Fácil C++

Criando uma classe Contador

Enunciado

Crie uma classe Contador com um membro privado int valor. Adicione um construtor que inicializa valor com 0, um método público incrementar() que soma 1 e um método público getValor() que retorna o valor atual. No main, crie um objeto, incremente duas vezes e imprima o valor.

Requisitos

  • A classe deve ter o membro valor como private.
  • O construtor deve inicializar valor com 0.
  • Os métodos incrementar() e getValor() devem ser públicos.
  • A saída deve mostrar o valor 2.

Código inicial

#include <iostream>

class Contador {
    // complete aqui
};

int main() {
    // crie um objeto e teste
    return 0;
}

Saída esperada

Valor: 2
Ver dica

Use private: para o membro e public: para os métodos. O construtor pode ser Contador() : valor(0) {}.

Mostrar solução 
#include <iostream>

class Contador {
private:
    int valor;  // membro privado

public:
    // Construtor inicializa valor com 0
    Contador() : valor(0) {}

    // Incrementa o valor em 1
    void incrementar() {
        ++valor;
    }

    // Retorna o valor atual
    int getValor() const {
        return valor;
    }
};

int main() {
    Contador c;          // cria objeto, chama construtor
    c.incrementar();     // valor = 1
    c.incrementar();     // valor = 2
    std::cout << "Valor: " << c.getValor() << "\n";
    return 0;
}

Passo a passo

  1. Declaramos a classe Contador com a palavra-chave class.
  2. Dentro dela, private: indica que valor só pode ser acessado pelos membros da classe.
  3. O construtor Contador() : valor(0) {} usa lista de inicialização para definir valor como 0.
  4. O método incrementar() aumenta valor em 1 usando ++valor.
  5. O método getValor() retorna o valor atual; é const porque não modifica o objeto.
  6. No main, criamos Contador c; — o construtor padrão é chamado automaticamente.
  7. Chamamos incrementar() duas vezes e imprimimos o resultado com getValor().

Por que funciona

O encapsulamento garante que valor não seja alterado diretamente fora da classe, apenas por meio de métodos controlados. O construtor assegura que todo objeto Contador comece com valor 0, evitando lixo de memória. Assim, o código é seguro e previsível.

Erros comuns

  • Esquecer public:: os métodos ficam privados e não podem ser chamados no main.
    void incrementar() { ... } sem public: causa erro de compilação.
  • Não inicializar valor no construtor: o membro fica com valor indeterminado.
    Contador() {} deixa valor sem inicialização.
  • Declarar getValor() sem const: não é erro, mas impede chamar em objetos constantes.
    Prefira int getValor() const.

Outra forma de resolver

Usar struct (tudo público por padrão) e inicializar valor diretamente:

struct Contador {
    int valor = 0;
    void incrementar() { ++valor; }
    int getValor() const { return valor; }
};

Isso é preferível quando não há necessidade de encapsulamento rígido.

Saída esperada

Valor: 2