📥 Argumentos e Tipos de Retorno · Funções · C/C++

📥 Argumentos e Tipos de Retorno em Funções

"Os argumentos (parâmetros) permitem que funções recebam dados do chamador, enquanto o tipo de retorno permite que a função devolva um resultado. A escolha correta de como passar e retornar dados é crucial para eficiência e segurança."

A comunicação entre uma função e seu chamador ocorre através de dois mecanismos: os argumentos (entrada) e o valor de retorno (saída). Compreender as diferentes formas de passar argumentos e retornar valores é essencial para escrever funções eficientes e seguras.

📤 Passagem de Argumentos: As Três Formas

C/C++ oferece três mecanismos principais para passar dados a uma função. A escolha afeta desempenho, segurança e capacidade de modificar o valor original.

1️⃣ Passagem por Valor (Padrão)

Uma cópia do argumento é criada. Alterações dentro da função não afetam a variável original.

void incrementar(int x) {
    x = x + 1;   // Modifica apenas a cópia local
}

int main() {
    int valor = 5;
    incrementar(valor);
    cout << valor << endl;   // 5 (não mudou!)
}
  

Quando usar: Tipos pequenos (int, char, float) que não precisam ser modificados pela função.

2️⃣ Passagem por Ponteiro

Passa o endereço da variável. A função acessa e modifica o valor original através do ponteiro.

void incrementar(int* x) {
    (*x) = (*x) + 1;   // Modifica o valor original via ponteiro
}

int main() {
    int valor = 5;
    incrementar(&valor);      // Passa o endereço
    cout << valor << endl;   // 6 (mudou!)
}
  

Quando usar: Quando a função precisa modificar o argumento E o argumento pode ser opcional (nullptr). Comum em C e APIs de baixo nível.

3️⃣ Passagem por Referência (Apenas C++)

Sintaxe mais limpa que ponteiros. A função trabalha diretamente com a variável original, sem necessidade de desreferenciar.

void incrementar(int& x) {
    x = x + 1;   // Modifica o valor original diretamente
}

int main() {
    int valor = 5;
    incrementar(valor);       // Passa a variável (sem & na chamada)
    cout << valor << endl;   // 6 (mudou!)
}
  

Quando usar: Quando a função precisa modificar o argumento (preferido em C++). Também para objetos grandes que não devem ser copiados (use const T& se não for modificar).

📊 Comparação dos Métodos de Passagem

Método	Modifica Original?	Cópia?	Pode ser Nulo?	Sintaxe
Por Valor	❌ Não	✅ Sim	N/A	`f(int x)`
Por Ponteiro	✅ Sim	❌ Não	✅ Sim (`nullptr`)	`f(int* x)`
Por Referência	✅ Sim	❌ Não	❌ Não (deve ser válida)	`f(int& x)`
Por Ref. Constante	❌ Não	❌ Não	❌ Não	`f(const int& x)`

📦 Passagem de Arrays como Argumentos

Arrays são sempre passados como ponteiros. O tamanho original é perdido, então geralmente passamos o tamanho como argumento adicional.

// Estas três declarações são equivalentes
void imprimir(int arr[], int tam);
void imprimir(int arr[10], int tam);   // O 10 é ignorado!
void imprimir(int* arr, int tam);

// Para garantir que o array não seja modificado, use const
void imprimir(const int* arr, int tam);
  

🔄 Tipos de Retorno

O tipo de retorno especifica que tipo de valor a função devolve ao chamador.

Tipos Primitivos

int somar(int a, int b) { return a + b; }
double calcularMedia(const int* arr, int tam) { ... }
bool ehValido(const std::string& str) { ... }
char primeiraLetra(const std::string& str) { ... }
  

Retornando void

Funções que não retornam valor são declaradas com void.

void exibirMensagem(const std::string& msg) {
    cout << msg << endl;
    // return; // opcional
}
  

Retornando Ponteiros

// Cuidado: NUNCA retorne ponteiro para variável local!
int* encontrar(int* arr, int tam, int valor) {
    for (int i = 0; i < tam; i++) {
        if (arr[i] == valor) return &arr[i];
    }
    return nullptr;   // Seguro: ponteiro nulo indica "não encontrado"
}
  

⚠️ Nunca retorne ponteiro ou referência para variável local! A memória da variável local é liberada quando a função termina, resultando em um dangling pointer.

int* errado() {
    int local = 42;
    return &local;   // PERIGO! local será destruída
}
    

Retornando Referências (C++)

// Seguro: retorna referência a um elemento de um array passado como argumento
int& obterElemento(int* arr, int indice) {
    return arr[indice];   // arr existe fora da função
}

// Retorno de referência permite modificar o elemento
obterElemento(numeros, 2) = 99;
  

Retornando Estruturas e Objetos

struct Pessoa {
    std::string nome;
    int idade;
};

Pessoa criarPessoa(const std::string& nome, int idade) {
    return {nome, idade};   // C++11: inicialização uniforme
}
  

🎯 Dedução de Tipo de Retorno (C++14)

O compilador pode deduzir o tipo de retorno usando auto.

auto somar(int a, int b) {
    return a + b;   // Compilador deduz que retorna int
}

auto criarMensagem() {
    return std::string("Olá");   // Deduz std::string
}
  

📊 Resumo: O que Pode Ser Retornado?

Tipo	Exemplo	Seguro?	Observação
Tipo primitivo	`int`, `double`	✅ Sim	Cópia é retornada
Estrutura/Classe	`Pessoa`, `std::string`	✅ Sim	Cópia (ou move) é retornada
Ponteiro para heap	`new int(42)`	✅ Sim	Chamador deve liberar
Ponteiro para argumento	`&arr[i]`	✅ Sim	Argumento existe fora
Ponteiro para global/estática	`&global`	✅ Sim	Persiste
Ponteiro para local	`&local`	❌ Não	Dangling pointer

💡 Boas Práticas

✅ Prefira passar objetos grandes por referência constante (const T&) para evitar cópias.
✅ Use referências (T&) quando a função precisar modificar o argumento.
✅ Use ponteiros apenas quando o argumento for opcional (pode ser nullptr) ou em código C.
✅ Nunca retorne ponteiros ou referências para variáveis locais.
✅ Para funções que retornam ponteiros, documente quem é responsável por liberar a memória.

🔗 Conclusão

A escolha correta de como passar argumentos e retornar valores impacta diretamente a eficiência, segurança e clareza do código. Em C++, a passagem por referência (especialmente const T&) é geralmente preferida para objetos grandes, enquanto tipos pequenos podem ser passados por valor. Compreender as implicações de cada método é essencial para escrever funções robustas e bem projetadas.

⏭️ Próximo: Ponteiros para funções...