Sobrecarga do Operador de Atribuição

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 44 de 104.

O operador de atribuição por cópia (=) é chamado quando você atribui um objeto existente a outro. Ao contrário do construtor de cópia (que cria um novo objeto), o operador de atribuição trabalha com um objeto que já existe e pode ter recursos que precisam ser limpos primeiro.

class Buffer {
    int* data;
    size_t size;
    
public:
    Buffer(size_t s) : size(s), data(new int[s]) {}
    ~Buffer() { delete[] data; }
    
    Buffer& operator=(const Buffer& other) {
        if (this != &other) {              // 1. Verificação de autoatribuição
            delete[] data;                  // 2. Limpar recurso existente
            size = other.size;              // 3. Copiar os dados
            data = new int[size];
            for (size_t i = 0; i < size; ++i)
                data[i] = other.data[i];
        }
        return *this;                       // 4. Retornar *this
    }
};

A verificação de autoatribuição (this != &other) é crítica. Sem ela, b = b; excluiria os dados antes de tentar copiá-los, causando comportamento indefinido.

O operador retorna *this por referência para permitir o encadeamento como a = b = c;. Isso corresponde ao comportamento dos tipos integrados.

Para classes que gerenciam recursos, você frequentemente implementará tanto operadores de atribuição por cópia quanto por movimento:

Buffer& operator=(Buffer&& other) noexcept {
    if (this != &other) {
        delete[] data;           // Limpa o recurso atual
        data = other.data;       // Rouba o recurso
        size = other.size;
        other.data = nullptr;    // Deixa a origem em um estado válido
        other.size = 0;
    }
    return *this;
}

O operador de atribuição por movimento transfere a propriedade em vez de copiar, tornando operações como vec[0] = createBuffer(); muito mais eficientes.

Desafio

Fácil

Vamos criar uma classe DynamicString que gerencia um array de caracteres alocado dinamicamente e lida corretamente com a atribuição entre objetos existentes. Este é um cenário prático em que você precisa transferir com segurança dados de string de um objeto para outro sem vazamentos de memória ou ponteiros pendentes.

Você criará dois arquivos para organizar seu código:

DynamicString.h: Defina uma classe DynamicString que armazena uma string no estilo C usando memória dinâmica. Sua classe deve gerenciar:
- Um ponteiro char* privado para os dados da string
- Um size_t privado para o comprimento
- Um construtor que recebe um const char* e cria uma cópia profunda
- Um destrutor que libera corretamente a memória alocada
- Um operador de atribuição por cópia que realiza uma cópia profunda com proteção contra autoatribuição
- Um operador de atribuição por movimento que transfere a propriedade de forma eficiente
- Um método c_str() que retorna a string interna (const)
- Um método length() que retorna o comprimento da string (const)
Seu operador de atribuição por cópia deve seguir as quatro etapas essenciais: verificar se há autoatribuição, limpar os recursos existentes, copiar os novos dados e retornar *this. O operador de atribuição por movimento deve assumir o ponteiro da origem e deixar a origem em um estado vazio válido (nullptr com comprimento 0).
main.cpp: Leia três strings da entrada (cada uma em uma linha separada). Crie três objetos DynamicString: str1 com a primeira entrada, str2 com a segunda entrada e str3 com a terceira entrada.
Demonstre seus operadores de atribuição:
1. Imprima o estado inicial das três strings
2. Use a atribuição por cópia: str1 = str2;
3. Imprima str1 e str2 após a atribuição por cópia (ambas devem ter o mesmo conteúdo)
4. Use a atribuição por movimento: str2 = std::move(str3);
5. Imprima str2 após a atribuição por movimento e o comprimento de str3 (deve ser 0 após a movimentação)
Formato da saída:
```
Initial:
str1: <value>
str2: <value>
str3: <value>
After copy (str1 = str2):
str1: <value>
str2: <value>
After move (str2 = std::move(str3)):
str2: <value>
str3 length: 0
```

Use <cstring> para strlen e strcpy. Marque seu operador de atribuição por movimento como noexcept. Inclua <utility> em main.cpp para std::move. Não se esqueça dos protetores de inclusão no arquivo de cabeçalho.

Experimente você mesmo

#include <iostream>
#include <string>
#include <utility>
#include "DynamicString.h"

using namespace std;

int main() {
    // Lê três strings da entrada
    string input1, input2, input3;
    getline(cin, input1);
    getline(cin, input2);
    getline(cin, input3);

    // Cria três objetos DynamicString
    DynamicString str1(input1.c_str());
    DynamicString str2(input2.c_str());
    DynamicString str3(input3.c_str());

    // TODO: Imprimir o estado inicial de todas as três strings
    // Formato:
    // Initial:
    // str1: <valor>
    // str2: <valor>
    // str3: <valor>

    // TODO: Usar atribuição por cópia: str1 = str2;

    // TODO: Imprimir str1 e str2 após a atribuição por cópia
    // Formato:
    // After copy (str1 = str2):
    // str1: <valor>
    // str2: <valor>

    // TODO: Usar atribuição por movimento: str2 = std::move(str3);

    // TODO: Imprimir str2 após o movimento, e o comprimento de str3
    // Formato:
    // After move (str2 = std::move(str3)):
    // str2: <valor>
    // str3 length: 0

    return 0;
}