Quatre modèles éprouvés pour les fonctions définies par l'utilisateur en C

Quatre modèles éprouvés pour les fonctions définies par l'utilisateur en C

Explorez quatre façons distinctes d'implémenter une fonction définie par l'utilisateur qui vérifie si un nombre est premier, et apprenez quelle approche offre la plus grande clarté et réutilisabilité.

Ci-dessous, quatre programmes complets démontrent comment la même tâche logique peut être exprimée avec différentes signatures de fonction. Les quatre sorties sont identiques, pourtant les choix de conception varient, illustrant les compromis clés dans la conception de fonctions.

---

Exemple 1 : Sans arguments, sans valeur de retour

#include <stdio.h>
void verifierNombrePremier();
int main() {
    verifierNombrePremier(); // argument non passé
    return 0;
}
// le type de retour est void signifiant qu'il ne retourne aucune valeur
void verifierNombrePremier() {
    int n, i, flag = 0;
    printf("Entrez un entier positif : ");
    scanf("%d", &n);
    for(i=2; i <= n/2; ++i) {
        if(n%i == 0) {
            flag = 1;
        }
    }
    if (flag == 1)
        printf("%d n'est pas un nombre premier.", n);
    else
        printf("%d est un nombre premier.", n);
}

La fonction verifierNombrePremier() est responsable de la lecture de l'entrée utilisateur, d'effectuer le test de primalité et d'afficher le résultat. Comme son type de retour est void, elle communique le résultat uniquement par effets de bord.

---

Exemple 2 : Sans arguments, mais avec une valeur de retour

#include <stdio.h>
int obtenirEntier();
int main() {
    int n, i, flag = 0;
    // aucun argument n'est passé
    n = obtenirEntier();
    for(i=2; i<=n/2; ++i) {
        if(n%i==0){ flag = 1; break; }
    }
    if (flag == 1)
        printf("%d n'est pas un nombre premier.", n);
    else
        printf("%d est un nombre premier.", n);
    return 0;
}
// retourne l'entier entré par l'utilisateur
int obtenirEntier() {
    int n;
    printf("Entrez un entier positif : ");
    scanf("%d", &n);
    return n;
}

Ici, obtenirEntier() encapsule la routine de saisie et retourne la valeur à main, qui gère ensuite la logique de vérification de primalité. Cette séparation rend l'étape de saisie réutilisable dans différents contextes.

---

Exemple 3 : Argument passé, pas de valeur de retour

#include <stdio.h>
void verifierPremierEtAfficher(int n);
int main() {
    int n;
    printf("Entrez un entier positif : ");
    scanf("%d", &n);
    // n est passé à la fonction
    verifierPremierEtAfficher(n);
    return 0;
}
// le type de retour est void signifiant qu'il ne retourne aucune valeur
void verifierPremierEtAfficher(int n) {
    int i, flag = 0;
    for(i=2; i <= n/2; ++i) {
        if(n%i == 0){ flag = 1; break; }
    }
    if(flag == 1)
        printf("%d n'est pas un nombre premier.", n);
    else
        printf("%d est un nombre premier.", n);
}

Dans ce modèle, la responsabilité d'afficher le résultat est déplacée dans la fonction d'aide. Bien que cela garde main maigre, la fonction couple maintenant l'algorithme avec l'E/S, réduisant sa réutilisabilité.

---

Exemple 4 : Argument passé et une valeur de retour

#include <stdio.h>
int verifierNombrePremier(int n);
int main() {
    int n, flag;
    printf("Entrez un entier positif : ");
    scanf("%d", &n);
    // n est passé à la fonction verifierNombrePremier()
    // la valeur retournée est assignée à la variable flag
    flag = verifierNombrePremier(n);
    if(flag == 1)
        printf("%d n'est pas un nombre premier", n);
    else
        printf("%d est un nombre premier", n);
    return 0;
}
// int est retourné depuis la fonction
int verifierNombrePremier(int n) {
    int i;
    for(i=2; i <= n/2; ++i) {
        if(n%i == 0) return 1;
    }
    return 0;
}

Ce design garde l'algorithme isolé et retourne un simple drapeau de statut. Le caller décide comment présenter le résultat, ce qui rend la fonction hautement réutilisable dans les bibliothèques ou applications plus larges.

---

Choisir le modèle optimal

Bien que les quatre implémentations produisent la même sortie, l'approche la plus maintenable et testable est l'Exemple 4 : passer le nombre comme argument et retourner un drapeau de style booléen. Ce modèle adhère au principe de responsabilité unique, permet les tests unitaires de verifierNombrePremier sans dépendances E/S, et peut être facilement intégré dans des systèmes plus complexes.

En fin de compte, le choix dépend de l'architecture de votre projet. Si la fonction doit interagir directement avec l'utilisateur, l'Exemple 3 pourrait suffire. Pour le code de bibliothèque ou les services où l'E/S est gérée ailleurs, l'Exemple 4 offre la plus grande flexibilité.