Les fonctions peuvent-elles être imbriquées dans la définition mais pas dans les appels imbriqués ?

Faux, les fonctions peuvent être des appels imbriqués mais ne peuvent pas être définies imbriquées. En langage C, toutes les fonctions sont parallèles, c'est-à-dire qu'elles sont indépendantes les unes des autres lors de la définition des fonctions. Une fonction n'est pas subordonnée à une autre fonction, c'est-à-dire que les fonctions ne peuvent pas être imbriquées dans la définition, mais elles peuvent s'appeler les unes les autres. ne peut pas appeler la fonction principale.

L'environnement d'exploitation de ce tutoriel : système Windows 7, version C99, ordinateur Dell G3.

Faux, les fonctions peuvent être des appels imbriqués mais ne peuvent pas être définies imbriquées.

Fonction en langage C

Une fonction est un morceau de code qui peut être réutilisé pour remplir une certaine fonction de manière indépendante. transmis ou non par l'utilisateur. Les fonctions qui reçoivent des données utilisateur doivent spécifier des paramètres lors de leur définition. Les fonctions qui ne reçoivent pas de données utilisateur n'ont pas besoin d'être spécifiées. Sur cette base, les fonctions peuvent être divisées en fonctions paramétrées et fonctions sans paramètres.

Le processus d'encapsulation d'un segment de code dans une fonction est appelé définition de fonction.

Définition de la fonction

Si la fonction ne reçoit pas de données transmises par l'utilisateur, elle peut être définie sans paramètres. Comme indiqué ci-dessous :

dataType  functionName(){
    //body
}

Si la fonction doit recevoir des données transmises par l'utilisateur, elle doit alors être définie avec des paramètres. Comme indiqué ci-dessous :

dataType  functionName( dataType1 param1, dataType2 param2 ... ){
    //body
}

• dataType est le type de valeur de retour, qui peut être n'importe quel type de données en langage C, tel que int, float, char, etc.

• functionName est le nom de la fonction, qui est un type d'identifiant. Les règles de dénomination sont les mêmes que celles des identifiants. Les parenthèses ( ) après le nom de la fonction ne peuvent pas manquer.

• dataType1 param1, dataType2 param2 ... est la liste des paramètres. Une fonction ne peut avoir qu'un seul paramètre ou plusieurs paramètres, séparés par . Les paramètres sont essentiellement des variables, et leur type et leur nom doivent être spécifiés lors de leur définition. Par rapport à la définition d'une fonction sans paramètre, la définition d'une fonction paramétrée n'a qu'une seule liste de paramètres supplémentaire.

• body est le corps de la fonction, qui est le code que la fonction doit exécuter et constitue la partie principale de la fonction. Même s'il n'y a qu'une seule instruction, le corps de la fonction doit être entouré de { }.

• S'il existe une valeur de retour, utilisez l'instruction return dans le corps de la fonction pour la renvoyer. Le type de données renvoyées doit être le même que dataType.

  return est un mot-clé en langage C, qui ne peut être utilisé que dans les fonctions pour renvoyer les résultats du traitement.
  

Exemple :

#include <stdio.h>
int sum(){
    int i, sum=0;
    for(i=1; i<=100; i++){
        sum+=i;
    }
    return sum;
}
int main(){
    int a = sum();
    printf("The sum is %d\n", a);
    return 0;
}

Résultat d'exécution :

The sum is 5050

La fonction ne peut pas être une définition imbriquée, main est également un définition de la fonction, donc la somme doit être placée en dehors de main. Les fonctions doivent d'abord être définies puis utilisées, donc sum doit être placé avant main.

Remarque : main est une définition de fonction, pas un appel de fonction. Lorsque le fichier exécutable est chargé dans la mémoire, le système démarre l'exécution à partir de la fonction principale, c'est-à-dire que le système appellera la fonction principale que nous avons définie.

Recommandation du didacticiel : "Vidéo du didacticiel sur le langage C"

Appel de fonction

Le soi-disant appel de fonction ), c'est-à-dire en utilisant une fonction déjà définie. La forme générale de l'appel de fonction est :

functionName(param1, param2, param3 ...);

functionName est le nom de la fonction, param1, param2, param3... est la liste de paramètres réelle. Les paramètres réels peuvent être des constantes, des variables, des expressions, etc. Plusieurs paramètres réels sont séparés par des virgules.

En langage C, il existe de nombreuses façons d'appeler des fonctions, par exemple :

//函数作为表达式中的一项出现在表达式中
z = max(x, y);
m = n + max(x, y);
//函数作为一个单独的语句
printf("%d", a);
scanf("%d", &b);
//函数作为调用另一个函数时的实参
printf( "%d", max(x, y) );
total( max(x, y), min(m, n) );

Appel imbriqué de fonctions

Les fonctions ne peuvent pas être des définitions imbriquées, mais les appels peuvent être imbriqués, c'est-à-dire que les appels à une autre fonction sont autorisés lors de la définition ou de l'appel d'une fonction.

[Exemple] Calculez la somme = 1 ! + 2 ! + 3 ! + ... + (n-1) + n !

Analyse : Vous pouvez écrire deux fonctions, une avec pour calculer la factorielle et un pour calculer la somme cumulée.

#include <stdio.h>
//求阶乘
long factorial(int n){
    int i;
    long result=1;
    for(i=1; i<=n; i++){
        result *= i;
    }
    return result;
}
// 求累加的和
long sum(long n){
    int i;
    long result = 0;
    for(i=1; i<=n; i++){
        //在定义过程中出现嵌套调用
        result += factorial(i);
    }
    return result;
}
int main(){
    printf("1!+2!+...+9!+10! = %ld\n", sum(10));  //在调用过程中出现嵌套调用
    return 0;
}

Résultats d'exploitation :

1!+2!+...+9!+10! = 4037913

L'appel à factorial() apparaît dans la définition de sum(), l'appel à sum() apparaît dans le processus d'appel de printf(), et printf () est également appelé par main(), et leur relation d'appel globale est :

main() --> printf() --> sum() --> factorial()

Si une fonction A() appelle une autre fonction B() pendant la définition ou le processus d'appel, alors nous l'appelons A() est la fonction appelante ou la fonction principale, et B() est appelée la fonction appelée.

Lorsque la fonction appelante rencontre la fonction appelée, la fonction appelante se mettra en pause et le CPU exécutera le code de la fonction appelée une fois l'exécution de la fonction appelée terminée, il reviendra à la fonction appelante et le la fonction appelante Le statut continue de s'exécuter.

Le processus d'exécution d'un programme en langage C peut être considéré comme le processus d'appel mutuel entre plusieurs fonctions, qui forment une chaîne d'appel simple ou complexe. Le point de départ de cette chaîne est main() et le point final est également main(). Lorsque main() aura fini d'appeler toutes les fonctions, il renverra une valeur (telle que return 0;) pour mettre fin à sa propre vie, mettant ainsi fin au programme entier.

Une fonction est un bloc de code réutilisable. Le CPU exécutera les codes un par un Lorsqu'il rencontre un appel de fonction, le CPU doit d'abord enregistrer l'adresse du code suivant dans le bloc de code actuel (en supposant que l'adresse est 0X1000). , puis passez à un autre bloc de code, puis revenez pour continuer l'exécution du code à 0X1000 une fois l'exécution terminée. L'ensemble du processus équivaut à ce que le processeur fasse une pause, abandonne temporairement le travail en cours pour faire autre chose, puis continue le travail précédent après l'avoir terminé.

Pour plus de connaissances sur la programmation informatique, veuillez visiter : Vidéo de programmation ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!