Question

Need help with implementing a pure abstract class via inheritance, using namespace to wrap all my classes to avoid conflict with others.

I have been able to build and run the code successfully if I remove namespace wrapper from my abstract class and all classes that inherit from my pure abstract class.

It seems like Visual Studio 2010 compiler is complaining that despite all classes are in the same namespace, the abstract class’s pure abstract method is not implemented.

Any help would be much appreciated.

//IBaseClass.h

//forward declaration
class ConcreteClass;

//namespace MyCustomNamespace
//{
    class IBaseClass
    {
    public:
        virtual ~IBaseClass() { /*virtual destructor*/ }
    //Behaviours...
        virtual bool Method001( const ConcreteClass &cc ) = 0;
        //virtual bool Method002(/*some input*/) = 0;
    };
//} /*NAMESPACE*/

//-----------------------------------------
//ParentClass.h

//namespace MyCustomNamespace
    //{
    class ParentClass : virtual public IBaseClass
    {
    private:
        int a;

    public:
        virtual ~ParentClass() { /*virtual destructor*/ }

        //getter-setter implemented in ParentClass.cpp file...
        void setA(const int aa); 
        const int getA() const; 
    };
//} /*NAMESPACE*/


//-----------------------------------------
//ConcreteClass.h

//namespace MyCustomNamespace
//{
    class ConcreteClass: public ParentClass 
    {
    private:
        int b;

    public:
        virtual ~ConcreteClass() { /*virtual destructor*/ }

        //getter-setter...
        void setB(const int bb);             
        const int getB() const;

        bool Method001( const ConcreteClass &cc ); //re-declaring IBase abstract method...
    };
//} /*NAMESPACE*/


//-----------------------------------------
//ConcreteClass.cpp


//namespace MyCustomNamespace
//{
    void ConcreteClass::setB(const int bb) { this->b = bb; } 
    const int ConcreteClass::getB() const { return this->b; }

    bool ConcreteClass::Method001( const ConcreteClass &cc )
    {
        //implementation code goes here...
        return false;
    }
//} /*NAMESPACE*/

Answer 1

The problem is that your forward class has been declared in another namespace (specifically, the global namespace). Thus, the virtual to override is a different symbol with a different parameter type.

As written, the compiler matches ConcreteClass to the forward declaration it sees in the global namespace when declared in the base:

virtual bool Method001( const ConcreteClass &cc ) = 0;

When you declare Method001 in ConcreteClass:

virtual bool Method001( const ConcreteClass &cc );

the compiler matches cc to MyCustomNamespace::ConcreteClass because that is a more accurate match.

To resolve the issue, just place your forward declaration in the proper namespace:

namespace MyCustomNamespace {
  class ConcreteClass;
}