Valeur de retour et opérateur return

1. Introduction

Imagine : tu commandes une pizza par téléphone (ou via une appli, on est quand même au XXIe siècle). Tu donnes à l’opérateur les détails de ta commande, et il te renvoie le résultat : la pizza ! Si l’opérateur ne dit rien — t’as faim, et c’est la déprime.

C’est pareil avec les fonctions : parfois leur taf c’est juste faire une action, mais souvent on veut qu’une fonction renvoie aussi un truc utile, et ce résultat peut changer selon les paramètres ! Par exemple :

• Une fonction calcule la somme de deux nombres et te donne le résultat.
• Une fonction reçoit l’âge d’une personne et renvoie une catégorie ("enfant", "adulte", "retraité").
• Une fonction crée une jolie chaîne pour saluer l’utilisateur par son prénom.

Valeur de retour — c’est la façon pour une fonction de “passer” le résultat de son taf à l’extérieur.

2. Signature d’une méthode avec valeur de retour

Dans la leçon précédente, on a vu ce genre de modèle :

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

Le type void veut dire que la fonction ne renvoie rien (void = "vide", pas de valeur).

Voyons maintenant à quoi ressemble une fonction qui renvoie quelque chose :

int Add(int a, int b)
{
    // corps de la fonction
}

Ici, int devant le nom de la fonction — c’est le type de la valeur de retour. Donc, si la fonction renvoie une chaîne — on écrit string, si c’est un nombre à virgule — double, etc.

La syntaxe pour déclarer une fonction ressemble à ça :

<type de retour> NomMethode(<paramètres>)
{
    // corps de la fonction
}

Exemples de signatures différentes :

int Sum(int a, int b)

string GetGreeting(string name)

double Multiply(double x, double y)

bool IsAdult(int age)

3. L’opérateur return : comment renvoyer un résultat depuis une fonction

Pour que tout marche, c’est pas suffisant d’indiquer le type — il faut apprendre à la fonction à renvoyer le résultat “vers le haut”. Pour ça, on utilise l’opérateur return. Avec lui, on dit : voilà, je renvoie cette valeur, et la fonction s’arrête là (elle “sort” à ce moment).

type NomMethode(...)
{
    // quelques calculs
    return valeur;
}

Exemple :

int Add(int a, int b)
{
    int sum = a + b;
    return sum; // on renvoie la somme comme résultat de la fonction
}

Règle importante : le type de la valeur renvoyée par return doit correspondre (ou être compatible) avec le type que t’as mis dans la signature de la méthode.

4. Exemples : on écrit des méthodes qui renvoient quelque chose

On va voir direct sur des exemples ! Voici quelques cas classiques.

Exemple 1 : addition de deux nombres

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

// Utilisation :
int result = Add(10, 20);
Console.WriteLine("Somme : " + result); // Affiche : Somme : 30

Exemple 2 : salutation personnalisée

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

// Utilisation :
string greeting = CreateGreeting("Anna");
Console.WriteLine(greeting); // Affiche : Salut, Anna !

Exemple 3 : vérifier la majorité

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

if (IsAdult(21))
{
    Console.WriteLine("Entrée autorisée.");
}
else
{
    Console.WriteLine("Désolé, réservé aux adultes.");
}
// Affiche : Entrée autorisée.

Exemple 4 : valeur de retour et utilisation dans les expressions

Console.WriteLine("Deux fois plus : " + MultiplyByTwo(7));

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

5. Type de valeur de retour : diversité et particularités

En C#, une fonction peut renvoyer n’importe quel "type" (pas que des nombres, des chaînes, etc). Voici quelques cas :

• Nombres entiers : int, long, short — easy.
• Nombres à virgule : double, float, decimal.
• Chaînes : string.
• Booléens : bool.
• Tableaux : int[], string[] etc.
• Types référence : objets de classes que t’as créées.
• void : cas spécial, rien n’est renvoyé.

Pourquoi le type de retour est-il si important ?

Le compilateur vérifie à la loupe que tu renvoies bien ce que t’as promis. Si t’as promis de renvoyer un int, mais tu renvoies une chaîne ou rien du tout — erreur. Un vrai chef relou.

Exemple d’erreur :

int GetNumber()
{
    return "42"; // Erreur ! On attendait un int, pas un string.
}

6. L’opérateur return sans valeur : pour les méthodes void

Pour être honnête, dans les méthodes avec un type de retour déclaré (genre int, string), l’opérateur return doit toujours être suivi d’une valeur à renvoyer.

Mais ! Si la fonction est déclarée avec le type void, tu peux quand même utiliser return sans valeur — juste pour arrêter la fonction tout de suite.

void PrintNumbers(int n)
{
    if (n <= 0)
    {
        Console.WriteLine("Le nombre ne doit pas être négatif !");
        return; // On sort juste de la fonction, sans rien renvoyer
    }
    for (int i = 1; i <= n; i++)
    {
        Console.WriteLine(i);
    }
}

C’est pratique si tu veux arrêter la fonction selon une condition, mais t’as rien à renvoyer.

7. Erreurs classiques avec return

Ah, combien de fois les débutants se prennent la tête avec des erreurs liées à return !

Problème n°1 : pas de return dans une fonction qui doit renvoyer quelque chose

int GetValue(bool flag)
{
    if (flag)
        return 1;
    // Oups ! Et si flag == false ?
}
// Erreur : tous les chemins ne contiennent pas un return !

Solution : prévois toujours un return dans tous les scénarios ! Par exemple :

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

Problème n°2 : type de valeur de retour incorrect

double GetMagicNumber()
{
    return 42; // En vrai, ça passe (int peut être converti en double)
    // Mais si la fonction devait renvoyer un int et tu renvoies une chaîne — erreur !
}

Règle : fais gaffe à la compatibilité des types. Si t’as un doute — convertis explicitement :

return (double)42;

Problème n°3 : return trop tôt

Sache que dès que return s’exécute, la méthode s’arrête direct. Tout ce qui est après ne sera jamais exécuté !

int GetNumber()
{
    return 5;
    Console.WriteLine("Cette ligne ne sera jamais exécutée"); // le compilateur va râler !
}

Problème n°4 : return dans une méthode void avec une valeur de retour (interdit !)

void PrintSomething()
{
    return 1; // Impossible de renvoyer une valeur depuis une méthode void !
}