C++ Valores Padrão

Na aula Parâmetros e Argumentos, cada chamada tinha de mandar todos os argumentos, senão vinha o erro too few arguments. Mas muitas vezes um parâmetro quase sempre tem o mesmo valor: a quantidade quase sempre é 1, a linha do recibo quase sempre tem 20 tracinhos. Para esses casos, o C++ deixa você dar ao parâmetro um valor padrão: se a chamada mandar o argumento, ele é usado; se não mandar, entra o padrão. Nesta aula você vai criar parâmetros opcionais e conhecer as duas regras que o compilador cobra: padrões só no fim, e padrão escrito num lugar só.

Todos os programas desta aula foram compilados com o g++ 15 na máquina fictícia da Ana, na pasta ~/cpp, com o comando padrão do guia, g++ -std=c++23 -Wall -Wextra arquivo.cpp -o programa.

A ideia: o pedido "do jeito de sempre"

Na padaria, a Ana pede "um café". O atendente não pergunta o tamanho nem se é com açúcar: ele faz o café de sempre, o médio sem açúcar. Se um dia ela quiser diferente, diz: "um café grande". O que ela não disser fica no padrão.

Um parâmetro com valor padrão funciona assim: a função já sabe o que usar quando a chamada não disser nada. Quem chama só precisa falar o que for diferente do de sempre.

1. Um parâmetro opcional

#include <iostream>
#include <string>

void saudar(std::string nome = "cliente") {
    std::cout << "Olá, " << nome << "!\n";
}

int main() {
    saudar("Ana");
    saudar();
}

std::string nome

O parâmetro, como nas aulas anteriores.

= "cliente"

O valor padrão (em inglês, default argument, "argumento padrão"): o valor que nome recebe quando a chamada não mandar nenhum. Escreve-se com =, como ao criar uma variável.

saudar("Ana");

A chamada mandou o argumento: nome vale "Ana". O padrão é ignorado.

saudar();

A chamada não mandou nada: nome vale o padrão, "cliente". Sem o padrão, esta linha daria too few arguments to function.

$ g++ -std=c++23 -Wall -Wextra saudar.cpp -o saudar
$ ./saudar
Olá, Ana!
Olá, cliente!

Por dentro, é como se o compilador reescrevesse a segunda chamada como saudar("cliente"). A função em si não sabe se o valor veio da chamada ou do padrão.

2. Vários parâmetros com padrão

A linha do recibo da aula Funções sempre tinha 20 tracinhos. A Ana quer poder mudar o tamanho e o símbolo de vez em quando, sem ter de dizer os dois toda vez:

#include <iostream>

void linha(int tamanho = 20, char simbolo = '-') {
    for (int i = 0; i < tamanho; i++) {
        std::cout << simbolo;
    }
    std::cout << "\n";
}

int main() {
    linha();
    linha(10);
    linha(10, '=');
    linha(5, '*');
}

$ g++ -std=c++23 -Wall -Wextra linha.cpp -o linha
$ ./linha
--------------------
----------
==========
*****

A regra é a da aula de parâmetros: os argumentos vão para os parâmetros pela posição, da esquerda para a direita. Os padrões só preenchem o que sobrou no fim.

Mais um exemplo, com três parâmetros e todas as combinações possíveis:

#include <iostream>
#include <string>

void cartao(std::string nome = "cliente", std::string loja = "Lojinha da Ana", int desconto = 5) {
    std::cout << loja << ": " << nome << " ganhou " << desconto << "% de desconto\n";
}

int main() {
    cartao();
    cartao("Bruno");
    cartao("Carla", "Papelaria Central");
    cartao("Davi", "Lojinha da Ana", 10);
}

$ g++ -std=c++23 -Wall -Wextra todos.cpp -o todos
$ ./todos
Lojinha da Ana: cliente ganhou 5% de desconto
Lojinha da Ana: Bruno ganhou 5% de desconto
Papelaria Central: Carla ganhou 5% de desconto
Lojinha da Ana: Davi ganhou 10% de desconto

Repare na última chamada: para dar 10% ao Davi, a Ana teve de escrever também a loja, "Lojinha da Ana", mesmo sendo o padrão. É a próxima regra.

--------------------
-----
***

#include <iostream>

void linha(int tamanho, char simbolo) {
    for (int i = 0; i < tamanho; i++) {
        std::cout << simbolo;
    }
    std::cout << "\n";
}

int main() {
    linha();
    linha(5);
    linha(3, '*');
}

#include <iostream>

void linha(int tamanho = 20, char simbolo = '-') {
    for (int i = 0; i < tamanho; i++) {
        std::cout << simbolo;
    }
    std::cout << "\n";
}

int main() {
    linha();
    linha(5);
    linha(3, '*');
}

3. Não dá para pular um argumento

E se a Ana quiser o tamanho padrão, mas com =? Em algumas linguagens dá para dizer "pule o primeiro". Em C++, não. A primeira tentativa é deixar o lugar vazio:

#include <iostream>

void linha(int tamanho = 20, char simbolo = '-') {
    for (int i = 0; i < tamanho; i++) {
        std::cout << simbolo;
    }
    std::cout << "\n";
}

int main() {
    linha(, '=');
}

$ g++ -std=c++23 -Wall -Wextra pular2.cpp -o pular2
pular2.cpp: In function ‘int main()’:
pular2.cpp:11:11: error: expected primary-expression before ‘,’ token
   11 |     linha(, '=');
      |           ^

Expected primary-expression before ‘,’ token = "esperava uma expressão antes da vírgula": um argumento vazio não existe em C++.

A segunda tentativa é pior, porque compila:

#include <iostream>

void linha(int tamanho = 20, char simbolo = '-') {
    for (int i = 0; i < tamanho; i++) {
        std::cout << simbolo;
    }
    std::cout << "\n";
}

int main() {
    linha('=');
}

$ g++ -std=c++23 -Wall -Wextra pular.cpp -o pular        « nenhum aviso
$ ./pular
-------------------------------------------------------------

Saíram 61 tracinhos! O argumento '=' foi para o primeiro parâmetro, tamanho, que é int. Um char é um número por dentro (o código do = é 61, veja Caracteres), e a conversão implícita fez o resto. O simbolo ficou com o padrão '-'.

A única forma é escrever também o primeiro: linha(20, '=');. Por isso, ao criar a função, ponha por último o parâmetro que menos muda: quem chama vai querer trocar os primeiros sem precisar repetir os outros.

4. Os padrões só podem ficar no fim

Como os argumentos são distribuídos da esquerda para a direita, um parâmetro com padrão não pode ter, depois dele, um parâmetro sem padrão. A Ana tentou deixar a quantidade opcional no meio:

#include <iostream>
#include <string>

void item(std::string produto, int quantidade = 1, double preco) {
    std::cout << quantidade << " x " << produto
              << " = R$ " << quantidade * preco << "\n";
}

int main() {
    item("caneta", 2.5);
}

$ g++ -std=c++23 -Wall -Wextra meio.cpp -o meio
meio.cpp:4:59: error: default argument missing for parameter 3 of ‘void item(std::string, int, double)’
    4 | void item(std::string produto, int quantidade = 1, double preco) {
      |                                                    ~~~~~~~^~~~~
meio.cpp:4:36: note: ...following parameter 2 which has a default argument
    4 | void item(std::string produto, int quantidade = 1, double preco) {
      |                                ~~~~^~~~~~~~~~~~~~

default argument missing for parameter 3

"Falta o argumento padrão do parâmetro 3" (o preco).

note: ...following parameter 2 which has a default argument

"…que vem depois do parâmetro 2, que tem argumento padrão". Como a quantidade tem padrão, todo parâmetro depois dela também precisaria ter.

Pense na chamada item("caneta", 2.5): o 2.5 deveria ir para a quantidade ou para o preço? Pela posição, iria para a quantidade, e o preço ficaria sem nada. O compilador corta o problema pela raiz. A correção é mudar a ordem, deixando o opcional no fim:

#include <iostream>
#include <string>

void item(std::string produto, double preco, int quantidade = 1) {
    std::cout << quantidade << " x " << produto
              << " = R$ " << quantidade * preco << "\n";
}

int main() {
    item("caneta", 2.5);
    item("caderno", 10.0, 3);
}

$ g++ -std=c++23 -Wall -Wextra fim.cpp -o fim
$ ./fim
1 x caneta = R$ 2.5
3 x caderno = R$ 30

5. Com protótipo: o padrão vai num lugar só

Quando a função tem declaração antecipada (o protótipo, da aula Funções), o padrão aparece duas vezes? Não. A Ana tentou escrever nos dois lugares:

#include <iostream>

void linha(int tamanho = 20, char simbolo = '-');

int main() {
    linha();
}

void linha(int tamanho = 20, char simbolo = '-') {
    for (int i = 0; i < tamanho; i++) {
        std::cout << simbolo;
    }
    std::cout << "\n";
}

$ g++ -std=c++23 -Wall -Wextra duas.cpp -o duas
duas.cpp:9:6: error: default argument given for parameter 1 of ‘void linha(int, char)’ [-fpermissive]
    9 | void linha(int tamanho = 20, char simbolo = '-') {
      |      ^~~~~
duas.cpp:3:6: note: previous specification in ‘void linha(int, char)’ here
    3 | void linha(int tamanho = 20, char simbolo = '-');
      |      ^~~~~
duas.cpp:9:6: error: default argument given for parameter 2 of ‘void linha(int, char)’ [-fpermissive]
    9 | void linha(int tamanho = 20, char simbolo = '-') {
      |      ^~~~~
duas.cpp:3:6: note: previous specification in ‘void linha(int, char)’ here
    3 | void linha(int tamanho = 20, char simbolo = '-');
      |      ^~~~~

default argument given for parameter 1

"Argumento padrão dado para o parâmetro 1" na linha 9, a definição. Um erro para cada parâmetro repetido (1 e 2).

note: previous specification … here

"Especificação anterior aqui": o padrão já tinha sido dado na linha 3, o protótipo. Mesmo sendo o mesmo valor, repetir é proibido.

[-fpermissive]

Ignore: é uma opção antiga que relaxaria a regra. Não use.

Então, deixar o padrão só na definição? Também não funciona, porque o main vem antes dela:

#include <iostream>

void linha(int tamanho, char simbolo);

int main() {
    linha();
}

void linha(int tamanho = 20, char simbolo = '-') {
    for (int i = 0; i < tamanho; i++) {
        std::cout << simbolo;
    }
    std::cout << "\n";
}

$ g++ -std=c++23 -Wall -Wextra sodef.cpp -o sodef
sodef.cpp: In function ‘int main()’:
sodef.cpp:6:10: error: too few arguments to function ‘void linha(int, char)’
    6 |     linha();
      |     ~~~~~^~
sodef.cpp:3:6: note: declared here
    3 | void linha(int tamanho, char simbolo);
      |      ^~~~~

Lembre: o compilador lê de cima para baixo. Na linha 6, ele só conhece o protótipo da linha 3, que não tem padrão nenhum; o padrão da linha 9 ainda não foi lido. O certo é o padrão no protótipo, que é o que quem chama enxerga, e a definição sem ele:

#include <iostream>

void linha(int tamanho = 20, char simbolo = '-');

int main() {
    linha();
    linha(8, '~');
}

void linha(int tamanho, char simbolo) {
    for (int i = 0; i < tamanho; i++) {
        std::cout << simbolo;
    }
    std::cout << "\n";
}

$ g++ -std=c++23 -Wall -Wextra certo.cpp -o certo
$ ./certo
--------------------
~~~~~~~~

6. O que pode ser um valor padrão

Qualquer valor do tipo do parâmetro: um número, um texto, uma constante com nome. Uma constante deixa claro de onde veio o número e permite mudá-lo num lugar só (aula Constantes):

#include <iostream>

const double TAXA_PADRAO = 0.05;

double comTaxa(double valor, double taxa = TAXA_PADRAO) {
    return valor + valor * taxa;
}

int main() {
    std::cout << comTaxa(100) << "\n";
    std::cout << comTaxa(100, 0.10) << "\n";
}

$ g++ -std=c++23 -Wall -Wextra constante.cpp -o constante
$ ./constante
105                      « taxa padrão de 5%
110                      « taxa de 10%, mandada na chamada

Repare que os valores padrão funcionam igual em funções que devolvem um resultado, como esta.

Valor padrão ou outra forma?

Existe outro jeito de deixar uma função ser chamada com números diferentes de argumentos: escrever duas funções com o mesmo nome, a sobrecarga. Quando usar cada uma:

Cuidado para não exagerar: uma função com cinco parâmetros opcionais fica difícil de chamar (lembre do Davi, que teve de repetir a loja). Se isso acontecer, talvez seja hora de agrupar as opções numa struct.

Quando dá errado

Referência rápida

Exercícios

Missão final: etiquetas de preço

caderno: R$ 30 à vista
mochila: 3x de R$ 30
estojo: R$ 12.5 à vista

#include <iostream>
#include <string>

// protótipo aqui

int main() {
    etiqueta("caderno", 30);
    etiqueta("mochila", 90, 3);
    etiqueta("estojo", 12.5);
}

// definição aqui

#include <iostream>
#include <string>

void etiqueta(std::string produto, double preco, int parcelas = 1);

int main() {
    etiqueta("caderno", 30);
    etiqueta("mochila", 90, 3);
    etiqueta("estojo", 12.5);
}

void etiqueta(std::string produto, double preco, int parcelas) {
    if (parcelas == 1) {
        std::cout << produto << ": R$ " << preco << " à vista\n";
    } else {
        std::cout << produto << ": " << parcelas << "x de R$ " << preco / parcelas << "\n";
    }
}

Resumo

• tipo nome = valor na lista de parâmetros dá um valor padrão: se a chamada não mandar o argumento, ele é usado.
• Os argumentos vão para os parâmetros da esquerda para a direita; os padrões preenchem o que faltou no fim.
• Parâmetros com padrão ficam no fim da lista. Senão: default argument missing for parameter N.
• Não dá para pular um argumento do meio. E cuidado: linha('=') manda o '=' (61) para o primeiro parâmetro.
• Com protótipo, o padrão vai só no protótipo. Nos dois lugares: default argument given for parameter … previous specification. Só na definição: too few arguments na chamada.
• Próxima aula: Por Valor × Por Referência, para a função poder mudar a variável de quem chama.