Sobrecarga de Operadores e Funções Membro Const em C++

Este artigo explora a sobrecarga de operadores em C++, focando especificamente em operadores de atribuição, incremento/decremento, e operadores de fluxo (entrada/saída), além de discutir o uso de const em funções membro.

Sobrecarga de Operadores

A sobrecarga de operadores em C++ permite que operadores predefinidos (como +, -, =, ==, etc.) sejam aplicados a objetos de classes definidas pelo usuário. O objetivo é tornar o código mais entuitivo e legível, permitindo que objetos de tipos personalizados se comportem de maneira semelhante a tipos de dados nativos.

Princípios da Sobrecarga de Operadores:

Operadores sobrecarregados são funções com nomes especiais.
A sintaxe é operator seguido pelo símbolo do operador (ex: operator+).
Não é possível criar novos operadores nem alterar o comportamanto de operadores para tipos nativos.
Pelo menos um dos operandos de um operador sobrecarregado deve ser de um tipo de classe ou enumeração.
O significado fundamental de operadores para tipos nativos não pode ser alterado.
Funções membro de operadores recebem implicitamente um ponteiro this para o operando esquerdo.
Operadores como sizeof, ::, .\*, ?:, . não podem ser sobrecarregados.

Exemplo de Sobrecarga do Operador de Igualdade (`==`):


#include <iostream>

class Data {
public:
    Data(int ano = 0, int mes = 1, int dia = 1) : _ano(ano), _mes(mes), _dia(dia) {}

    void imprimir() const {
        std::cout << _ano << "-" << _mes << "-" << _dia << std::endl;
    }

    // Sobrecarga do operador de igualdade
    bool operator==(const Data& outra) const {
        return _ano == outra._ano && _mes == outra. _mes && _dia == outra._dia;
    }

private:
    int _ano;
    int _mes;
    int _dia;
};

int main() {
    Data d1(2024, 9, 22);
    Data d2 = d1; // Chama o construtor de cópia (ou atribuição se d2 já existir)

    if (d1 == d2) { // Usa o operador == sobrecarregado
        std::cout << "As datas sao iguais." << std::endl;
    }
    
    // Forma explícita (equivalente à anterior)
    if (d1.operator==(d2)) {
         std::cout << "As datas sao iguais (chamada explicita)." << std::endl;
    }

    return 0;
}

Sobrecarga do Operador de Atribuição (`=`)

O operador de atribuição é crucial para gerenciar a cópia de objetos. É comum que ele retorne uma referência para o próprio objeto (\*this) para permitir a atribuição em cadeia.

Pontos Importantes na Sobrecarga do Operador de Atribuição:

O parâmetro deve ser uma referência constante para evitar cópias desnecessárias e garantir que o objeto original não seja modificado.
O tipo de retorno é uma referência (Data&) para suportar atribuições em cadeia (ex: obj3 = obj2 = obj1;).
É essencial verificar se o objeto está sendo atribuído a si mesmo (if (this != &outro)) para evitar problemas, especialmente com recursos dinâmicos.
Se um operador de atribuição não for explicitamente definido, o compilador gerará um padrão que realiza uma cópia membro a membro (cópia superficial).
O operador de atribuição só pode ser definido como uma função membro da classe.


class Data {
public:
    Data(int ano = 0, int mes = 1, int dia = 1) : _ano(ano), _mes(mes), _dia(dia) {}

    // Sobrecarga do operador de atribuição
    Data& operator=(const Data& outro) {
        if (this != &outro) { // Evita auto-atribuição
            _ano = outro._ano;
            _mes = outro._mes;
            _dia = outro._dia;
        }
        return *this; // Retorna referência para permitir atribuição em cadeia
    }

    void imprimir() const {
        std::cout << _ano << "-" << _mes << "-" << _dia << std::endl;
    }

private:
    int _ano;
    int _mes;
    int _dia;
};

int main() {
    Data d1(2024, 9, 22);
    Data d2;
    d2 = d1; // Usa o operador = sobrecarregado
    d2.imprimir(); 

    Data d3(2000, 1, 1);
    d3 = d2 = d1; // Atribuição em cadeia
    d3.imprimir();

    return 0;
}

Diferença entre Construtor de Cópia e Operador de Atribuição:

Construtor de Cópia: Usado para inicializar um novo objeto com base em um objeto existente.
Oeprador de Atribuição: Usado para atribuir o valor de um objeto existente a outro objeto já existente.

Sobrecarga de Incremento (`++`) e Decremento (`--`):

Para diferenciar o pré-incremento do pós-incremento, o C++ utiliza a sobrecarga de função. O pós-incremento/decremento aceita um parâmetro inteiro fictício (geralmente int) para distingui-lo do pré-incremento/decremento.


class Data {
public:
    Data(int ano = 2024, int mes = 9, int dia = 22) : _ano(ano), _mes(mes), _dia(dia) {}

    // Pré-incremento (retorna referência para o objeto modificado)
    Data& operator++() {
        _dia++;
        // Lógica para ajustar dia/mês/ano se necessário seria adicionada aqui
        return *this;
    }

    // Pós-incremento (retorna uma cópia do objeto *antes* da modificação)
    Data operator++(int) {
        Data temp(*this); // Cria cópia do estado atual
        _dia++;
        // Lógica para ajustar dia/mês/ano
        return temp; // Retorna a cópia do estado original
    }
    
    // ... outros membros ...

private:
    int _ano;
    int _mes;
    int _dia;
};

int main() {
    Data d1(2024, 9, 22);
    
    ++d1; // Chama operator++()
    d1.imprimir(); 

    Data d2 = d1++; // Chama operator++(int), d1 é incrementado, d2 recebe o valor anterior de d1
    d1.imprimir(); 
    d2.imprimir(); 

    return 0;
}

Funções Membro `const`

Declarar uma função membro como const indica que essa função não modificará o estado do objeto para o qual é chamada. Isso se aplica ao ponteiro this implícito; um const membro de função tem um ponteiro this do tipo const Classe*.

Regras de Chamada para Funções Membro `const`:

Um objeto const não pode chamar uma função membro não const (isso seria uma ampliação de permissão).
Um objeto não const pode chamar uma função membro const (isso é uma redução de permissão).
Uma função membro const não pode chamar outras funções membro não const (ampliação de permissão do this).
Uma função membro não const pode chamar outras funções membro const (redução de permissão do this).


class Data {
public:
    Data(int ano = 2024, int mes = 9, int dia = 22) : _ano(ano), _mes(mes), _dia(dia) {}

    // Função membro const: não modifica o objeto
    void imprimir() const {
        std::cout << _ano << "-" << _mes << "-" << _dia << std::endl;
        // _dia++; // Erro! Não pode modificar membro em função const
    }

    // Função membro não const: pode modificar o objeto
    void avancarDia() {
        _dia++;
        // ... lógica de ajuste ...
    }

private:
    int _ano;
    int _mes;
    int _dia;
};

int main() {
    Data d1(2024, 9, 22);
    const Data d2(2024, 9, 22);

    d1.imprimir();      // OK (objeto não const chama função const)
    d2.imprimir();      // OK (objeto const chama função const)
    // d2.avancarDia(); // ERRO! (objeto const não pode chamar função não const)

    return 0;
}

Funções que apenas leem o estado do objeto (como imprimir, getAno, etc.) devem ser declaradas como const.

Sobrecarga dos Operadores de Endereço (`&`)

Os operadores de endereço (operator& e operator& const) geralmente não precisam ser redefinidos, pois o compilador fornece implementações padrão que retornam o endereço do objeto.


class Data {
public:
    // Sobrecarga do operador de endereço para objetos não const
    Data* operator&() {
        return this;
    }

    // Sobrecarga do operador de endereço para objetos const
    const Data* operator&() const {
        return this;
    }

private:
    int _ano;
    int _mes;
    int _dia;
};

Implementação de uma Classe Data

A seguir, um esboço de uma classe Data mais completa, demonstrando a aplicação dos conceitos discutidos.


#include <iostream>
#include <iomanip> // Para std::setw, std::setfill

class Data {
private:
    int _ano;
    int _mes;
    int _dia;

    // Função auxiliar para obter dias no mês (considerando ano bissexto)
    static int diasNoMes(int ano, int mes) {
        static const int dias[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        if (mes == 2 && ((ano % 4 == 0 && ano % 100 != 0) || (ano % 400 == 0))) {
            return 29; // Fevereiro em ano bissexto
        }
        return dias[mes];
    }

    // Função auxiliar para validação de data
    bool validarData(int ano, int mes, int dia) const {
        if (ano < 0 || mes < 1 || mes > 12 || dia < 1 || dia > diasNoMes(ano, mes)) {
            return false;
        }
        return true;
    }

public:
    // Construtor
    Data(int ano = 1900, int mes = 1, int dia = 1) : _ano(ano), _mes(mes), _dia(dia) {
        if (!validarData(ano, mes, dia)) {
            // Tratar erro de data inválida (ex: lançar exceção ou definir data padrão)
            std::cerr << "Erro: Data invalida inicializada: " << ano << "-" << mes << "-" << dia << std::endl;
            // Define uma data padrão em caso de erro
            _ano = 1900; _mes = 1; _dia = 1;
        }
    }

    // Construtor de Cópia (padrão é suficiente se não houver alocação dinâmica)
    Data(const Data& outra) = default;

    // Operador de Atribuição (padrão é suficiente se não houver alocação dinâmica)
    Data& operator=(const Data& outra) = default;

    // Imprimir (const)
    void imprimir() const {
        std::cout << std::setfill('0') << std::setw(4) << _ano << "-"
                  << std::setfill('0') << std::setw(2) << _mes << "-"
                  << std::setfill('0') << std::setw(2) << _dia;
    }

    // Pré-incremento (dia)
    Data& operator++() {
        _dia++;
        if (_dia > diasNoMes(_ano, _mes)) {
            _dia = 1;
            _mes++;
            if (_mes > 12) {
                _mes = 1;
                _ano++;
            }
        }
        return *this;
    }

    // Pós-incremento (dia)
    Data operator++(int) {
        Data temp(*this);
        ++(*this); // Reutiliza o pré-incremento
        return temp;
    }

    // Pré-decremento (dia)
    Data& operator--() {
        _dia--;
        if (_dia < 1) {
            _mes--;
            if (_mes < 1) {
                _mes = 12;
                _ano--;
            }
            _dia = diasNoMes(_ano, _mes);
        }
        return *this;
    }

    // Pós-decremento (dia)
    Data operator--(int) {
        Data temp(*this);
        --(*this); // Reutiliza o pré-decremento
        return temp;
    }

    // Adição de dias
    Data operator+(int diasParaAdicionar) const {
        Data resultado(*this);
        resultado += diasParaAdicionar;
        return resultado;
    }

    // Adição de dias in-place
    Data& operator+=(int diasParaAdicionar) {
        if (diasParaAdicionar < 0) {
            *this -= (-diasParaAdicionar); // Reutiliza -=
            return *this;
        }
        _dia += diasParaAdicionar;
        while (_dia > diasNoMes(_ano, _mes)) {
            _dia -= diasNoMes(_ano, _mes);
            _mes++;
            if (_mes > 12) {
                _mes = 1;
                _ano++;
            }
        }
        return *this;
    }
    
    // Subtração de dias
    Data operator-(int diasParaSubtrair) const {
        Data resultado(*this);
        resultado -= diasParaSubtrair;
        return resultado;
    }

    // Subtração de dias in-place
    Data& operator-=(int diasParaSubtrair) {
         if (diasParaSubtrair < 0) {
            *this += (-diasParaSubtrair); // Reutiliza +=
            return *this;
        }
        _dia -= diasParaSubtrair;
        while (_dia <= 0) {
            _mes--;
            if (_mes < 1) {
                _mes = 12;
                _ano--;
            }
            _dia += diasNoMes(_ano, _mes);
        }
        return *this;
    }


    // Comparações (const)
    bool operator==(const Data& outra) const {
        return _ano == outra._ano && _mes == outra._mes && _dia == outra._dia;
    }

    bool operator!=(const Data& outra) const {
        return !(*this == outra);
    }

    bool operator>(const Data& outra) const {
        if (_ano != outra._ano) return _ano > outra._ano;
        if (_mes != outra._mes) return _mes > outra._mes;
        return _dia > outra._dia;
    }

    bool operator<(const Data& outra) const {
        return outra > *this; // Reutiliza o operador >
    }

    bool operator>=(const Data& outra) const {
        return (*this > outra) || (*this == outra);
    }

    bool operator<=(const Data& outra) const {
        return !(*this > outra); // Reutiliza o operador >
    }

    // Diferença em dias entre duas datas
    int operator-(const Data& outra) const {
        // Simplificação: assume que esta data é posterior à outra
        // Uma implementação robusta precisaria considerar a ordem e a contagem precisa de dias
        // Aqui, vamos apenas converter para um número total de dias desde uma data base fictícia
        // e subtrair. Isso requereria funções auxiliares adicionais.
        // Por simplicidade, apresentaremos uma abordagem de contagem de dias.
        
        Data inicio = (*this < outra) ? *this : outra;
        Data fim = (*this >= outra) ? *this : outra;
        
        int diasDiferenca = 0;
        while(inicio != fim) {
            ++inicio;
            diasDiferenca++;
        }
        
        return (*this > outra) ? diasDiferenca : -diasDiferenca;
    }


    // Declarar operadores de fluxo como amigos
    friend std::ostream& operator<<(std::ostream& os, const Data& dt);
    friend std::istream& operator>>(std::istream& is, Data& dt);
};

// Implementação do operador de fluxo de saída (<<)
std::ostream& operator<<(std::ostream& os, const Data& dt) {
    os << std::setfill('0') << std::setw(4) << dt._ano << "-"
       << std::setfill('0') << std::setw(2) << dt._mes << "-"
       << std::setfill('0') << std::setw(2) << dt._dia;
    return os;
}

// Implementação do operador de fluxo de entrada (>>)
std::istream& operator>>(std::istream& is, Data& dt) {
    is >> dt._ano >> dt._mes >> dt._dia;
    // Opcional: Validar a data após a leitura
    if (!dt.validarData(dt._ano, dt._mes, dt._dia)) {
         std::cerr << "Aviso: Data inserida invalida: " << dt << std::endl;
         // Tratar como desejado (ex: resetar para data padrão, lançar exceção)
         dt = Data(); // Reseta para data padrão
    }
    return is;
}

// Exemplo de uso da classe Data completa
int main() {
    Data hoje(2024, 9, 22);
    Data amanha = hoje + 1; // Usa operator+
    Data ontem = hoje - 1; // Usa operator-

    std::cout << "Hoje: " << hoje << std::endl;
    std::cout << "Amanha: " << amanha << std::endl;
    std::cout << "Ontem: " << ontem << std::endl;

    hoje++; // Usa operator++(int)
    std::cout << "Hoje apos pos-incremento: " << hoje << std::endl;

    ++hoje; // Usa operator++()
    std::cout << "Hoje apos pre-incremento: " << hoje << std::endl;

    Data dataNascimento(1990, 5, 15);
    std::cout << "Data de nascimento: " << dataNascimento << std::endl;
    std::cout << "Diferenca em dias entre hoje e nascimento: " << (hoje - dataNascimento) << std::endl;

    Data d1(2023, 12, 31);
    Data d2(2024, 1, 1);
    std::cout << d1 << " eh maior que " << d2 << "? " << (d1 > d2) << std::endl; // False
    std::cout << d2 << " eh maior que " << d1 << "? " << (d2 > d1) << std::endl; // True

    return 0;
}

Sobrecarga de Operadores de Fluxo (`<<` e `>>`)

Os operadores de fluxo de saída (<< para std::cout) e entrada (>> para std::cin) são comumente sobrecarregados para permitir a interação fácil com objetos de classes personalizadas.

Devem ser implementados como funções globais (não membros) para permitir que o objeto da classe seja o operando esquerdo (ex: std::cout << meuObjeto;).
O primeiro parâmetro é uma referência para o stream de saída (std::ostream&) ou entrada (std::istream&).
O segundo parâmetro é uma referência constante para o objeto a ser impresso (para <<) ou uma referência não constante para o objeto a ser preenchido (para >>).
As funções devem retornar uma referência para o stream (std::ostream& ou std::istream&) para permitir o encadeamento de operações.
Se a classe tiver membros privados que precisam ser acessados por essas funções globais, a declaração friend dentro da classe é necessária.

Tags: C++ sobrecarga de operadores operador de atribuição const funções membro const

Publicado em 6-13 19:48 por Thomas

Doido Dev

Sobrecarga de Operadores e Funções Membro Const em C++