Créer des fonctions en C

Introduction

Dans ce laboratoire (lab), vous apprendrez à créer et à utiliser des fonctions en programmation C. Le laboratoire couvre les concepts fondamentaux de la déclaration et de la définition des fonctions, la compréhension des arguments de fonction, le renvoi de valeurs par les fonctions, la gestion des fonctions void et la pratique de l'utilisation des fonctions. Vous explorerez ces sujets grâce à des exemples pratiques et des exercices, ce qui vous permettra d'acquérir les compétences nécessaires pour écrire un code C modulaire et réutilisable.

Le laboratoire commence par l'introduction des bases de la déclaration et de la définition des fonctions, en démontrant comment créer et appeler des fonctions simples. Il approfondit ensuite la compréhension des arguments de fonction, en montrant comment passer différents types de données en entrée des fonctions. Le laboratoire couvre également le concept de valeurs de retour, en vous guidant sur la façon de renvoyer des données depuis les fonctions. De plus, le laboratoire explore l'utilisation des fonctions void, qui ne renvoient aucune valeur. Enfin, vous aurez l'occasion de pratiquer et d'appliquer les concepts appris grâce à divers exercices.

Déclarer et définir des fonctions

Dans cette étape, vous apprendrez à déclarer et définir des fonctions en programmation C. Les fonctions sont des éléments de base qui aident à organiser et à modulariser votre code.

Commençons par créer un nouveau fichier appelé functions_demo.c dans le répertoire ~/project :

cd ~/project
touch functions_demo.c

Maintenant, écrivons une simple déclaration et définition de fonction :

#include <stdio.h>

// Déclaration de fonction (prototype)
void greet(char* name);

// Fonction principale
int main() {
    // Appel de la fonction
    greet("LabEx User");
    return 0;
}

// Définition de la fonction
void greet(char* name) {
    printf("Hello, %s! Welcome to C programming.\n", name);
}

Décortiquons les éléments clés :

void greet(char* name) est la déclaration de fonction (prototype)
La fonction prend un pointeur de caractères (chaîne de caractères) comme argument
void indique que la fonction ne renvoie pas de valeur
À l'intérieur de main(), nous appelons la fonction avec un argument
La définition de la fonction suit la fonction principale et implémente la logique réelle

Compilez et exécutez le programme :

gcc functions_demo.c -o functions_demo
./functions_demo

Exemple de sortie :

Hello, LabEx User! Welcome to C programming.

Les fonctions vous aident à :

Organiser le code en blocs réutilisables
Améliorer la lisibilité du code
Réduire la répétition
Modulariser votre programme

Comprendre les arguments de fonction

Dans cette étape, vous apprendrez à travailler avec les arguments de fonction en programmation C. Les arguments de fonction vous permettent de passer des données dans les fonctions, les rendant plus flexibles et réutilisables.

Créons un nouveau fichier appelé function_arguments.c dans le répertoire ~/project :

cd ~/project
touch function_arguments.c

Maintenant, écrivons un programme démontrant différents types d'arguments de fonction :

#include <stdio.h>

// Fonction avec plusieurs arguments
int calculate_rectangle_area(int length, int width) {
    return length * width;
}

// Fonction avec un argument à virgule flottante
float convert_celsius_to_fahrenheit(float celsius) {
    return (celsius * 9/5) + 32;
}

int main() {
    // Utilisation d'arguments entiers
    int length = 5;
    int width = 3;
    int area = calculate_rectangle_area(length, width);
    printf("Rectangle Area: %d square units\n", area);

    // Utilisation d'un argument à virgule flottante
    float celsius = 25.0;
    float fahrenheit = convert_celsius_to_fahrenheit(celsius);
    printf("%.1f°C is %.1f°F\n", celsius, fahrenheit);

    return 0;
}

Décortiquons les concepts clés :

Les fonctions peuvent prendre plusieurs arguments de différents types
calculate_rectangle_area() prend deux arguments entiers
convert_celsius_to_fahrenheit() prend un argument de type flottant
Les arguments sont passés par valeur en C (une copie est créée)
La fonction peut utiliser ces arguments dans ses calculs

Compilez et exécutez le programme :

gcc function_arguments.c -o function_arguments
./function_arguments

Exemple de sortie :

Rectangle Area: 15 square units
25.0°C is 77.0°F

Points clés concernant les arguments de fonction :

Les arguments fournissent des entrées aux fonctions
Vous pouvez passer des variables ou des valeurs directes
Le nombre et le type d'arguments doivent correspondre à la déclaration de la fonction
Les arguments aident à rendre les fonctions plus polyvalentes et réutilisables

Retourner des valeurs depuis les fonctions

Dans cette étape, vous apprendrez à retourner des valeurs depuis les fonctions en programmation C. Les valeurs de retour permettent aux fonctions de calculer et de renvoyer des résultats au code appelant.

Créons un nouveau fichier appelé function_returns.c dans le répertoire ~/project :

cd ~/project
touch function_returns.c

Maintenant, écrivons un programme démontrant différents types de valeurs de retour :

#include <stdio.h>

// Fonction retournant un entier
int square(int number) {
    return number * number;
}

// Fonction retournant un flottant
float calculate_average(int a, int b, int c) {
    return (float)(a + b + c) / 3;
}

// Fonction retournant un caractère
char get_grade(int score) {
    if (score >= 90) return 'A';
    else if (score >= 80) return 'B';
    else if (score >= 70) return 'C';
    else if (score >= 60) return 'D';
    else return 'F';
}

int main() {
    // Utilisation d'une valeur de retour entière
    int num = 7;
    int squared = square(num);
    printf("Square of %d is %d\n", num, squared);

    // Utilisation d'une valeur de retour flottante
    int math = 85, science = 92, english = 78;
    float average = calculate_average(math, science, english);
    printf("Average score: %.2f\n", average);

    // Utilisation d'une valeur de retour caractère
    int student_score = 85;
    char grade = get_grade(student_score);
    printf("Student score %d gets grade %c\n", student_score, grade);

    return 0;
}

Décortiquons les concepts clés :

Les fonctions peuvent retourner différents types de données
square() retourne un résultat entier
calculate_average() retourne un flottant
get_grade() retourne un caractère
Le mot-clé return envoie une valeur au code appelant
Les types de retour doivent correspondre à la déclaration de la fonction

Compilez et exécutez le programme :

gcc function_returns.c -o function_returns
./function_returns

Exemple de sortie :

Square of 7 is 49
Average score: 85.00
Student score 85 gets grade B

Points clés concernant les valeurs de retour :

Les valeurs de retour permettent aux fonctions de calculer et de renvoyer des résultats
Utilisez des types de retour appropriés en fonction du but de la fonction
Vous pouvez utiliser les valeurs de retour directement ou les stocker dans des variables
Les valeurs de retour rendent les fonctions plus puissantes et flexibles

Gérer les fonctions void

Dans cette étape, vous apprendrez à utiliser les fonctions void en programmation C. Les fonctions void effectuent des actions sans retourner de valeur, ce qui est utile pour les tâches qui n'ont pas besoin de renvoyer un résultat.

Créons un nouveau fichier appelé void_functions.c dans le répertoire ~/project :

cd ~/project
touch void_functions.c

Maintenant, écrivons un programme démontrant les fonctions void :

#include <stdio.h>

// Fonction void pour afficher un message de bienvenue
void print_welcome() {
    printf("Welcome to the C Programming Lab!\n");
}

// Fonction void avec des paramètres pour afficher les informations d'un étudiant
void display_student_info(char* name, int age) {
    printf("Student Name: %s\n", name);
    printf("Student Age: %d\n", age);
}

// Fonction void pour dessiner un motif simple
void draw_pattern(int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("* ");
        }
        printf("\n");
    }
}

int main() {
    // Appel de fonctions void
    print_welcome();

    // Fonction void avec des paramètres
    char* student_name = "LabEx User";
    int student_age = 25;
    display_student_info(student_name, student_age);

    // Fonction void avec un motif
    int pattern_size = 3;
    printf("\nDrawing a %dx%d pattern:\n", pattern_size, pattern_size);
    draw_pattern(pattern_size);

    return 0;
}

Décortiquons les concepts clés :

Les fonctions void ont void comme type de retour
Elles effectuent des actions sans retourner de valeur
print_welcome() affiche simplement un message
display_student_info() prend des paramètres et affiche des informations
draw_pattern() crée un motif visuel en utilisant des boucles imbriquées
Les fonctions void sont appelées comme des fonctions normales
On ne peut pas utiliser return avec une valeur dans les fonctions void

Compilez et exécutez le programme :

gcc void_functions.c -o void_functions
./void_functions

Exemple de sortie :

Welcome to the C Programming Lab!
Student Name: LabEx User
Student Age: 25

Drawing a 3x3 pattern:
* * *
* * *
* * *

Points clés concernant les fonctions void :

Utilisées pour les actions qui n'ont pas besoin de retourner de valeur
Peuvent prendre des paramètres
Utiles pour l'affichage, la journalisation ou l'exécution de tâches spécifiques
Aident à organiser et à modulariser le code
Ne peuvent pas retourner de valeur en utilisant return

Pratiquez l'utilisation des fonctions

Dans cette étape finale, vous allez appliquer tout ce que vous avez appris sur les fonctions en C en créant un programme complet qui démontre différents types de fonctions et leur utilisation.

Créons un fichier appelé calculator.c dans le répertoire ~/project :

cd ~/project
touch calculator.c

Maintenant, écrivons un programme qui implémente une calculatrice simple avec diverses fonctions :

#include <stdio.h>

// Fonction pour additionner deux nombres
int add(int a, int b) {
    return a + b;
}

// Fonction pour soustraire deux nombres
int subtract(int a, int b) {
    return a - b;
}

// Fonction pour multiplier deux nombres
int multiply(int a, int b) {
    return a * b;
}

// Fonction pour diviser deux nombres avec gestion d'erreur
float divide(int a, int b) {
    if (b == 0) {
        printf("Error: Division by zero!\n");
        return 0;
    }
    return (float)a / b;
}

// Fonction void pour afficher le menu de la calculatrice
void display_menu() {
    printf("\n--- Simple Calculator ---\n");
    printf("1. Addition\n");
    printf("2. Subtraction\n");
    printf("3. Multiplication\n");
    printf("4. Division\n");
    printf("5. Exit\n");
    printf("Enter your choice: ");
}

int main() {
    int choice, num1, num2;
    float result;

    while (1) {
        display_menu();
        scanf("%d", &choice);

        // Condition de sortie
        if (choice == 5) {
            printf("Goodbye!\n");
            break;
        }

        // Validation du choix
        if (choice < 1 || choice > 4) {
            printf("Invalid choice. Try again.\n");
            continue;
        }

        // Obtenir les entrées de l'utilisateur
        printf("Enter two numbers: ");
        scanf("%d %d", &num1, &num2);

        // Effectuer le calcul en fonction du choix de l'utilisateur
        switch (choice) {
            case 1:
                result = add(num1, num2);
                printf("Result: %d + %d = %d\n", num1, num2, (int)result);
                break;
            case 2:
                result = subtract(num1, num2);
                printf("Result: %d - %d = %d\n", num1, num2, (int)result);
                break;
            case 3:
                result = multiply(num1, num2);
                printf("Result: %d * %d = %d\n", num1, num2, (int)result);
                break;
            case 4:
                result = divide(num1, num2);
                printf("Result: %d / %d = %.2f\n", num1, num2, result);
                break;
        }
    }

    return 0;
}

Décortiquons les concepts clés :

Différents types de fonctions sont utilisés (valeurs de retour, fonctions void)
Les fonctions effectuent des opérations mathématiques spécifiques
display_menu() est une fonction void qui affiche le menu
Les fonctions arithmétiques retournent les résultats calculés
La fonction main() implémente une calculatrice pilotée par menu
Une gestion d'erreur est incluse pour la division par zéro
Une instruction switch est utilisée pour sélectionner l'opération

Compilez et exécutez le programme :

gcc calculator.c -o calculator
./calculator

Exemple d'interaction :

--- Simple Calculator ---
1. Addition
2. Subtraction
3. Multiplication
4. Division
5. Exit
Enter your choice: 1
Enter two numbers: 10 5
Result: 10 + 5 = 15

--- Simple Calculator ---
...
Enter your choice: 5
Goodbye!

Points clés concernant l'utilisation des fonctions :

Combiner différents types de fonctions
Utiliser les fonctions pour décomposer des problèmes complexes
Implémenter une gestion d'erreur
Créer un code modulaire et réutilisable

Résumé

Dans ce laboratoire, vous avez appris à déclarer et à définir des fonctions en programmation C, à comprendre les arguments de fonction, à retourner des valeurs depuis les fonctions, à gérer les fonctions void et à pratiquer l'utilisation des fonctions. Vous avez commencé par créer une simple fonction pour saluer un utilisateur, puis vous avez exploré des fonctions plus complexes avec plusieurs arguments et des valeurs de retour. Vous avez également appris à utiliser les fonctions void et à pratiquer l'utilisation des fonctions dans vos programmes. Ces concepts fondamentaux sont essentiels pour construire un code modulaire et réutilisable en C.