Why did I get the error "error C2259: ... cannot instantiate abstract class"?

Question

Any help is appriciated. I'm working on a C++ factory pattern and i get this error.

1>c:\users\brian\documents\visual studio 2010\projects\cst276lab_3\guitar.hpp(456): error C2259: 'ElectricGuitarComponentFactory' : cannot instantiate abstract class

This is my code:

///////////////////////guitar class////////////////////

class Guitar

{

      private: std::string _name;

      protected: mutable std::auto_ptr< HeadStock > _HeadStock;
      protected: mutable std::auto_ptr< NeckStrap > _NeckStrap;
      protected: mutable std::vector< Bridge* > _Bridge;
      protected: mutable std::auto_ptr< Strings > _Strings;
      protected: mutable std::auto_ptr< Switches > _Switches;
      protected: mutable std::auto_ptr< GuitarBody > _GuitarBody;

      public: virtual void prepare() const = 0;

      private: Guitar( const Guitar& ); // Disable copy constructor
      private: void operator=( const Guitar& ); // Disable assignment operator

      protected: Guitar()
      {
      }
      public: virtual ~Guitar()
      {

         for( std::vector< Bridge* >::iterator iterator = _Bridge.begin();
         _Bridge.end() != iterator; ++iterator )
         {
            delete *iterator;
         }
         _Bridge.clear();

      }
      public: virtual void bake() const 
      {
         std::cout << "Bake for 25 minutes at 350" << std::endl;
      }
      public: virtual void cut() const 
      {
         std::cout << "Cutting the pizza into diagonal slices" << std::endl;
      }
      public: virtual void box() const
      {
         std::cout << "Place pizza in official PizzaStore box" << std::endl;
      }
      public: void setName( std::string name) 
      {
         _name = name;
      }
      public: std::string getName() const 
      {
         return _name;
      }
      public: std::string toString() const 
      {
    std::stringstream value; 
    value << "---- " << _name.c_str() << " ----" << std::endl;
    if( _HeadStock.get() != 0 ) 
    {
       value << _HeadStock->toString();
       value << std::endl;
         }
    if( _NeckStrap.get() != 0 ) 
    {
       value << _NeckStrap->toString();
       value << std::endl;
    }
    if( _Strings.get() != 0 ) 
    {
       value << _Strings->toString();
       value << std::endl;
    }
    if( _GuitarBody.get() != 0 )
    {
       value << _GuitarBody->toString();
       value << std::endl;
    }

    if( _Switches.get() != 0 )
    {
       value << _Switches->toString();
       value << std::endl;
    }

    if( _Bridge.size() != 0 )
    {
       for( std::vector< Bridge* >::iterator iterator = _Bridge.begin(); 
            _Bridge.end  () != iterator; ++iterator ) 
       {
          value << ( *iterator )->toString() << ", ";
       }
       value << std::endl;
    }

    return value.str();
      }
};


//////////////////////////////////////Class guitar store////////////////


class GuitarStore 

{

      protected: GuitarStore() 
      {
      }
      public: virtual ~GuitarStore() = 0 
      {
      }
      public: std::auto_ptr< Guitar > orderGuitar( std::string type ) const 
      {
         std::auto_ptr< Guitar > guitar( createGuitar( type ) );
         std::cout << "--- Making a " << guitar->getName() << " ---" << std::endl;
         guitar->prepare();
         guitar->bake();
         guitar->cut();
         guitar->box();
         return guitar;
      }
      public: virtual std::auto_ptr< Guitar > createGuitar( std::string type ) const = 0;
};


//////////////////////////////////guitar component factory////////////////////////////////



class GuitarComponentFactory 

      {
         public: virtual HeadStock* createHeadStock() const = 0;
         public: virtual NeckStrap* createNeckStrap() const = 0;
         public: virtual Strings* createStrings() const = 0;
         public: virtual std::vector< Bridge* > createBridge() const = 0;
         public: virtual Switches* createSwitches() const = 0;
         public: virtual GuitarBody* createGuitarBody() const = 0;
         public: virtual ~GuitarComponentFactory() = 0 {}
      };


///////////////////////////// electric guitar///////////////////

class ElectricGuitar : public Guitar

{

      private: mutable std::auto_ptr< GuitarComponentFactory > _ingredientFactory;

      public: explicit ElectricGuitar( GuitarComponentFactory* ingredientFactory ) :
      _ingredientFactory( ingredientFactory ) 
      {
         assert( ingredientFactory );
      }
      public: void prepare() const 
      {
         std::cout << "Preparing " << getName().c_str() << std::endl;
         _HeadStock = std::auto_ptr< HeadStock>( _ingredientFactory->createHeadStock() );
         _NeckStrap = std::auto_ptr< NeckStrap>( _ingredientFactory->createNeckStrap() );
         _Strings = std::auto_ptr< Strings>( _ingredientFactory->createStrings() );
         _Switches= std::auto_ptr< Switches>( _ingredientFactory->createSwitches() );
         if( _Bridge.empty() ) 
            _Bridge = _ingredientFactory->createBridge();
      }
};


//////////// electric guitar component factory////////////////


class ElectricGuitarComponentFactory : public GuitarComponentFactory 

{

      public: HeadStock* createHeadStock() const 
      {
         return new AngledHeadStock();
      }
      public: NeckStrap* createNeckStrap() const 
      {
         return new LeatherNeckStrap();
      }
      public: Strings* createStrings() const 
      {
         return new NylonStrings();
      }
      public: std::vector< Bridge* > createBridge() const 
      {
         std::vector< Bridge* > bridge;
         bridge.push_back( new ChromeBridge() );
         return bridge;
      }

      public: Switches* createSwithes() const
      {
         return new SPDT_Switches();
      }

      public: GuitarBody* createGuitarBody() const 
      {
         return new HollowGuitarBody();
      }

};


//////////////////// electric guitar srore  ////////////////


class ElectricGuitarStore : public GuitarStore 

{

      public: std::auto_ptr< Guitar > createGuitar( std::string item ) const
      {
         std::auto_ptr< Guitar > guitar( 0 );
         GuitarComponentFactory* ingredientFactory = new ElectricGuitarComponentFactory();
         if( item.compare( "Electric" ) == 0 ) 
         {
       guitar = std::auto_ptr< Guitar >( new ElectricGuitar( ingredientFactory ) );
       guitar->setName( "Electric GuitarBody" );
            return guitar;
         }
      }
};

any help would be nice thanks ahead of time...=)

You need to read up on [`const`-correctness](http://www.gotw.ca/gotw/006.htm). There's no need to make every single function `const` and almost every single data member `mutable`. There's a lot of other things that left much to be desired. Like why is your `Guitar` class making pizzas? — In silico, Feb 14 '11 at 06:39
-Don't make everything mutable. Don't use auto_ptrs as members, they probably don't behave like you would expect. - No need to write public/protected/private in front of each and every member/method. — Frank Osterfeld, Feb 14 '11 at 07:31
Yesterday someone had the same problem : http://stackoverflow.com/questions/4985993/inheritance-of-abstract-class/4986001#4986001 — Nawaz, Feb 14 '11 at 08:03
Why are you putting an access specifier on everything? It's noisy and unorthodox. And as has been mentioned, your code is unnecessarily over-complex and strange. Do you have a [C++ book](http://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list) to read? — GManNickG, Feb 14 '11 at 17:00
@mmmmmmmm I am getting the just a one line massage in vs 2017 output windows. To know which methods are not implemented how do I open a detailed out file or how do I configure VS to get more detailed output. — qqqqq, Sep 19 '18 at 18:24

score 4 · Answer 1 · answered Feb 14 '11 at 06:45

To fix the specific problem, you need to declare a destructor for ElectricGuitarComponentFactory because you have declared the destructor of the base class as a pure virtual function. Why you have declared the base class destructor as pure virtual, I don't know; it really doesn't make any sense to do that. The destructor should be declared virtual, but not as pure virtual.

Also, the syntax you have used,

public: virtual ~GuitarComponentFactory() = 0 {}

is ill-formed. You cannot declare a pure virtual function and provide a definition for it in the class definition. If you want to provide a definition for a pure virtual function, you must do so outside of the class definition. The compiler you are using, Visual C++, is a bit lenient with respect to this rule.

Xeo · Answer 2 · 2011-02-14T06:55:58.163

2

class GuitarComponentFactory 
  {
     public: virtual ~GuitarComponentFactory() = 0 {}
  };

In your derived ElectricGuitarComponentFactory you don't provide a destructor, hence it's still an abstract class.

edited Feb 14 '11 at 06:55

answered Feb 14 '11 at 06:42

Xeo

129,499
52
291
397

score 0 · Answer 3 · answered Feb 14 '11 at 06:43

ElectricGuitarComponentFactory inherits GuitarComponentFactory ....

When you inherit an abstract class (abstract = has pure virtual methods), then you need to override all those methods.

in GuitarComponentFactory you got 7 methods, and in ElectricGuitarComponentFactory you only declared 6.

You forgot to override the destructor.

Why did I get the error "error C2259: ... cannot instantiate abstract class"?

3 Answers3

Linked

Related