Introduction aux fonctions C

Une introduction aux fonctions C

Les fonctions sont la façon dont nous pouvons structurer notre code en sous-programmes que nous pouvons:

  1. donner un nom à
  2. appelle quand on en a besoin

À partir de votre tout premier programme, un «Hello, World!», Vous utilisez immédiatementCles fonctions:

#include <stdio.h>

int main(void) {
	printf("Hello, World!");
}

Lemain()La fonction est une fonction très importante, car c'est le point d'entrée d'un programme C.

Voici une autre fonction:

void doSomething(int value) {
	printf("%u", value);
}

Les fonctions ont 4 aspects importants:

  1. ils ont un nom, nous pouvons donc les appeler (les «appeler») plus tard
  2. ils spécifient une valeur de retour
  3. ils peuvent avoir des arguments
  4. ils ont un corps, enveloppé dans des bretelles bouclées

Le corps de la fonction est l'ensemble des instructions qui sont exécutées chaque fois que nous invoquons une fonction.

Si la fonction n'a pas de valeur de retour, vous pouvez utiliser le mot-clévoidavant le nom de la fonction. Sinon, vous spécifiez le type de valeur de retour de la fonction (intpour un entier,floatpour une valeur à virgule flottante,const char *pour une chaîne, etc.).

Vous ne pouvez pas renvoyer plus d'une valeur à partir d'une fonction.

Une fonction peut avoir des arguments. Ils sont facultatifs. S'il ne les a pas, à l'intérieur des parenthèses nous inséronsvoid, comme ça:

void doSomething(void) {
   /* ... */
}

Dans ce cas, lorsque nous invoquons la fonction, nous l'appellerons sans rien entre parenthèses:

doSomething();

Si nous avons un paramètre, nous spécifions le type et le nom du paramètre, comme ceci:

void doSomething(int value) {
   /* ... */
}

Lorsque nous invoquons la fonction, nous passerons ce paramètre entre parenthèses, comme ceci:

doSomething(3);

Nous pouvons avoir plusieurs paramètres, et si c'est le cas, nous les séparons par une virgule, à la fois dans la déclaration et dans l'invocation:

void doSomething(int value1, int value2) {
   /* ... */
}

doSomething(3, 4);

Les paramètres sont passés parcopie. Cela signifie que si vous modifiezvalue1, sa valeur est modifiée localement et la valeur en dehors de la fonction, là où elle a été passée lors de l'appel, ne change pas.

Si vous passez unaiguilleen tant que paramètre, vous pouvez modifier cette valeur de variable car vous pouvez désormais y accéder directement en utilisant son adresse mémoire.

Vous ne pouvez pas définir une valeur par défaut pour un paramètre. C ++ peut le faire (et donc les programmes de langage Arduino), mais C ne peut pas.

Assurez-vous de définir la fonction avant de l'appeler, sinon le compilateur lèvera un avertissement et une erreur:

➜  ~ gcc hello.c -o hello; ./hello
hello.c:13:3: warning: implicit declaration of
      function 'doSomething' is invalid in C99
      [-Wimplicit-function-declaration]
  doSomething(3, 4);
  ^
hello.c:17:6: error: conflicting types for
      'doSomething'
void doSomething(int value1, char value2) {
     ^
hello.c:13:3: note: previous implicit declaration
      is here
  doSomething(3, 4);
  ^
1 warning and 1 error generated.

The warning you get regards the ordering, which I already mentioned.

The error is about another thing, related. Since C does not “see” the function declaration before the invocation, it must make assumptions. And it assumes the function to return int. The function however returns void, hence the error.

If you change the function definition to:

int doSomething(int value1, int value2) {
  printf("%d %d\n", value1, value2);
  return 1;
}

you’d just get the warning, and not the error:

➜  ~ gcc hello.c -o hello; ./hello
hello.c:14:3: warning: implicit declaration of
      function 'doSomething' is invalid in C99
      [-Wimplicit-function-declaration]
  doSomething(3, 4);
  ^
1 warning generated.

In any case, make sure you declare the function before using it. Either move the function up, or add the function prototype in a header file.

Inside a function, you can declare variables.

void doSomething(int value) {
  int doubleValue = value * 2;
}

A variable is created at the point of invocation of the function, and is destroyed when the function ends, and it’s not visible from the outside.

Inside a function, you can call the function itself. This is called recursion and it’s something that offers peculiar opportunities.

Download my free C Handbook


More clang tutorials: