Valor de retorno e operador return

1. Introdução

Imagina só: tu pede uma pizza pelo telefone (ou pelo app, né, século XXI). Tu passa os detalhes do pedido pro atendente, e ele te devolve o resultado: a pizza! Se o atendente fica mudo — tu fica com fome e sem alegria.

Com funções é igual: às vezes elas só fazem uma ação, mas na real, a gente quase sempre quer que a função devolva alguma coisa útil, e esse resultado pode mudar dependendo do que tu passar pra ela! Tipo:

• Função calcula a soma de dois números e devolve o resultado.
• Função recebe a idade de uma pessoa e retorna a categoria ("criança", "adulto", "idoso").
• Função monta uma string bonitona pra cumprimentar o usuário pelo nome.

Valor de retorno — é o jeito da função “entregar” pra fora o resultado do que ela fez.

2. Assinatura de método com valor de retorno

Na aula passada a gente viu esse modelinho aqui:

void PrintHello()
{
    Console.WriteLine("Oi!");
}

O tipo void quer dizer que a função não retorna nada (void significa "vazio", ausência de valor).

Agora bora ver como fica uma função que retorna alguma coisa:

int Add(int a, int b)
{
    // corpo da função
}

Aqui o int antes do nome da função é o tipo do valor que ela vai retornar. Se a função retorna uma string — coloca string, se for número com vírgula — double, e por aí vai.

A sintaxe pra declarar uma função é assim:

<tipo do valor de retorno> NomeDoMetodo(<parâmetros>)
{
    // corpo da função
}

Exemplos de várias assinaturas:

int Sum(int a, int b)

string GetGreeting(string name)

double Multiply(double x, double y)

bool IsAdult(int age)

3. Operador return: como devolver resultado da função

Pra tudo funcionar, não basta só dizer o tipo certo — tem que ensinar a função a mandar o resultado de volta “pra cima”. Pra isso serve o operador return. Com ele a gente fala: ó, tô devolvendo esse valor aqui, e a função termina na hora (ela meio que "sai" pra fora nesse momento).

tipo NomeDoMetodo(...)
{
    // alguns cálculos
    return valor;
}

Exemplo:

int Add(int a, int b)
{
    int sum = a + b;
    return sum; // devolve a soma como resultado da função
}

Regra importante: o tipo do valor que tu retorna com return tem que bater (ou ser compatível) com o tipo que tu colocou na assinatura do método.

4. Exemplos: escrevendo métodos que retornam alguma coisa

Bora ver na prática! Olha só alguns casos bem comuns.

Exemplo 1: somando dois números

int Add(int a, int b)
{
    return a + b;
}

// Usando:
int result = Add(10, 20);
Console.WriteLine("Soma: " + result); // Saída: Soma: 30

Exemplo 2: saudação personalizada

string CreateGreeting(string name)
{
    return "Oi, " + name + "!";
}

// Usando:
string greeting = CreateGreeting("Anna");
Console.WriteLine(greeting); // Saída: Oi, Anna!

Exemplo 3: checando maioridade

bool IsAdult(int age)
{
    return age >= 18;
}

if (IsAdult(21))
{
    Console.WriteLine("Entrada liberada.");
}
else
{
    Console.WriteLine("Desculpa, só para adultos.");
}
// Saída: Entrada liberada.

Exemplo 4: valor de retorno e uso em expressões

Console.WriteLine("O dobro: " + MultiplyByTwo(7));

int MultiplyByTwo(int n)
{
    return n * 2;
}

5. Tipo do valor de retorno: variedade e detalhes

Em C# a função pode retornar qualquer "tipo" (não só número, string e o básico). Olha só alguns exemplos:

• Números inteiros: int, long, short — tranquilo.
• Com vírgula: double, float, decimal.
• Strings: string.
• Booleanos: bool.
• Arrays: int[], string[] e por aí vai.
• Tipos por referência: objetos das classes que tu criou.
• void: caso especial, quando não retorna nada.

Por que o tipo do valor de retorno é tão importante?

O compilador fica de olho pra garantir que tu tá retornando o que prometeu. Se tu prometeu int, mas tenta devolver uma string ou nada — vai dar erro. Tipo um chefe chato.

Exemplo de erro:

int GetNumber()
{
    return "42"; // Erro! Esperava int, não string.
}

6. Operador return sem valor: pra métodos void

Pra ser justo, em métodos que têm tipo de retorno declarado (tipo int, string), o operador return sempre tem que vir com o valor que tu quer devolver.

Mas! Se a função é void, tu pode sim usar return sem valor — só pra sair da função na hora.

void PrintNumbers(int n)
{
    if (n <= 0)
    {
        Console.WriteLine("O número não pode ser negativo!");
        return; // Só sai da função, não retorna nada
    }
    for (int i = 1; i <= n; i++)
    {
        Console.WriteLine(i);
    }
}

Isso é útil quando tu quer parar a função por algum motivo, mas não precisa devolver nada.

7. Erros comuns usando return

Nossa, como a galera que tá começando quebra a cabeça com erro de return!

Problema #1: não tem return na função que deveria retornar algo

int GetValue(bool flag)
{
    if (flag)
        return 1;
    // Opa! E se flag == false?
}
// Erro: nem todos os caminhos retornam valor!

Solução: sempre coloca return pra todos os caminhos possíveis! Tipo:

int GetValue(bool flag)
{
    if (flag)
        return 1;
    else
        return 0;
}

Problema #2: tipo do valor de retorno não bate

double GetMagicNumber()
{
    return 42; // Aqui tá ok (int pode virar double sem problema)
    // Mas se fosse int e tu devolvesse string — ia dar ruim!
}

Regra: cuida pra ser compatível. Se ficar na dúvida — converte pro tipo certo:

return (double)42;

Problema #3: return na hora errada

Fica ligado: quando executa o return, o método para na hora. Tudo que vem depois, nem roda!

int GetNumber()
{
    return 5;
    Console.WriteLine("Essa linha nunca vai rodar"); // o compilador até reclama!
}

Problema #4: return com valor em método void (proibido!)

void PrintSomething()
{
    return 1; // Não pode retornar valor de método void!
}