[C] extern // static

[ark]

Yop,

la question sur l'utilisation du mot cle extern s'etant pose sur IRC, je vais donc faire un petit post par rapport a l'utilisatiion des mots cles suivants: extern et static.

1. extern

Ce mot cle est utile pour acceder a une variable presente dans un autre objet. En voici un exemple:
Nous avons deux fichier,
le premier, contenant la fonction main(), ou la variable int bar est declaree en globale.

Code C :

#include <stdio.h>

/* Prototype de la fonction dans l'autre fichier */
void foo(void);

/* ma variable partagee. */
int bar = 0;

int main(void) {
  foo();
  printf("bar = %d\n", bar);
  return 0;
}

Le second, ou l'on recupere la variable, pour effectuer un traitement dans la fonction foo()

Code C :

/* cette variable a deja ete declare,
   on ne fait que recuperer son adresse */
extern int bar;

void foo(void) {
  bar += 1;
}

Et comme prevu, la sortie de ce programme sera:

tmp $> ./a.out
bar = 1

On rappellera tout de meme que les variable globale, c'est mal, et si vous pouvez vous en passer, faites le, merci. :)



2. static

Celui-ci a deux utilisations differente en fonction de si vous l'utiliser a l'interieur ou a l'exterieur du scope d'une fonction.

A l'interieur du scope d'une fonction, il permet de faire en sortes que la valeur de la variable soit conserve entre chaque appel de la fonction.

Exemple:

Code C :

#include <stdio.h>

void foo(void) {
  static int bar = 0;

  ++bar;
  printf("bar = %d\n", bar);
}

int main(void) {
  foo();
  foo();
  foo();
  return 0;
}

Ici, bar est initialisee a 0. (C'est fait de maniere explicite, mais on est pas oblige de le mettre puisque toutes les variables declarees globale ou static seront automatiquement init a 0 si vous ne precisez rien. Mais dans un soucis de lisibilite, je prefere le faire)
A chaque appel de la fonction foo, sa valeur sera incremente de 1. L'output de ce code donne donc:

tmp $> ./a.out
bar = 1
bar = 2
bar = 3

Le deuxieme cas d'utilisation de ce mot cle, lorsqu'il est utilise en dehors du scope d'une fonction, permet de restreindre la fonction ou la variable sur laquelle vous l'appliquez a l'objet courant.
Pour faire simple, si vous declarez une fonction en static, vous y aurez acces uniquement dans ce fichier.

Et pour l'exemple, deux fichiers ici aussi:

bar.c, qui contient le main, et qui appelle une fonction foo

Code C :

int main(void) {
  foo();
  return 0;
}

et foo.c, qui contient la fonction foo, declare en static.

Code C :

#include <stdio.h>

static void foo(void) {
  puts("coucou");
}

Le resultat, c'est qu'on ne pourra pas compiler tout ca:

tmp $> gcc bar.c foo.c
/tmp/ccjd6zly.o: In function `main':
bar.c:(.text+0xa): undefined reference to `foo'
collect2: error: ld returned 1 exit status

voila voila, c'etait pas grands chose, mais j'espere que ca aura appris des choses a certains.