Prevent class inheritance in C++

Question

Recently one of my friend asked me how to prevent class inheritance in C++. He wanted the compilation to fail.

I was thinking about it and found 3 answers. Not sure which is the best one.

1) Private Constructor(s)

class CBase
{

public:

 static CBase* CreateInstance() 
 { 
  CBase* b1 = new CBase();
  return b1;
 }

private:

 CBase() { }
 CBase(CBase3) { }
 CBase& operator=(CBase&) { }


};

2) Using CSealed base class, private ctor & virtual inheritance

class CSealed
{

private:

 CSealed() {
 }

 friend class CBase;
};


class CBase : virtual CSealed
{

public:

 CBase() {
 }

};

3) Using a CSealed base class, protected ctor & virtual inheritance

class CSealed
{

protected:

 CSealed() {
 }

};

class CBase : virtual CSealed
{

public:

 CBase() {
 }

};

All the above methods make sure that CBase class cannot be inherited further. My Question is:

1. Which is the best method ? Any other methods available ?

2. Method 2 & 3 will not work unless the CSealed class is inherited virutally. Why is that ? Does it have anything to do with vdisp ptr ??

PS:

The above program was compiled in MS C++ compiler (Visual Studio). reference : http://www.codeguru.com/forum/archive/index.php/t-321146.html

Solution 1

As of C++11, you can add the final keyword to your class, eg

class CBase final
{
...

The main reason I can see for wanting to do this (and the reason I came looking for this question) is to mark a class as non subclassable so you can safely use a non-virtual destructor and avoid a vtable altogether.

Solution 2

You are going through contortions to prevent further subclassing. Why? Document the fact that the class isn't extensible and make the dtor non-virtual. In the spirit of c, if someone really wants to ignore the way you intended this to be used why stop them? (I never saw the point of final classes/methods in java either).

//Note: this class is not designed to be extended. (Hence the non-virtual dtor)
struct DontExtened
{
  DontExtened();
  /*NOT VIRTUAL*/
  ~DontExtened();
  ...
};

Solution 3

1) is a matter of taste. If I see it correctly, your more fancy 2nd and 3rd solutions move the error in certain circumstances from link time to compile time, which in general should be better.

2) Virtual inheritance is needed to force the responsibility to initialize the (virtual) base class to the most derived class from where the base class ctor is no longer reachable.

Solution 4

To answer your question, you can't inherit from CBase because in virtual inheritance a derived class would need to have direct access to the class from which it was inherited virtually. In this case, a class that would derive from CBase would need to have direct access to CSealed which it can't since the constructor is private.

Though I don't see the usefulness of it all (ie: stopping inheritance) you can generalize using templates (I don't think it compiles on all compilers but it does with MSVC)

template<class T>
class CSealed
{
    friend T;    // Don't do friend class T because it won't compile
    CSealed() {}
};

class CBase : private virtual CSealed<CBase>
{
};

View more solutions

Comments

[Manuel]

I think the point in Java is that the JIT compiler can optimize calls to virtual methods if the class is final

[KitsuneYMG]

@Manuel. I understand the jvm may like it, but there should be a easy way to undo that w/o changing the source. @ReallyOverride?

[Jagannath]

It has to be class CBase : private virtual CSealed<CBase>. Otherwise, CBase can be derived.

[josesuero]

That's getting sidetracked a bit. In Java, the final keyword makes sense because all functions are virtual by default, and so there's a lot to gain by allowing the JIT compiler to perform these optimizations. In C++, there'd be nothing to gain from a similar mechanism to prevent subclassing, which is why the language doesn't supply a mecehanism for doing it.

[Ed S.]

Sanity ftw. Let people shoot themselves in the foot if they want to.

[Nemanja Boric]

There is another good reason and that's preventing derived classes to break the contract of the immutable classes.

[Peter N Lewis]

@Nemanja Boric that would apply to any subclass and any contract, not just mutability. Any subclass can potentially break any implied contracts of the class - that isn't really a good reason for disallowing all subclasses. For an immutable object, what if you want to add a derived value, for example FullName() from FirstName() and LastName() methods, or perhaps a specific hash function.

[Thomas Eding]

-1: Such contortions are for accidents. Also, this does not answer the OP's question (even if it may (it's not) be an X-Y problem). Your answer is equivalent to make everything public and document every logically private item as such. My rule is let the compiler help you not make mistakes when possible.

[KitsuneYMG]

@ThomasEding Well, you can think that, but you're dead wrong. This is the idiomatic way in c++ 2011. My rule is to write code that can be expected to be well understood by the wider community of coders for a language. Also, if your compiler does not warn you about inheriting from a class with a non-virtual dtor, you need a new one.

[Thomas Eding]

I thought C++11 had final for that very purpose. Thus I would expect that to be the idiomatic way to do so in C++11. Why use comments when you have a language feature to do exactly what the comments try (but fail) to enforce?

[Tommy Andersen]

I agree with @ThomasEding the final identifier, is the better option. It allows the compiler to assist you, and documents very precisely that this class is not intended for inheritance. If you choose to take the path of comments, then you would have the programmer look up the source, and interpret the comment. Which can be multiple lines, perhaps even within a larger commenting block. By using final the IDE can help when at first attempting to inherit from the class. Besides using final the developer knows where to look, even if he/she is not used to the programming style used.

[Thomas Eding]

This answer has other problems in addition, including deriving from a derived class with a virtual destructor; and legitimate non-virtual subclassing (take std::unary_function for instance). stackoverflow.com/questions/7403883/…

[Andrew Lazarus]

-1. My compiler doesn't read documentation, and sometimes my colleagues don't either. Enterprise-quality software outsources constraints to the code.

[lmat - Reinstate Monica]

The reason I'm using final on my struct is because I use it by value in a std::vector. If someone extends it and gets one in the std::vector, that's real bad.

[Peter Cordes]

There's been an answer pointing out the C++11 final keyword since 2012; it's currently highest voted by a factor of ~6