Wie kann sichergestellt werden, dass nur eine bestimmte Klasse eine Instanz einer anderen Klasse erstellt?

Question

Wie kann ich die Instanziierung einer Klasse nur innerhalb einer bestimmten Klasse einschränken?

Ich möchte es nicht in einer einzigen Datei beschränken, so dass anonymer Namespace keine Option für mich ist.

Bitte beachten Sie, dass ich die Deklaration der zu beschränkenden Klasse für die ganze Welt sichtbar machen möchte, nur dass nur ein bestimmter Kandidat aus der ganzen Welt diese nur instanziieren kann.

Wie kann ich das erreichen?

Answer 1

könnten Sie übernehmen die passkey pattern (aufgenommene Kredite von Rakete1111 dem Beispiel):

class pass_key { friend class allowed_t; pass_key() {} }; 

struct restricted_t 
{ 
    restricted_t(pass_key); 
}; 

class allowed_t 
{ 
public: 
    allowed_t() : yes(pass_key()) {} // ok, allowed_t is a friend of pass_key 

private: 
    restricted_t yes; 
}; 

class not_allowed_t 
{ 
public: 
    not_allowed_t() : no(pass_key()) {} // not ok, pass_key() is private 

private: 
    restricted_t no; 
}; 

int main() 
{ 
    allowed_t a;  // OK, can access constructor 
    not_allowed_t b; // ERROR, only a friend of the key 
        // class has access to the restricted 
        // constructor 
} 

Das Muster ermöglicht eine feingranulare Zugriffskontrolle als restricted_t ein Freund von allowed_t machen und vermeidet komplizierte proxying Muster.

Answer 2

Verwenden Sie friend s! Eine Klasse machen Foo ein Freund einer Klasse Bar bedeutet, dass Foo auf private Mitglieder Bar zugreifen kann. Wenn Sie den Konstruktor privat machen, kann nur Foo eine Instanz von Bar erstellen.

struct restricted_t { 
    friend struct allowed_t; // allow 'allowed_t' to access my private members 
private: 
    // nobody can construct me (except for my friends of course) 
    restricted_t() = default; 
}; 

struct allowed_t { 
    restricted_t yes; // ok 
}; 

struct not_allowed_t { 
    restricted_t no; // not ok 
}; 

int main() { 
    allowed_t a; // ok, can access constructor 
    not_allowed_t b; // error, constructor is private 
}