Désactiver le constructeur de copie

Question

J'ai une classe :

class SymbolIndexer {
protected:
  SymbolIndexer ( ) { }

public:
  static inline SymbolIndexer & GetUniqueInstance ( ) 
  { 
    static SymbolIndexer uniqueinstance_ ;
    return uniqueinstance_ ; 
  }
};

Comment dois-je le modifier pour désactiver le code comme :

SymbolIndexer symbol_indexer_ = SymbolIndexer::GetUniqueInstance ( );

et n'autoriser que des codes comme :

SymbolIndexer & ref_symbol_indexer_ = SymbolIndexer::GetUniqueInstance ( );

Answer 1

Vous pouvez rendre le constructeur de copie privé et ne pas fournir d'implémentation :

private:
    SymbolIndexer(const SymbolIndexer&);

Ou en C++11, l'interdire explicitement :

SymbolIndexer(const SymbolIndexer&) = delete;

Answer 2

Si l'héritage multiple ne vous dérange pas (ce n'est pas si mal, après tout), vous pouvez écrire une classe simple avec un constructeur de copie privée et un opérateur d'affectation et la sous-classer en plus :

class NonAssignable {
private:
    NonAssignable(NonAssignable const&);
    NonAssignable& operator=(NonAssignable const&);
public:
    NonAssignable() {}
};

class SymbolIndexer: public Indexer, public NonAssignable {
};

Pour GCC, cela donne le message d'erreur suivant :

test.h: In copy constructor ‘SymbolIndexer::SymbolIndexer(const SymbolIndexer&)’:
test.h: error: ‘NonAssignable::NonAssignable(const NonAssignable&)’ is private

Je ne suis pas très sûr que cela fonctionne dans tous les compilateurs, cependant. Il existe un Question connexe mais sans réponse pour l'instant.

UPD :

En C++11, vous pouvez également écrire NonAssignable comme suit :

class NonAssignable {
public:
    NonAssignable(NonAssignable const&) = delete;
    NonAssignable& operator=(NonAssignable const&) = delete;
    NonAssignable() {}
};

El delete Le mot-clé empêche les membres d'être construits par défaut, ils ne peuvent donc plus être utilisés dans les membres construits par défaut d'une classe dérivée. Essayer d'assigner donne l'erreur suivante dans GCC :

test.cpp: error: use of deleted function
          ‘SymbolIndexer& SymbolIndexer::operator=(const SymbolIndexer&)’
test.cpp: note: ‘SymbolIndexer& SymbolIndexer::operator=(const SymbolIndexer&)’
          is implicitly deleted because the default definition would
          be ill-formed:

UPD :

Boost a déjà une classe juste pour le même but, je suppose qu'elle est même implémentée de manière similaire. Cette classe s'appelle boost::noncopyable et est destiné à être utilisé comme dans l'exemple suivant :

#include <boost/core/noncopyable.hpp>

class SymbolIndexer: public Indexer, private boost::noncopyable {
};

Je recommande de s'en tenir à la solution de Boost si la politique de votre projet le permet. Voir aussi un autre boost::noncopyable -Question connexe pour plus d'informations.

Answer 3

Faire SymbolIndexer( const SymbolIndexer& ) privé. Si vous assignez à une référence, vous ne copiez pas.

Answer 4

Les développeurs C++ qui apprennent la différence entre référence et pointeur peuvent être tentés d'avoir

class MyClass {
    SomeClass acc;
public:
    MyClass() : acc() {}
    SomeClass &GetAccess( return acc; );
};

Comme un moyen pratique de le faire ensuite :

someblock->{
    MyClass inst;
    auto acc = inst.GetAccess();  

    acc.SomeFunction();
}

ce qui créera des problèmes avec les doubles libérations à l'intérieur de SomeClass, parce que vous vous retrouvez avec une copie par défaut...