I am trying to create a pure virtual base class (or simulated pure virtual)
my goal:
- User can't create instances of BaseClass.
- 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?
Best Answer
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:
Base *clone()
method, that will be implemented to doreturn new Derived(this)
in each concrete subclass. You should probably wrap that inunique_ptr
orshared_ptr
immediately to avoid leaking the copies.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.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 tonew
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.