How to prevent others create a new instance of your class on stack ?

Question

Suppose you write a class A, with constructor being private (to prevent others to create it on stack) then one day another developer add a new ctor, say A(int), and want to use inside main():

A a(1)

to create it on stack. How do you prevent that?

my solution:

Declare a public constructor

  A(void& input )
   {
 Cerr << “please do not create it on stack” << endl ; 
  exit(1);
   }

I am not sure it is correct ?

thanks

May I ask *why* you want to prevent this? Give us a compelling reason and we may give you a better implementation based on that. — Xeo, Oct 27 '11 at 00:43
@BenjaminLindley One of the points of C++ being so convoluted is to give people as many tools as possible to enforce rules of a codebase at compile-time. None of them are going to be perfect...you could argue that one shouldn't bother with `const` because someone who can edit your code could `const_cast` it away, but const-correctness catches a lot of mistakes anyway. There's nothing "silly" about wanting to use every trick in the book to help enforce the practices and protocols of your codebase and cut down on errors. And it's even possible to do so for this case...see my answer. — HostileFork says dont trust SE, Oct 27 '11 at 02:11
@HostileFork: except that in C++, whenever you can construct an object, you can construct it whenever you feel like. What's the big difference between `A a;` and `std::unique_ptr a;` ? I am all for compiler-enforcement, and the solution you presented is amusing and not too intrusive, but in this case it just does not really work. — Matthieu M., Oct 27 '11 at 06:46
@MatthieuM. Well there we go with the paint again :-/ Yes, there's not much difference if you just return a pointer from your factory method, but if you return a shared_ptr (for instance) there's a difference that this kind of thing could influence. — HostileFork says dont trust SE, Oct 27 '11 at 07:03

score 8 · Answer 1 · edited May 23 '17 at 11:44

As others say, you can't prevent people who can edit your class from making it do pretty much anything...BUT...

...if you want a slightly more compiler-enforceable method than a comment, you could inherit from a class which has no default constructor. Anyone writing a constructor would be (hopefully) led to take notice of it. You could make its name cue people into taking certain precautions.

Something like this:

class DoNotStackConstruct {
protected:
    DoNotStackConstruct(const char* dummy) {}
};

class A : protected DoNotStackConstruct {
private:
    A () : DoNotStackConstruct ("PLEASE make all A constructors private!") {
       // your code here
    }
public:
    static std::tr1::shared_ptr<A> newA() {
        return std::tr1::shared_ptr<A>(new A);
    }

/* ... a bunch of code ... */
/* ... then someone later adds the following ... */

public:
    A (int i) {
        // can't force them to make it private, but...
        // this won't compile without mentioning DoNotStackConstruct
    }
};

Once you start using C++11 there will be "delegating constructors", and this trick will have a bit less teeth:

Can I call a constructor from another constructor (do constructor chaining) in C++?

Then they'll be able to delegate to A() without visiting the source line and copying the "hey, don't make your constructor public!" text. But by default, they'll still get the compiler error the first time they try.

The `deleteA` method is completely unnecessary, the constructor is `private`, not the destructor. — Matthieu M., Oct 27 '11 at 06:43
@MatthieuM. Originally I had it returning a shared_ptr (which is the only reason I bother with private constructors) but I just paired it to "simplify" further. You're right though, so I'll axe that...tough to decide how much "paint" to use when filling in examples, and tough to decide when to actually bother with compiling it too :-/ — HostileFork says dont trust SE, Oct 27 '11 at 06:48

Michael Kristofik · Accepted Answer · 2011-10-27T13:17:14.273

Put in a comment that says something like this:

class A
{
    private:
        // This is private on purpose to prevent allocation on the stack.
        // We'll fire you if you ever write a new constructor that isn't private.
        A();
};

This comment is tongue-in-cheek (mostly) but it points to an important concept. Code conventions like disallowing stack allocation need to be enforced by peer review. As others have said, someone else could theoretically change the code however they want. But a good peer review process will help keep that in check. IMHO, that's far more cost effective than some clever compiler tricks that new hires might not necessarily understand.

Indeed, especially as whoever can add a public constructor can obviously modify *any* part of the class, including whatever mechanism implemented to prevent allocation on the stack. — André Caron, Oct 27 '11 at 13:21

score 5 · Answer 3 · answered Oct 27 '11 at 00:38

5

Clearly, you can't prevent it. If someone else can directly edit your code, then they can do whatever they want.

answered Oct 27 '11 at 00:38

Oliver Charlesworth

267,707
33
569
680

Certainly you're right in the general sense...but how helpful is this FGITW answer, really? See my comment on the question, and my answer. – HostileFork says dont trust SE Oct 27 '11 at 06:43

score 1 · Answer 4 · answered Oct 27 '11 at 01:46

I think the solution you want is the following steps.

Give a constructor 'private' access.
Make a non-member static function who creates a instance by new or malloc and returns it.
Use the function for creating an instance of the class.

I am sure these step may be a solution of your question.

How to prevent others create a new instance of your class on stack ?

4 Answers4