Simplification "Prevention of derived classes" in C ++

Question

Based on the assumption that there is a legitimate reason to prevent withdrawal from a class, Bjarne provides a solution here to answer the question "Can I stop people coming from my class?"

However, I thought:

class final { protected: final() { } // line 3 }; class B : private virtual final { }; class D : public B { // line 9 }; int main() { B b; D d; // line 14 } 

When you try to compile, you get:

 foo.cpp: In constructor 'D::D()': foo.cpp:3: error: 'final::final()' is protected foo.cpp:9: error: within this context foo.cpp: In function 'int main()': foo.cpp:14: note: synthesized method 'D::D()' first required here 

Does my solution work in all cases? IMHO, this is better because the final class is generic and does not require class foresight to prevent output from.

Answer 1

The solution is pretty bad, it can be improved with CRTP (adobe does this), but it will not be a complete solution. The problem with your code is that another programmer who does not want to break your contract (she is a good person), but does not know that she should not leave your class, may want to block others from her own class:

 class YourSealedClass : private virtual final {}; class HerSealedClass : public YourSealedClass, private virtual final { }; 

Please note that there is not even malicious intent, and the contract is violated. Improvement with CRTP will be:

 template <typename T> class seal { protected: seal(){} ~seal(){} }; class YourSealedClass : private virtual seal<YourSealedClass> {}; 

This will catch the previous error, as its code will look like this:

 class HerSealedClass : public YourSealedClass, private virtual seal<HerSealedClass> {}; 

And since it does not inherit from seal<YourSealedClass> , the compiler will catch up with it.

The problem with this approach is that it does not block the stubborn (or malicious) programmer:

 class MalignClass : public YourSealedClass, private virtual seal<YourSealedClass> {}; 

To become a child of the compaction class and as such gain access to your own class.

In C ++ 0x, I believe (I will have to double-check it) that they will raise the restriction that the template cannot make friends with the template argument, and this will be a good step in the generic type solution for the class sealant:

 template <typename T> class seal { friend class T; // illegal in C++03 seal() {}; ~seal() {}; }; class MySealedClass : private virtual seal<MySealedClass> {}; 

The advantage of this approach (currently not available) is that since the constructor and destructors are private, friends can instantiate the type. Since you use CRTP to inherit a specific instance that passes its own type as an argument, you tell the compiler that only you can actually create an instance of your base, and all parts fall right into place.

Answer 2

Try:

 class D : public B, public virtual final { };