Restricting Access to C++ Constructor and Destructor

Question

Forgive me if this has already been asked, I didn't find any answers to my specific question.

I have a class in a library I'm making that I want certain classes to be able to create and destroy, and other classes to be able to access other public functions. Having a friend class is not what I want either as the friend class will get access to member variables and member functions which I don't want. I stumbled upon this idiom which almost works, except for the destructor since it can't take additional parameters. With that idiom, I get:

class B;
class A
{
    public:
        class LifecycleKey
        {
            private:
                LifecycleKey() {}
                friend class B;
        };

        A(LifecycleKey); // Now only class B can call this
        // Other public functions

    private:
        ~A(); // But how can I get class B to have access to this?

        void somePrivateFunction();

        // Members and other private functions
};

As alluded to in the above code, the solution doesn't allow only class B to have access to the destructor.

While none of the above issues are deal breakers by any stretch as I can always just make ctor and dtor public and just say "RTFM".

My question is:

Is there is some way to limit access to ctor and dtor to specific classes (but only the ctor and dtor) while adhering to more well known syntax (having stuff be on the stack if people want, destroying via delete , etc.)?

Any help is greatly appreciated!

SOLUTION

in A.h

class B;
class A
{
    protected:
        A() {}
        virtual ~A() {}
        A(const A&); // Implement if needed
        A(A&&); // Implement if needed

    public:
        // Public functions

    private:
        void somePrivateFunction();

        // Members and other private functions
};

in B.h

class B
{
    public:
        B();
        ~B();
        const A* getA() const;

    private:
        A* m_a;
}

in B.cpp

namespace {
    class DeletableA : public A {
        public:
            DeletableA() : A() {}
            DeletableA(const DeletableA&); // Implement if needed
            DeletableA(DeletableA&&); // Implement if needed
            ~DeletableA() {}
    }
}

#include B.h
B::B() : m_a(new DeletableA()) {}
B::~B() { delete static_cast<DeletableA*>(m_a); }
const A* B::getA() const { return m_a; }

Alternatively, if the DeletableA class is needed in B.h or A.h (due to inlining, templating, or desire to have all class A related classes in A.h), it can be moved there with a "pass key" on the constructor so no other classes can create one. Even though the destructor will be exposed, no other class will ever get a DeletableA to delete.

Obviously this solution requires that class B know to make instances of Deletable A (or to make the class in general if it isn't exposed in A.h) and only store A* that are exposed via public functions, but, it is the most flexible set up that was suggested.

While still possible for some other class to make a subclass of class A (since class A isn't "final"), you can add another "pass key" to the constructor of A to prevent such behavior if you wish.

Answer 1

Use a mediator-class:

class mediator;
class A
{
/* Only for B via mediator */
    A();
    ~A(); // But how can I get class B to have access to this?
    friend class mediator;
/* Past this line the official interface */
public:
    void somePrivateFunction();
protected:
private:
};

class B;
class mediator
{
    static A* createA() { return new A{}; }
    static void destroyA(const A* p) { delete p; }
    // Add additional creators and such here
    friend class B;
};

Thus, only the mediator, as part of the interface to B, gets full access.

BTW: Instead of restricting access to the dtor, you might get happier overloading new and delete and restricting access to them.
The advantage: Allocation on the stack is generally possible, if the variable is directly initialized without copying.

void* operator new(std::size_t);
void* operator new[](std::size_t);
void operator delete(void*);
void operator delete[](void*);
void operator delete(void*, std::size_t) noexcept;
void operator delete[](void*, std::size_t) noexcept;

Answer 2

For the goal that class B should be the only one able to instantiate and destroy objects of class A:

• For static and automatic variable, restricting access to the constructor is all that's needed, and you're already doing that.

• For dynamically allocated object you can restrict access to its deallocation functions, operator delete, and operator delete[], and leave the destructor public. This prohibits other code than B from deleting objects.

• For dynamically objects you can derive class A from an interface with protected virtual destructor or named self-destroy function, which has class B as friend. B can then destroy any dynamic A object by casting up to the interface that it has access to.

Code that explicitly calls the destructor deserves whatever it gets.

Remember, you're never building an impregnable defense against malicious code, you're just building a reasonable detection and compile time reporting of inadvertent incorrect use.

Answer 3

use shared_ptr

class K{
public:
    int x;
private:
    ~K(){}; 
     K(){};  
private:
    friend class K_Creater;
    friend class K_Deleter; 
};

struct K_Deleter{  void operator()(K* p) { delete p; }  };

struct K_Creater{ 
    static shared_ptr<K> Create(){ 
        return shared_ptr<K>(new K,  K_Deleter() ); 
    }
};



//K* p = new K;    prohibited
shared_ptr<K> p = K_Creator::Create();

another answer is：

#include <iostream>

class A
{
public:

    class Key
    {
    private:
        Key(){
            std::cout << "Key()" << std::endl;
        }
        ~Key(){
            std::cout << "~Key()" << std::endl;
        }
        friend class B;
    };

    A(Key key){
        std::cout << "A(Key key)" << std::endl;
    }
    void seti(){ i_=0;}
private:
    int i_;
};

class B{
public:
    static void foo(){

        A a{A::Key()};

        A* pa = new A( A::Key() );
        delete pa;

        static A sa({});

    }
};

int main(){

    B::foo();

    //A a{A::Key()};  prohibit
    //A* pa = new A( A::Key() );   prohibit
    //delete pa;   prohibit
    //static A sa({});   prohibit

    return 0;
}

Answer 4

My take:

Any class/function that has access to the constructor should also have access to the destructor.

You should make ~A() public since A() is public. Since no other client except B can use the constructor, they won't have the need to use the destructor anyway.

You can further limit who can access the destructor by declaring away the copy and move constructors, and the new and delete operators.

Update

Making the destructor public and declaring away the copy and move constructors seems to address all of your concerns. You don't even need to declare away the new and delete operators or their array variants.

Here's what I think should meet most of your needs.

class B;

class PassKey
{
   private:
      PassKey() {}
      ~PassKey() {}
   friend class B;
};

class A
{
   public:
      A(PassKey) {}
      ~A() {}

   private:
      // Declare away
      A(A const&);
      A(A&&);
};

Now, let's take a look at what B can have:

class B
{
   public:
      B() : a(PassKey()), ap(new A(PassKey())), ap2(new A(PassKey())) {}
      ~B() { delete ap; }

      A const& getA() const {return a;}

      A a;
      A* ap;
      std::shared_ptr<A> ap2;
};

It can have the following member data types:

1. Objects of type A.
2. Raw pointers to objects of type A.
3. Objects of type shared_ptr<A>.

Member functions of B can also create any of the above types of objects.

Other classes can't use objects of type A since they cannot construct one in any way. All the following attempts to use A in various forms fail.

struct C
{
   C() : a(PassKey()) {} // Can't construct an instance of A 
                         // since C doesn't have access to
                         // PassKey's constructor.
   A a;
};

struct D
{
   D() : a(new A(PassKey())) {} // Can't construct an instance of A 
                                // since D doesn't have access to
                                // PassKey's constructor.
   A* a;
};

struct E
{
   E(A const& a) : ap(new A(a)) {}  // Can't construct an instance of A 
                                    // since E doesn't have access to
                                    // A's copy constructor.
   A* ap;
};

class F
{
   public:
      F(A& a) : ap(new A(std::move(a))) {} // Can't construct an instance of A 
                                           // since F doesn't have access to
                                           // A's move constructor.
      A* ap;
};