📦 Um Pouco Mais Sobre Argumentos · Tópicos Avançados · C++

📦 Um Pouco Mais Sobre Argumentos

"Além da passagem básica por valor, ponteiro e referência, C++ oferece recursos avançados para argumentos: valores padrão, listas de inicialização, quantidade variável e forwarding perfeito."

Dominar as nuances dos argumentos de função permite escrever interfaces mais flexíveis, expressivas e eficientes. Vamos explorar recursos que vão além do básico e são essenciais no C++ moderno.

📌 Argumentos com Valor Padrão

Parâmetros podem ter valores padrão, tornando-os opcionais na chamada. Os parâmetros com valor padrão devem vir depois dos sem valor padrão.

// Parâmetro 'b' tem valor padrão 0
int incrementar(int a, int b = 1) {
    return a + b;
}

int main() {
    cout << incrementar(5) << endl;      // 6 (b assume 1)
    cout << incrementar(5, 3) << endl;   // 8 (b = 3)
}

// Múltiplos parâmetros com valor padrão
void configurar(const std::string& nome, 
                  int timeout = 30, 
                  bool verbose = false) {
    // ...
}

// ERRO: parâmetro com valor padrão antes de sem valor padrão
// void errado(int a = 10, int b);  // Não compila!
  

💡 Valores padrão na declaração: Coloque os valores padrão apenas na declaração (protótipo), não na definição. Se a função não tiver protótipo separado, coloque na definição.

📋 Argumentos em Lista de Inicialização (std::initializer_list)

Permite que uma função receba um número variável de argumentos do mesmo tipo de forma segura.

#include <initializer_list>

int somar(std::initializer_list<int> numeros) {
    int total = 0;
    for (int n : numeros) {
        total += n;
    }
    return total;
}

int main() {
    cout << somar({1, 2, 3}) << endl;        // 6
    cout << somar({10, 20, 30, 40}) << endl; // 100
    cout << somar({5}) << endl;                // 5
    cout << somar({}) << endl;                   // 0
}
  

🔢 Argumentos Variádicos (Estilo C)

Funções como printf usam ... (ellipsis) para número variável de argumentos. Não é type-safe e deve ser evitado em C++ moderno.

#include <cstdarg>

int somar(int count, ...) {
    va_list args;
    va_start(args, count);
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += va_arg(args, int);
    }
    va_end(args);
    return total;
}

// somar(3, 10, 20, 30);  // 60
  

⚠️ Evite ellipsis em C++! Prefira std::initializer_list, variadic templates ou sobrecarga de funções. Ellipsis não verifica tipos e é propensa a erros.

🧬 Variadic Templates (C++11)

A forma moderna e type-safe de lidar com número variável de argumentos de tipos potencialmente diferentes.

// Caso base: sem argumentos
void imprimir() {
    cout << endl;
}

// Caso recursivo: imprime o primeiro e chama para o resto
template<typename T, typename... Args>
void imprimir(T primeiro, Args... resto) {
    cout << primeiro << " ";
    imprimir(resto...);
}

int main() {
    imprimir(1, "olá", 3.14, 'A');
    // Saída: 1 olá 3.14 A
}
  

🔄 Perfect Forwarding (C++11)

Preserva a categoria de valor (lvalue/rvalue) e qualificadores const dos argumentos ao passá-los adiante.

template<typename T>
void wrapper(T&& arg) {
    // std::forward preserva a natureza de arg
    funcaoReal(std::forward<T>(arg));
}

// Exemplo prático: fábrica de objetos
template<typename T, typename... Args>
std::unique_ptr<T> make_unique_wrapper(Args&&... args) {
    return std::make_unique<T>(std::forward<Args>(args)...);
}
  

📊 Comparação dos Métodos para Múltiplos Argumentos

Método	Type-Safe?	Tipos Diferentes?	Complexidade	Quando Usar
`std::initializer_list`	✅ Sim	❌ Não (mesmo tipo)	Baixa	Listas homogêneas
Variadic Templates	✅ Sim	✅ Sim	Média/Alta	C++ moderno, genéricos
Ellipsis (C)	❌ Não	✅ Sim	Média	Evitar em C++
Sobrecarga	✅ Sim	✅ Sim	Baixa	Poucas combinações fixas

📝 Argumentos com auto (C++20)

Parâmetros de função podem ser declarados com auto, tornando a função um template implícito.

// C++20: função template abreviada
void imprimir(auto valor) {
    cout << valor << endl;
}

// Equivalente a:
// template<typename T>
// void imprimir(T valor) { ... }

int main() {
    imprimir(42);           // T = int
    imprimir("olá");        // T = const char*
    imprimir(3.14);         // T = double
}
  

🎯 Argumentos como Rvalue References (Move Semantics)

Permite "roubar" recursos de objetos temporários, evitando cópias desnecessárias.

class Buffer {
    int* dados;
    size_t tamanho;
public:
    // Construtor de movimento
    Buffer(Buffer&& outro) noexcept 
        : dados(outro.dados), tamanho(outro.tamanho) {
        outro.dados = nullptr;
        outro.tamanho = 0;
    }
};

void processar(Buffer buf) { /* ... */ }

int main() {
    Buffer temp;
    processar(std::move(temp));   // Move, não copia
}
  

💡 Boas Práticas

✅ Use valores padrão para tornar funções mais flexíveis e reduzir sobrecargas.
✅ Prefira std::initializer_list para listas homogêneas de tamanho variável.
✅ Use variadic templates para código genérico com múltiplos tipos.
✅ Passe objetos grandes por const T& se não forem modificados; por T&& se for para tomar posse.
✅ Evite ellipsis (...) estilo C — não é type-safe.

🔗 Conclusão

O sistema de argumentos em C++ é extremamente rico e flexível. Desde os simples valores padrão até templates variádicos e perfect forwarding, cada recurso tem seu lugar e propósito. Dominar essas ferramentas permite criar APIs elegantes, eficientes e fáceis de usar, que se integram perfeitamente com o resto da linguagem.

⏭️ Próximo: Sobrecarga de funções...