C++ Métodos

Na aula Classes e Objetos, a classe Produto só guardava dados, e quem fazia as contas era o main. Agora a classe vai ganhar ações: funções que moram dentro dela e trabalham com os dados do objeto. Essas funções se chamam métodos (ou funções-membro). Você já sabe escrever funções; um método é uma função com um "dono".

Os programas desta aula foram compilados e executados na máquina fictícia da Ana, na pasta ~/cpp/metodos, com o g++ 15.2 e o comando padrão g++ -std=c++23 -Wall -Wextra arquivo.cpp -o programa.

A ideia: as instruções no verso da ficha

A ficha de produto da Ana tem, na frente, os campos (nome, preço, estoque) e, no verso, as instruções: "para mostrar na vitrine, escreva o nome e o preço"; "para repor, some a quantidade ao estoque". As instruções são as mesmas para todo produto, mas cada vez que alguém as segue, segue numa ficha específica: repor canetas mexe na ficha da caneta, não na do caderno.

Métodos são isso: as instruções escritas uma vez, na classe, e executadas sempre sobre um objeto. Quando você escreve caderno.repor(4), está dizendo "siga a instrução repor, na ficha do caderno, com a quantidade 4".

1. O primeiro método

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    void mostrar() {
        std::cout << nome << ": R$ " << preco << " (" << estoque << " no estoque)\n";
    }

    int valorEmEstoque() {
        return preco * estoque;
    }

    void repor(int quantidade) {
        estoque += quantidade;
    }
};

int main() {
    Produto caneta{"caneta", 3, 50};
    Produto caderno{"caderno", 12, 8};

    caneta.mostrar();
    caderno.mostrar();

    caderno.repor(4);
    caderno.mostrar();

    std::cout << "Valor das canetas: R$ " << caneta.valorEmEstoque() << "\n";
    int total = caneta.valorEmEstoque() + caderno.valorEmEstoque();
    std::cout << "Valor total: R$ " << total << "\n";
}

$ g++ -std=c++23 -Wall -Wextra metodos.cpp -o metodos
$ ./metodos
caneta: R$ 3 (50 no estoque)
caderno: R$ 12 (8 no estoque)
caderno: R$ 12 (12 no estoque)
Valor das canetas: R$ 150
Valor total: R$ 294

A classe agora tem três métodos. Veja o primeiro em detalhe:

void mostrar() { … }

Uma função comum, com tipo de retorno (void, nada), nome e parênteses, só que escrita dentro da classe. Por estar abaixo do public:, o main pode chamá-la.

nome, preco, estoque

O método usa os atributos direto, sem ponto e sem parâmetro. Ele sempre trabalha sobre o objeto que o chamou: em caneta.mostrar(), nome é o nome da caneta; em caderno.mostrar(), o do caderno.

caneta.mostrar();

A chamada: objeto, ponto, nome do método e parênteses. Os parênteses são obrigatórios, mesmo vazios: são eles que dizem "execute".

Compare com a versão da aula O que é POO, em que mostrar era uma função solta: lá ela precisava receber const Produto& p e escrever p.nome, p.preco. O método não precisa, porque o objeto vai junto automaticamente, pelo lado esquerdo do ponto. (Como o C++ faz isso por baixo dos panos é o assunto da aula this.)

2. Métodos que devolvem um valor

Um método pode ter qualquer tipo de retorno, como uma função (aula Retorno). O valorEmEstoque devolve um int:

int valorEmEstoque()

Devolve um inteiro: quanto dinheiro está parado no estoque deste produto.

return preco * estoque;

Usa os atributos do objeto que chamou. Para a caneta: 3 × 50 = 150.

caneta.valorEmEstoque() + caderno.valorEmEstoque()

A chamada vira um valor, e você usa esse valor como qualquer número: soma, guarda numa variável, mostra. 150 + 12 × 12 = 150 + 144 = 294.

Repare na diferença entre um atributo e um método que devolve valor: caneta.estoque é um dado guardado; caneta.valorEmEstoque() é uma conta feita na hora, sempre atualizada. Não faz sentido guardar o "valor em estoque" num atributo, porque ele ficaria errado assim que o estoque mudasse.

3. Métodos que recebem parâmetros e mudam o objeto

O repor recebe a quantidade como parâmetro, igual a uma função comum, e muda um atributo:

void repor(int quantidade)

Recebe um int. Na chamada caderno.repor(4), quantidade vale 4.

estoque += quantidade;

Muda o estoque do próprio objeto. Não precisa de &, nem de devolver nada: o método mexe direto no objeto que o chamou. Por isso o caderno passou de 8 para 12 unidades.

Na versão com função solta, era preciso passar o produto por referência (void repor(Produto& p, int q)), senão a mudança se perdia numa cópia. Com o método, o objeto já vem "por referência": o método trabalha no original.

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    void mostrar() {
        std::cout << nome << ": R$ " << preco << " (" << estoque << " no estoque)\n";
    }

    int valorEmEstoque() {
        return preco * estoque;
    }

    void repor(int quantidade) {
        estoque += quantidade;
    }
};

int main() {
    Produto caneta{"caneta", 3, 50};
    caneta.mostrar();
    std::cout << "Valor das canetas: R$ " << caneta.valorEmEstoque() << "\n";
}

4. Um método chamando outro

Dentro de um método, você chama os outros métodos do mesmo objeto pelo nome, sem ponto, do mesmo jeito que usa os atributos. Aqui, vender confere o estoque com temEstoque e mostra o resultado com mostrar:

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    void mostrar() {
        std::cout << nome << ": R$ " << preco << " (" << estoque << " no estoque)\n";
    }

    bool temEstoque(int quantidade) {
        return quantidade <= estoque;
    }

    bool vender(int quantidade) {
        if (!temEstoque(quantidade)) {
            std::cout << "Não há " << quantidade << " " << nome << "(s). ";
            mostrar();
            return false;
        }
        estoque -= quantidade;
        std::cout << "Vendeu " << quantidade << ". ";
        mostrar();
        return true;
    }
};

int main() {
    Produto caderno{"caderno", 12, 8};

    caderno.vender(3);
    caderno.vender(10);

    if (caderno.vender(5)) {
        std::cout << "Acabaram os cadernos!\n";
    }
}

$ g++ -std=c++23 -Wall -Wextra vender.cpp -o vender
$ ./vender
Vendeu 3. caderno: R$ 12 (5 no estoque)
Não há 10 caderno(s). caderno: R$ 12 (5 no estoque)
Vendeu 5. caderno: R$ 12 (0 no estoque)
Acabaram os cadernos!

bool temEstoque(int quantidade)

Responde "sim" ou "não" (aula bool): há pelo menos quantidade unidades?

if (!temEstoque(quantidade))

Chama outro método do mesmo objeto, sem ponto. Quando o caderno executa vender, o temEstoque chamado aqui também é o do caderno.

mostrar();

Mesma coisa: mostra o objeto que está vendendo.

return false; / return true;

O método avisa a quem chamou se a venda deu certo. O main pode ignorar o resultado (como nas duas primeiras chamadas) ou usá-lo num if (como na terceira).

Essa é uma vantagem grande dos métodos: a regra "só vende se tiver estoque" ficou num lugar só. Quem usa a classe chama vender e não precisa lembrar de conferir. Na aula public e private, você vai fechar a última porta: proibir que alguém mexa no estoque sem passar pelo vender.

5. Declarar dentro, definir fora: Produto::metodo

Quando a classe cresce, os corpos dos métodos ocupam espaço e escondem o que importa: quais métodos existem. Por isso, é comum separar em duas partes:

• a declaração, dentro da classe: só o "cabeçalho" do método, terminado em ;;
• a definição, fora da classe: o corpo completo, com o nome da classe e :: na frente do nome do método.

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    void mostrar();
    void repor(int quantidade);
    int valorEmEstoque();
};

void Produto::mostrar() {
    std::cout << nome << ": R$ " << preco << " (" << estoque << " no estoque)\n";
}

void Produto::repor(int quantidade) {
    estoque += quantidade;
}

int Produto::valorEmEstoque() {
    return preco * estoque;
}

int main() {
    Produto regua{"régua", 5, 20};
    regua.repor(10);
    regua.mostrar();
    std::cout << "Valor: R$ " << regua.valorEmEstoque() << "\n";
}

$ g++ -std=c++23 -Wall -Wextra fora.cpp -o fora
$ ./fora
régua: R$ 5 (30 no estoque)
Valor: R$ 150

void mostrar();

Dentro da classe, só a declaração: "existe um método mostrar, que não recebe nada e não devolve nada". O ; no lugar do corpo diz "o corpo está em outro lugar".

void Produto::mostrar() { … }

A definição. O Produto:: diz "este é o mostrar que pertence à classe Produto". O :: é o operador de escopo, o mesmo de std::cout (o cout que pertence a std, aula Namespaces).

nome, preco, estoque

Graças ao Produto::, o corpo continua enxergando os atributos direto, como se estivesse escrito dentro da classe.

int Produto::valorEmEstoque()

O tipo de retorno vem antes de Produto::. O cabeçalho tem de ser igual ao da declaração: mesmo retorno, mesmo nome, mesmos tipos de parâmetro.

Para o programa, não muda nada: a saída é a mesma. A vantagem é de leitura. Quem abre a classe vê, em poucas linhas, tudo o que um Produto sabe fazer.

Dentro ou fora: qual usar?

Quando dá errado

Nos casos abaixo, o arquivo começa com a mesma classe Produto pública das seções anteriores; quando ela muda, mostramos o arquivo inteiro.

int main() {
    Produto regua{"régua", 5, 20};
    regua.mostrar;
}

$ g++ -std=c++23 -Wall -Wextra parenteses.cpp -o parenteses
parenteses.cpp: In function ‘int main()’:
parenteses.cpp:17:11: error: invalid use of non-static member function ‘void Produto::mostrar()’
   17 |     regua.mostrar;
      |     ~~~~~~^~~~~~~
parenteses.cpp:10:10: note: declared here
   10 |     void mostrar() {
      |          ^~~~~~~

int main() {
    Produto regua{"régua", 5, 20};
    mostrar();
}

$ g++ -std=c++23 -Wall -Wextra semobjeto.cpp -o semobjeto
semobjeto.cpp: In function ‘int main()’:
semobjeto.cpp:17:5: error: ‘mostrar’ was not declared in this scope
   17 |     mostrar();
      |     ^~~~~~~

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    void mostrar();
};

void mostrar() {
    std::cout << nome << ": R$ " << preco << "\n";
}

int main() {
    Produto regua{"régua", 5, 20};
    regua.mostrar();
}

$ g++ -std=c++23 -Wall -Wextra semclasse.cpp -o semclasse
semclasse.cpp: In function ‘void mostrar()’:
semclasse.cpp:14:18: error: ‘nome’ was not declared in this scope
   14 |     std::cout << nome << ": R$ " << preco << "\n";
      |                  ^~~~
semclasse.cpp:14:37: error: ‘preco’ was not declared in this scope
   14 |     std::cout << nome << ": R$ " << preco << "\n";
      |                                     ^~~~~

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    void mostrar();
};

void Produto::mostrar() {
    std::cout << nome << ": R$ " << preco << "\n";
}

void Produto::repor(int quantidade) {
    estoque += quantidade;
}

int main() {
    Produto regua{"régua", 5, 20};
    regua.mostrar();
}

$ g++ -std=c++23 -Wall -Wextra naodeclarado.cpp -o naodeclarado
naodeclarado.cpp:17:6: error: no declaration matches ‘void Produto::repor(int)’
   17 | void Produto::repor(int quantidade) {
      |      ^~~~~~~
naodeclarado.cpp:17:6: note: no functions named ‘void Produto::repor(int)’
naodeclarado.cpp:4:7: note: ‘class Produto’ defined here
    4 | class Produto {
      |       ^~~~~~~

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    void mostrar();
};

int main() {
    Produto regua{"régua", 5, 20};
    regua.mostrar();
}

$ g++ -std=c++23 -Wall -Wextra declarasemdefinir.cpp -o declarasemdefinir
/usr/bin/x86_64-linux-gnu-ld.bfd: /tmp/ccfkcJOb.o: na função "main":
declarasemdefinir.cpp:(.text+0x7d): referência não definida para "Produto::mostrar()"
collect2: error: ld returned 1 exit status

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    int preco() {
        return preco;
    }
};

int main() {
    Produto regua{"régua", 5, 20};
    std::cout << regua.preco() << "\n";
}

$ g++ -std=c++23 -Wall -Wextra mesmonome.cpp -o mesmonome
mesmonome.cpp:12:5: error: ‘int Produto::preco()’ conflicts with a previous declaration
   12 |     }
      |     ^
mesmonome.cpp:7:9: note: previous declaration ‘int Produto::preco’
    7 |     int preco;
      |         ^~~~~
mesmonome.cpp: In function ‘int main()’:
mesmonome.cpp:17:29: error: expression cannot be used as a function
   17 |     std::cout << regua.preco() << "\n";
      |                  ~~~~~~~~~~~^~

Referência rápida

Exercícios

Missão final: o caixa da lojinha

3 cadernos: R$ 36
Caderno agora custa R$ 14

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    void reajustar(int reais);
    int totalDaVenda(int quantidade);
};

// escreva as duas definições aqui

int main() {
    Produto caderno{"caderno", 12, 8};
    std::cout << "3 cadernos: R$ " << caderno.totalDaVenda(3) << "\n";
    caderno.reajustar(2);
    std::cout << "Caderno agora custa R$ " << caderno.preco << "\n";
}

#include <iostream>
#include <string>

class Produto {
public:
    std::string nome;
    int preco;
    int estoque;

    void reajustar(int reais);
    int totalDaVenda(int quantidade);
};

void Produto::reajustar(int reais) {
    preco += reais;
}

int Produto::totalDaVenda(int quantidade) {
    return preco * quantidade;
}

int main() {
    Produto caderno{"caderno", 12, 8};
    std::cout << "3 cadernos: R$ " << caderno.totalDaVenda(3) << "\n";
    caderno.reajustar(2);
    std::cout << "Caderno agora custa R$ " << caderno.preco << "\n";
}

Resumo

• Método = função que mora dentro da classe. Chama-se com objeto.metodo(argumentos); os parênteses são obrigatórios.
• O método enxerga os atributos direto (nome, preco), sempre os do objeto que o chamou.
• Métodos podem devolver valores (int valorEmEstoque()), receber parâmetros (repor(int)) e mudar o objeto, sem precisar de &.
• Dentro de um método, outro método do mesmo objeto se chama sem ponto: mostrar();.
• Dá para declarar na classe (void mostrar();) e definir fora (void Produto::mostrar() { … }). Essa é a base dos arquivos .h e .cpp.
• Erros: sem parênteses → invalid use of non-static member function; sem Produto:: → ‘nome’ was not declared; sem declaração → no declaration matches; sem definição → referência não definida (do ligador); nome repetido → conflicts with a previous declaration.
• Próxima aula: fazer o objeto já nascer preenchido e válido, com Construtores.