Sintaxe Básica de Classes

Em C++, uma classe é definida usando a palavra-chave class, seguida pelo nome da classe e um bloco de código que contém membros.

class NomeClasse {
    especificadores_de_acesso:  // Especificadores de acesso
        TipoDado variavel;     // Variáveis
        TipoRetorno funcao() {} // Métodos
};

Especificadores de Acesso

Os especificadores de acesso controlam a visibilidade dos membros da classe.

class NomeClasse {
    public:
        // Membros públicos
    protected:
        // Membros protegidos
    private:
        // Membros privados
};

Membros Públicos (public)

Membros públicos são acessíveis fora da classe, permitindo acesso direto a variáveis e funções.

class Circulo {
    public:
        double raio;
        void definirRaio(double r);
        double obterRaio();
};

double Circulo::obterRaio() { return raio; }
void Circulo::definirRaio(double r) { raio = r; }

// Exemplo de uso
Circulo c1;
c1.raio = 5.0;
cout << c1.raio << endl;
c1.definirRaio(7.0);
cout << c1.obterRaio() << endl;

Membros Privados (private)

Membros privados só são acessíveis dentro da classe ou por funções amigas. Por padrão, os membros sem especificador são privados.

class Retangulo {
    public:
        double largura;
        void definirAltura(double alt);
        double obterAltura();
    private:
        double altura;
};

double Retangulo::obterAltura() { return altura; }
void Retangulo::definirAltura(double alt) { altura = alt; }

// Exemplo de uso
Retangulo ret;
// ret.altura = 10.0; // Erro: 'altura' é privado
ret.definirAltura(10.0);
cout << ret.obterAltura() << endl;

Membros Protegidos (protected)

Membros protegidos são semelhantes aos privados, mas acessíveis em classes derivadas.

/* Classe base */
class Veiculo {
    protected:
        double velocidade;
};

/* Classe derivada */
class Carro : public Veiculo {
    public:
        void definirVelocidade(double vel);
        double obterVelocidade();
};

void Carro::definirVelocidade(double vel) { velocidade = vel; }
double Carro::obterVelocidade() { return velocidade; }

// Exemplo de uso
Carro meuCarro;
meuCarro.definirVelocidade(120.0);
cout << meuCarro.obterVelocidade() << endl;

Funções Membro de Classe

Definição Dentro da Classe

class Caixa {
    public:
        double comprimento;
        double largura;
        double altura;
        double calcularVolume() { return comprimento * largura * altura; }
};

Definição Fora da Classe

class Caixa {
    public:
        double comprimento;
        double largura;
        double altura;
        double calcularVolume();
};

double Caixa::calcularVolume() { return comprimento * largura * altura; }

Construtores

Construtores são funções especiais chamadas ao criar objetos, sem tipo de retorno e com o mesmo nome da classe.

Construtro Padrão

class Pessoa {
    public:
        Pessoa() { cout << "Objeto criado" << endl; }
    private:
        string nome;
};

// Exemplo
Pessoa p1; // Saída: Objeto criado

Cnostrutor Parametrizado

class Pessoa {
    public:
        Pessoa(string n) {
            nome = n;
            cout << "Objeto criado com nome: " << nome << endl;
        }
    private:
        string nome;
};

// Exemplo
Pessoa p2("Ana");

Construtor com Lista de Inicialização

class Ponto {
    public:
        Ponto(double x, double y): coordX(x), coordY(y) { cout << "Ponto criado" << endl; }
    private:
        double coordX;
        double coordY;
};

// Equivalente a:
Ponto(double x, double y) {
    coordX = x;
    coordY = y;
    cout << "Ponto criado" << endl;
}

Os membros são inicializados na ordem de declaração, não na ordem da lista de inicialização.

Destruidores

Destruidores são chamados ao destruir objetos, com o mesmo nome da classe precedido por ~.

<class>class Recurso {
    public:
        Recurso() { cout << "Recurso adquirido" << endl; }
        ~Recurso() { cout << "Recurso liberado" << endl; }
};

// Exemplo
Recurso r1;</class>

Uma classe pode ter vários construtores, mas apenas um destruidor.

Construtor de Cópia

O construtor de cópia inicializa um objeto a partir de outro da mesma classe.

class Sensor {
    public:
        int leitura;
        Sensor(int l): leitura(l) { cout << "Construtor geral chamado" << endl; }
        Sensor(const Sensor& s) {
            leitura = s.leitura;
            cout << "Construtor de cópia chamado" << endl;
        }
};

// Exemplo
Sensor s1(25);
Sensor s2(s1); // Construtor de cópia chamado

Cópia Superficial e Profunda

Cópia Superficial

Usada para tipos básicos ou objetos simples, copiando bits de memória.

int a = 10;
int b = a;

Cópia Profunda

Necessária para classes com recursos dinâmicos, onde uma nova cópia independente é criada.

#include <cstring>
#include <cstdlib>
using namespace std;

class VetorDinamico {
    public:
        VetorDinamico(int tamanho) {
            tam = tamanho;
            dados = (int*)calloc(tam, sizeof(int));
        }
        VetorDinamico(const VetorDinamico& outro) {
            tam = outro.tam;
            dados = (int*)calloc(tam, sizeof(int));
            memcpy(dados, outro.dados, tam * sizeof(int));
        }
        ~VetorDinamico() { free(dados); }
        int& operator[](int i) { return dados[i]; }
        int tamanho() const { return tam; }
    private:
        int tam;
        int* dados;
};

// Exemplo de uso
VetorDinamico v1(5);
for (int i = 0; i < 5; i++) v1[i] = i * 2;
VetorDinamico v2 = v1;
v2[2] = 99;
// v1 e v2 são independentes após cópia profunda

Membros Estáticos

Variáveis Estáticas

Variáveis estáticas são compartilhadas por todas as instâncias da classe.

class Contador {
    public:
        static int total;
        Contador() { total++; }
};
int Contador::total = 0; // Definição e inicialização

// Exemplo
Contador c1, c2, c3;
cout << "Total de objetos: " << Contador::total << endl; // Saída: 3

Funções Estáticas

Funções estáticas podem ser chamadas sem um objeto e só acessam membros estáticos.

class Gerador {
    public:
        static int contador;
        Gerador() { contador++; }
        static int obterContador() { return contador; }
};
int Gerador::contador = 0;

// Exemplo
Gerador g1, g2;
cout << "Contagem: " << Gerador::obterContador() << endl;

Amizas (Friend)

Funções Amigas

Funções amigas podem acessar membros privados e protegidos, mas não são membros da classe.

class Temperatura {
    double valor;
    public:
        Temperatura(double v): valor(v) {}
        friend void mostrarTemperatura(Temperatura t);
};

void mostrarTemperatura(Temperatura t) { cout << "Temperatura: " << t.valor << endl; }

// Exemplo
Temperatura temp(36.5);
mostrarTemperatura(temp);

Classes Amigas

Uma classe amiga pode acessar todos os membros da classe que a declarou como amiga.

class Encomenda {
    double peso;
    public:
        Encomenda(double p): peso(p) {}
        friend class Transportadora;
};

class Transportadora {
    public:
        void exibirPeso(Encomenda& e) { cout << "Peso: " << e.peso << endl; }
};

// Exemplo
Encomenda enc(15.3);
Transportadora trans;
trans.exibirPeso(enc);

Ponteiro this

O ponteiro this aponta para a instância atual do objeto, usado para resolver conflitos de nomes ou acessar membros explicitamente.

class Dispositivo {
    int id;
    public:
        void definirId(int id) { this->id = id; }
        int obterId() { return this->id; }
};

// Exemplo
Dispositivo dev;
dev.definirId(101);
cout << dev.obterId() << endl;