Prevenire istanza di un oggetto fuori del suo metodo factory

Question

Supponiamo che io ho una classe con un metodo factory

class A { 
public: 
    static A* newA() 
    { 
    // Some code, logging, ... 
    return new A(); 
    } 
} 

E 'possibile evitare che l'istanza di un oggetto di questa classe con un new, in modo che il metodo di fabbrica è l'unico metodo per creare un'istanza dell'oggetto?

Answer 1

Sicuro; basta fare il privato costruttore (protetta se si tratta di una classe di base):

class A { 
public: 
    static A* newA() 
    { 
    // Some code, logging, ... 
    return new A(); 
    } 

private: 
    A() {} // Default constructor 
}; 

Si dovrebbe fare il costruttore di copia privata/protetta e, se necessario.

E come sempre, è consigliabile prendere in considerazione la possibilità di restituire un puntatore intelligente anziché un puntatore raw, al fine di semplificare i problemi di gestione della memoria.

Answer 2

Si consiglia inoltre di fare il costruttore di copia privata, come bene o con la nuova sintassi C++ 11 si può dire esplicitamente al compilatore di non copiarlo e rendere il costruttore di default privato con qualcosa di simile:

struct NonCopyable { 
    NonCopyable & operator=(const NonCopyable&) = delete; 
    NonCopyable(const NonCopyable&) = delete; 
    NonCopyable() = default; 
}; 

class A : NonCopyable { 
public: 
    static std::shared_ptr<A> newA() 
    { 
    // Some code, logging, ... 
    return std::make_shared<A>(); 
    } 

private: 
    A() {} // Default constructor 
}; 

Il modo in cui C++ 03 era di solito qualcosa di simile:

class A { 
public: 
    static A* newA() 
    { 
    // Some code, logging, ... 
    return new A(); 
    } 

private: 
    A() {}      // no outsider default constructor 
    A(const A& rhs);    // no copy 
    A& operator=(const A& rhs); // no assignment 
}; 

int main() 
{ 
    A x;  // C2248 
    A y(x);  // C2248 
    x = y;  // C2248 
    A* p = A::newA(); // OK 
    std::cin.get(); 
    return 0; 
}