C++ nicht Heap Factory-Objekt Erstellung mit geschützten Konstruktor und Kopie Konstruktor

Question

Wegen der RAII-Funktionen möchte ich meine Objekte nur auf dem Stapel platzierbar sein und auch als Objekt Erstellung an spezialisierte Fabriken delegiert werden möchte ich nicht ocpy Konstruktor zugänglich sein benutzen.

Also habe ich so etwas getan.

template<typename Product, Args ... > 
class Creator : public Product 
{ 
    public: 
     static Product create(Args ... args) 
     { 
      return Product(args ...); 
     } 
}; 

class ProtectedClass 
{ 
     ProtectedClass(const ProtectedClass& aThat)=delete; 
     ProtectedClass& operator=(const ProtectedClass& aThat)=delete; 
    protected: 
     ProtectedClass(){} 
}; 

class Spawner 
{ 
    public: 
     ProtectedClass getProtectedClass() 
     { 
      return Creator<ProtectedClass>::create(); 
     } 
} 

int main() 
{ 
    Spawner spawner; 
    //I need protectedClass to be enclosed within this frame 
    ProtectedClass protectedClass = spawner.getProtectedClass(); // err copy constructor is delted 
} 

Ich kann

template<typename Product, Args ... > 
class Creator : public Product 
{ 
    public: 
     Creator(Args ... args) : product_(args ...){} 
     Product& get() const 
     { 
      return product_; 
     } 
    private: 
     Product product_; 
}; 

class Spawner 
{ 
    public: 
     std::unique_ptr<Creator<ProtectedClass>> getProtectedClassCreator() 
     { 
      return new Creator<ProtectedClass>(); 
     } 
} 

int main() 
{ 
    Spawner spawner; 
    std::unique_ptr<Creator<ProtectedClass>> creator = std::move(spawner.getProtectedClassCreator()); 
    ProtectedClass& protectedClass = creator->get(); 
} 

wie diese etwas tun, aber es scheint nicht richtig zu sehen.

Was sind andere Möglichkeiten, damit umzugehen?

Answer 1

Das würde ich tun, um Kopien zu löschen, Bewegungen zu ermöglichen und Konstruktion über jede Klasse zu ermöglichen, die einen Konstruktionsschlüssel erstellen kann.

// forward declare any factories 
class Spawner; 

struct ProtectedClass 
{ 
    class PermissionKey { 
     // this is a private constructor 
     PermissionKey() {}; 

     // make friends of the factories 
     friend Spawner; 
    }; 

    // all this is now public. 
    // because we have declared a constructor, the default constructor 
    // is deleted.  
    ProtectedClass(PermissionKey) {} 

    // disable copies 
    ProtectedClass(const ProtectedClass& aThat)=delete; 
    ProtectedClass& operator=(const ProtectedClass& aThat)=delete; 

    // enable moves so the factory can return it 
    ProtectedClass(ProtectedClass&& aThat)=default; 
    ProtectedClass& operator=(ProtectedClass&& aThat)=default; 
}; 

class Spawner 
{ 
public: 
    ProtectedClass getProtectedClass() 
    { 
     // construct our spawned object - we can create keys 
     return ProtectedClass(ProtectedClass::PermissionKey()); 
    } 
}; 

int main() 
{ 
    Spawner spawner; 
    //I need protectedClass to be enclosed within this frame 
    auto protectedClass = spawner.getProtectedClass(); // ok now 
}