Why operator = doesn't get inherited from a template class

Question

I have following template code:

class ClassName{};

template 
class TemplatePtr
{
public:
    void operator=(T* p)
    {

    }
};

class Temp         


        

Answer 1

operator = is always hidden by the derived class implementation unless explicit using declaration is provided. This is true for both class templates and ordinary classes.

BTW, your declaration of operator= is very nonstandard. It is usually declared so for a class 'A'.

A& operator=(A const &);

Here is something that may be what you are looking for (and compiles)

template <class T> 
class TemplatePtr 
{ 
public: 
    TemplatePtr& operator=(TemplatePtr const &) 
    {return *this;} 
}; 

template<class T>
class TemplatePtr_ClassName: public TemplatePtr<T> 
{ 
public:
   ~TemplatePtr_ClassName(){};
   TemplatePtr_ClassName& operator=(TemplatePtr_ClassName const &that){
      TemplatePtr<T>::operator=(that);        // invoke base class assignment operator
      return *this;
   }
}; 


int main() 
{ 
    TemplatePtr_ClassName<int> data; 
    data = *new TemplatePtr_ClassName<int>; 
    // delete stuff
} 

Answer 2

It gets inherited. However, the compiler-generated assignment operator for TempaltePtr_ClassName hides the inherited operator. You can make it visible by adding

using TempaltePtr<ClassName>::operator=;

to your derived class.