Reduzindo a duplicação de código entre o operador e o construtor = cópia

Question

Eu tenho uma classe que requer um construtor de cópia e operador de atribuição (que contém listas de ponteiros) não-padrão. Existe alguma maneira geral para reduzir a duplicação de código entre o construtor de cópia e operador de atribuição?

Answer 1

Não há nenhuma "maneira geral" para escrever personalizados construtores de cópia e operadores de atribuição que funciona em todos os casos. Mas há um idioma chamado "copy - & - Swap":

 class myclass
 {
    ...
 public:
    myclass(myclass const&);

    void swap(myclass & with);

    myclass& operator=(myclass copy) {
        this->swap(copy);
        return *this;
    }

    ...
};

É útil em muitos (mas não todos) situações. Às vezes você pode fazer melhor. Um vector ou uma string pode ter uma atribuição melhor que reutiliza alocado de armazenamento se era grande o suficiente.

Answer 2

fatorar o código comum para uma função de membro privado. Um simples (em vez artificial) exemplo:

#include <iostream>

class Test
{
public:
  Test(const char* n)
  {
    name = new char[20];
    strcpy(name, n);
  }

  ~Test()
  {
    delete[] name;
  }

  // Copy constructor
  Test(const Test& t)
  {
    std::cout << "In copy constructor.\n";
    MakeDeepCopy(t);
  }

  // Assignment operator
  const Test& operator=(const Test& t)
  {
    std::cout << "In assignment operator.\n";
    MakeDeepCopy(t);
  }

  const char* get_name() const { return name; }

private:
  // Common function where the actual copying happens.
  void MakeDeepCopy(const Test& t)
  {        
    strcpy(name, t.name);
  }

private:
  char* name;
};

int
main()
{
  Test t("vijay");
  Test t2(t); // Calls copy constructor.
  Test t3(""); 
  t3 = t2; // Calls the assignment operator.

  std::cout << t.get_name() << ", " << t2.get_name() << ", " << t3.get_name() << '\n';

  return 0;
}

Answer 3

My &My::operator = (My temp)  // thanks, sellibitze
{
    swap (*this, temp);
    return *this;
}

e implementar um std::swap<> (My &, My &) especializada.

Answer 4

Como já foi apontado por algumas cartazes, tendo operador = criar uma nova objeto com o construtor de cópia e, em seguida, usar swap é a técnica comum usada para não ter de código de replicação in = operador.

Dito isso, eu quero salientar alguns um profissional e um con desta técnica para ajudar a decidir se é apropriado.

Pro - a segurança de exceção

Se o seu objeto tem requisitos de recursos que poderiam causar um lance e assumindo que swap não vai jogar, esta técnica fornece a forte garantia de segurança de exceção (ou o objeto que está sendo atribuído a assumiu o valor do outro objeto ou é inalterado).

Con - pegada de recursos

Um problema com esta técnica é que ele requer um novo objeto completo deve ser criado antes de o antigo é liberado. Se o seu objeto requer uma grande quantidade de recursos, isso pode ser um problema.