Is there a way, using templates, to prevent a class from being derivable in C++

I need to prevent a class from being derived from so I thought to myself, this is something that Boost is bound to have already done. I know they have a noncopyable, they must have a nonderivable...

Imagine my surprise when I couldn't find it....

That got me thinking.. There must be a reason. Maybe it isn't possible to do using templates..

I'm sure if it was easy it's be in the boost libraries.

I know how to do it without using templates, i.e. using a base class with a private constructor i.e.

class ThatCantBeDerived;  // Forward reference

class _NonDeriv
{
    _NonDeriv() {}
    friend class ThatCantBeDerived;
};

class ThatCantBeDerived : virtual public _NonDeriv
{
public:
    ThatCantBeDerived() :
      _NonDeriv()
    {
    }
};

Or something like this..

Maybe it's the forward reference that causes the problem, or maybe there is开发者_C百科n't a portable way to achieve it..

Either way, I'm not sure why it isn't in boost..

Any ideas?

---

http://www.parashift.com/c++-faq-lite/strange-inheritance.html#faq-23.11

---

There is no way in C++ of preventing derivation - you cannot prevent this situation:

class A {};

class B : public A {};

However, there are several ways of preventing instantiation of objects of type B. Whether this is worth the trouble is debatable. I would prefer to document that the class A is not intended for derivation, and give it a non-virtual destructor.

Also, note that the name _NonDeriv is reserved in C++ for the implementation, as are all names that begin with an underscore and an uppercase letter. You are not allowed to create such names in your own code.

---

Under the current spec, it is explicitly forbidden to "friend" a template argument, so templatizing your example would make it not standards compliant. Boost probably would not want to add something like that to its libraries. I believe this restriction is being relaxed in Ox however, and there are workarounds for compilers.

---

Adobe has a not-perfect solution for this using templates.

The problem there is that since templates cannot declare argument-dependent friends [*] it relies on the constructor being protected instead of private. It is a partial solution in that it will trigger a compiler error when someone mistakenly decides to derive from your class, but it is not a complete solution since someone intentionally can force the inheritance.

template <typename SealedClass>
class seal
{
protected:
   seal() {}
};

class Sealed : private virtual seal<Sealed>
{
//...
};

class NaiveExtension : public Sealed { // fails
   NaiveExtension() {} // NaiveExtension cannot call seal<Sealed> constructor
};

class BreakingExtension : public Sealed, private virtual seal<Sealed> {
   BreakingExtension() : seal<Sealed>(), Sealed() {} // now it can
};

The advantage is that it can be templated (the adobe library actually defines a macro that will hide the 'private virtual' from the casual reader). The disadvantage is that it can be broken.

Then again, you can always do what C++FAQ suggests for some questions on blocking some functionalities:

'how can I inhibit people from...': write a comment not to do it

'but how do I really inhibit others from...': write a comment: You will be fired if...

'but how do I actually block it in case they don't follow the comment?': fire them

[*] This restriction will be taken away with the upcoming standard, whenever available, whenever implemented in compilers...

---

Easy:

Make all the constructors private:
Then nobdy can derivce from you. Of course this adds othe problems like you can not instanciate a variable of the object, but there are workarounds for that using public static member methods and friends:

#include <memory>
class InstnaceCantDeriveFromMe;
class CantDeriveFromMe
{
    private:
        friend class InstnaceCantDeriveFromMe;
        CantDeriveFromMe()
        {}

    public:
        static std::auto_ptr<CantDeriveFromMe>  getDynamicObj()
        {
            return std::auto_ptr<CantDeriveFromMe>(new CantDeriveFromMe());
        }
};

class Plop: public CantDeriveFromMe
{
};

class InstnaceCantDeriveFromMe
{
    private:
        CantDeriveFromMe  instnace;
    public:
        CantDeriveFromMe& get() {return instnace;}
};

int main()
{
    std::auto_ptr<CantDeriveFromMe>  a =     CantDeriveFromMe::getDynamicObj();
    InstnaceCantDeriveFromMe         b;


    // This fails to compile:
    Plop                             c; 
}

---

Maybe turn your example into a template, using CRTP - the curiously recurring template pattern:

template <typename T>
_NonDeriv
{
   _NonDeriv() {}
   friend class T;
};

class ThatCantBeDerived : virtual public _NonDeriv<ThatCantBeDerived>
{
public:
    ThatCantBeDerived() :
      _NonDeriv()
    {
    }
};

Might work...