C++: pure virtual assignment operator

Question

why if we have pure virtual assignment operator in a base class, then we implement that operator on the derived class, it give linker error on the base class?

currently I only have the following explanation on http://support.microsoft.com/kb/130486 , it said that the behavior is by design since normal inheritance rules does not apply.

it is not clear for me, why is it generate linker error by design? can someone give me more clear explanation about this?

edit: added my simplified code of which the error occured:

class __declspec(dllexport) BaseClass {
public:
    int memberA;
    virtual BaseClass& operator=(const BaseClass& rhs) = 0;
};

class __declspec(dllexport) DerivedClass : public BaseClass {
public:
    int memberB;
    DerivedClass():memberB(0) {}
    virtual BaseClass& operator=(const BaseClass& rhs) {
        this->memberA = rhs.memberA;
        this->memberB = 1;
        return *this;
    }
};

int main(void)
{
    DerivedClass d1;
    DerivedClass d2;

    BaseClass* bd1 = &d1;
    BaseClass* bd2 = &d2;

    *bd1 = *bd2;
}

the code will compile with no errors without __declspec(dllexport) and/or without pure virtual operator= declaration on base class.

without __declspec(dllexport) after assignment of *bd1 = *bd2;, d1::memberB is 1, but with __declspec(dllexport) d1::memberB is left unchanged

with __declspec(dllexport), and without pure virtual declaration, after assignment of *bd1 = *bd2;, d1::memberB is left unchanged

Answer 1

operator= is not inherited. Your code is meaningless in C++, so compilers are free to issue any error they want for it.

From the KB article you pointed to: http://support.microsoft.com/kb/130486

Since operator= is not inherited, any declaration of operator= in the base class is unused and unnecessary. Do not declare the operator= in the base class.

It's probably just a side-effect of how they compile, and they are just letting you know that they don't consider it a bug, so there is no need to fix it. "By design" doesn't necessarily mean that they specifically decided that this linker error is the right error message to give for this situation -- the code is wrong, you get an error, so from their point of view -- they're done.

Answer 2

In the example code:

class A
{
public :
   // To workaround LNK2001, comment the following line.
   virtual const A& operator=( const A& f ) = 0;
};

class B : public A
{
public :
   const A& operator=( const A& g ) {return g;}
};

B aB1, aB2;

int /*void*/ main( void )
{
   aB2 = aB1;
}

the line aB2 = aB1 does not call const A& B::operator=(const A&), but instead calls the automatically supplied B& operator=(const B&); which in turn uses the assignment operator for assigning the base portion of the class. But when it comes to linking, it turns out that that was never implemented.