Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

I am trying to create a pure virtual base class (or simulated pure virtual)

my goal:

  1. User can't create instances of BaseClass.
  2. Derived classes have to implement default constructor, copy constructor, copy assignment operator and destructor.

My attempt:

class Base
{
public:
    virtual ~Base() {};
    /* some pure virtual functions */
private:
    Base() = default;
    Base(const Base& base) = default;
    Base& operator=(const Base& base) = default;
}

This gives some errors complaining that (for one) the copy constructor is private. But i don't want this mimicked constructor to be called.
Can anyone give me the correct construction to do this if this is at all possible?

share|improve this question
    
It doesn't really matter if they get called or not (but it would provide useless extra overhead). The virtual base class just has to adhere to the 2 rules I stated at the top. –  Minion91 Oct 1 '12 at 9:35
    
If the derived class should be copyable, the base class has to be copyable and the copy constructor has to be available for calling from derived class, so at least protected. The same goes for default constructor and operator=. –  Jan Hudec Oct 1 '12 at 10:15
    
@CodingMash: Sure you can declare constructor private. It means that only a method of the class can construct instance with that constructor. It's done either for some constructors (to make the class non-copyable, though C++11 has = delete for that) or for all of them to restrict construction to a factory function. But such class is not inheritable, because the subclass constructor needs to call the base class constructor and it need to be at least protected for that. Making all constructors protected makes the class abstract. –  Jan Hudec Oct 1 '12 at 11:32
    
The second requirement looks unreasonable to me. It's up to the subclass author whether they want their class to be copyable and/or assignable. What is the reason behind that requirement? –  Jan Hudec Oct 1 '12 at 11:41
    
I want the user be able to create child classes, override some virtual functions and send them to a framework. The framework needs to keep that object and send out copies. The destruction of the objects will also be handled by the framework. The assignment operator is for the moment just to adhere to the rule of three. –  Minion91 Oct 1 '12 at 12:00

3 Answers 3

up vote 6 down vote accepted

The requirement looks wrong. The reason is that virtual methods and copy constructors don't work together. Virtual methods are useful if you use the object polymorphically, that is via reference/pointer to a base class. But copy constructor always constructs object of the static type it is written as, so if you give it polymorphic object, it will only create the base class, not the subclass you wanted. This is called slicing.

So you want to either:

  • Have a templated framework that knows the type at compile time and uses copy-constructor. But this does not need any virtual methods, nor for that matter a common base type, since the code will be compiled with the specific template parameter. Compiler will complain if the type substituted does not support the operations the template tries to use, but you can slightly improve diagnostics by using some explicit checks, e.g. from Boost.Concept Check.

  • Have a framework using polymorphic objects with base class, but that can't create copies with copy constructor, because it does not know the type to construct. There are three ways out:

    1. Have a pure virtual Base *clone() method, that will be implemented to do return new Derived(this) in each concrete subclass. You should probably wrap that in unique_ptr or shared_ptr immediately to avoid leaking the copies.
    2. Instead of copies, hand out references or smart pointers, probably shared_ptr in this case. It would probably be either const references/smart pointers or typed with interface that only contains methods that can't affect invariants in the framework.
    3. Make the method that inserts the objects a template, that would construct a cloner and store it along with the object. Cloner is a function template<typename T> Base *clone(const Base *obj) { return new T(dynamic_cast<const T &>(*obj); } (you can have a functor or a class with multiple helper methods like this). To ensure you really have correct type, the insert method should probably wrap the call to new as well similar to e.g. make_shared.

By the way, nothing of this has anything to do with rule of three. Because rule of three says that if default copy constructor, default assignment operator or default destructor are not good enough for the class, than none of them is. But not because compiler would require it, but because the logic probably does. But for most classes that want to be copyable they are good enough. Because in most cases you hide the resource handling in some smart pointer and just let the default copy/assignment/destructor call to it.

share|improve this answer
    
Thanks a lot for that! –  Minion91 Oct 1 '12 at 13:13

I am trying to create a pure virtual base class (or simulated pure virtual)

Sure:

User can't create instances of BaseClass.

Easy make the destructor virtual and pure

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

Now you can not instantiate a member of Base.

Derived classes have to implement default constructor, copy constructor, copy assignment operator and destructor.

You can't force any of that.
If the user does not provide any of the above the compiler will automatically generate public versions for you. But by making them private you have basically made any derived class non copyable (even if the create their own versions).

But in g++ there are some warnings to help you.
If you set -Weffc++ and also set -Werror It should generate a compile time error if you do not obey the rule of three.

share|improve this answer

As the Rule of the Three says...

If you need to explicitly declare either the destructor, copy constructor or copy assignment operator yourself, you probably need to explicitly declare all three of them.

In your example of abstract class with the inheritance hierarchy, you would have to make the destructor, copy constructor and the copy assignment operator your self. Do not declare either of them as private as you restrict their usage out of the class.

class Base
{
 /* some pure virtual functions */
 public:
     Base() ;
     Base(const Base& base) ;
     Base& operator=(const Base& base) = default;
     virtual ~Base() {};
} ;

As a matter of fact, assignment operator is not passed on in inheritance.

share|improve this answer
    
This does not prevent that classes can omit certain function implementations –  Minion91 Oct 1 '12 at 9:38
    
can you make your point clear? I am unable to get it –  Coding Mash Oct 1 '12 at 9:41
    
I want to make sure that someone who uses my classes has to implement those 4 methods –  Minion91 Oct 1 '12 at 9:43
    
You mean you want that someone who derives the classes from Base creates implementations in the respective child classes as well? –  Coding Mash Oct 1 '12 at 9:44
    
yes, exactly that –  Minion91 Oct 1 '12 at 9:45

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.