Classes e Objetos em C++: Guia Prático com Exemplos de Código

O que é uma Classe?

Uma classe C++ é um tipo de dado definido pelo usuário que agrupa dados e as funções que operam sobre esses dados em uma única entidade. Pense nela como um projeto (blueprint): ela define a forma e o comportamento de objetos que podem ser criados a partir dela.

Assim como uma planta de casa especifica a localização de portas, janelas e quartos, uma classe descreve o layout de seus membros de dados e as operações que podem manipulá-los. Múltiplas casas (objetos) podem ser construídas a partir da mesma planta.

Nota: Ilustração original omitida nesta versão otimizada.

Neste tutorial você aprenderá:

• O que é uma classe e por que importa em C++
• Exemplos concretos de classes
• O papel dos modificadores de acesso private e public
• Como criar objetos (instanciação)
• Acessando membros de dados com segurança
• Funções membro dentro e fora da definição da classe
• Construtores e destrutores em ação

Declaração de Classe

Declarar uma classe é direto: use a palavra-chave class seguida pelo nome da classe e envolva o corpo entre chaves.

Sintaxe

class nomeClasse {
    // membros de dados
    // funções membro
};

• nomeClasse – o identificador para sua classe.
• Membros de dados são tipicamente declarados como variáveis.
• Funções membro fornecem comportamento.

Modificadores de Acesso: private vs. public

Modificadores de acesso controlam a visibilidade de membros da classe.

• private – membros só são acessíveis dentro da classe ou de suas friends.
• public – membros podem ser acessados de qualquer lugar onde o objeto é visível.

Criando Objetos (Instanciação)

Objetos são instâncias de uma classe. Declarar um objeto segue o mesmo padrão de declarar uma variável: nomeClasse nomeObjeto;

Sintaxe

nomeClasse nomeObjeto;

• nomeClasse – a classe a partir da qual o objeto é criado.
• nomeObjeto – o identificador para o novo objeto.

Instanciação aloca memória para o objeto e pode disparar seu construtor.

Acessando Membros de Dados

Membros de dados públicos são acessados usando o operador ponto (.).

Exemplo

#include <iostream>
using namespace std;
class Telefone {
public:
    double custo;
    int slots;
};
int main() {
    Telefone Y6;
    Telefone Y7;
    Y6.custo = 100.0;
    Y6.slots = 2;
    Y7.custo = 200.0;
    Y7.slots = 2;
    cout << "Custo do Huawei Y6: " << Y6.custo << endl;
    cout << "Custo do Huawei Y7: " << Y7.custo << endl;
    cout << "Número de slots para cartão no Huawei Y6: " << Y6.slots << endl;
    cout << "Número de slots para cartão no Huawei Y7: " << Y7.slots << endl;
    return 0;
}

Por que Usar Getters/Setters?

Acessar ou modificar dados diretamente pode quebrar encapsulamento. Usar funções membro getter e setter fornece acesso controlado.

Exemplo com Encapsulamento

#include <iostream>
using namespace std;
class ClasseA {
public:
    void setA(int val);
    int getA() const;
private:
    int a;
};
int ClasseA::getA() const {
    return a;
}
void ClasseA::setA(int val) {
    a = val;
}
int main() {
    ClasseA obj;
    obj.setA(20);
    cout << "Valor de a é: " << obj.getA();
    return 0;
}

Membros Protected e Herança

Membros protected são acessíveis dentro da classe e por classes derivadas, permitindo herança controlada.

Exemplo

#include <iostream>
using namespace std;
class ClassePai {
protected:
    int valor;
};
class ClasseFilha : public ClassePai {
public:
    void setId(int x) {
        valor = x;
    }
    void exibirValor() {
        cout << "Valor é: " << valor << endl;
    }
};
int main() {
    ClasseFilha c;
    c.setId(21);
    c.exibirValor();
    return 0;
}

Funções Membro Dentro vs. Fora da Classe

Funções membro podem ser definidas inline dentro da classe ou declaradas dentro e definidas depois usando o operador de resolução de escopo ::.

Exemplo

#include <iostream>
#include <string>
using namespace std;
class Guru99 {
public:
    string nome_tutorial;
    int id;
    void imprimirNome();
    void imprimirId() {
        cout << "ID do tutorial é: " << id;
    }
};
void Guru99::imprimirNome() {
    cout << "Nome do tutorial é: " << nome_tutorial;
}
int main() {
    Guru99 guru;
    guru.nome_tutorial = "C++";
    guru.id = 1001;
    guru.imprimirNome();
    cout << endl;
    guru.imprimirId();
    return 0;
}

Construtores e Destrutores

Construtores inicializam objetos quando são criados, enquanto destrutores limpam logo antes de um objeto ser destruído.

Exemplo

#include <iostream>
using namespace std;
class ClasseA {
public:
    ClasseA() {
        cout << "Construtor da classe chamado" << endl;
    }
    ~ClasseA() {
        cout << "Destrutor da classe chamado" << endl;
    }
};
int main() {
    ClasseA a; // construtor chamado
    int p = 1;
    if (p) {
        ClasseA b; // construtor chamado, destrutor chamado no fim do bloco
    } // destrutor para 'b' chamado aqui
    // destrutor para 'a' chamado aqui
    return 0;
}

Saída:

Construtor da classe chamado
Construtor da classe chamado
Destrutor da classe chamado
Destrutor da classe chamado

Principais Conclusões

• C++ é fundamentalmente orientado a objetos; classes são os blocos de construção.
• Uma classe agrupa dados e funções relacionadas, criando um blueprint reutilizável.
• Use public, private e protected para impor encapsulamento.
• Instancie objetos com o nome da classe seguido do nome do objeto.
• Acesse membros públicos via operador ponto; use getters/setters para dados privados.
• Funções membro podem ser definidas inline ou fora da classe com ::.
• Construtores inicializam objetos; destrutores lidam com limpeza.