[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.

[airday]

Ce qui est interressant dans ces variables c'est que la variable globale a une adresse memoire plus importante par rapport a celle de la variable statique (son adresse ne change pas et est faible)

[ark]

Ce qui est interressant dans ces variables c'est que la variable globale a une adresse memoire plus importante par rapport a celle de la variable statique (son adresse ne change pas et est faible)

wtf?

[airday]

@ark, Je viens de le faire et constate par toi meme.

Code :

global = 5, adresse = 0x7fff56575b68
bar = 1, adresse = 0x10968b018
bar = 2, adresse = 0x10968b018
bar = 3, adresse = 0x10968b018

Apres surment je me suis mal exprime.

[supersnail]

EDIT: faut faire la différence entre adresse de pile (là où vivent les variables locales) et section de données, où sont stockées généralement les variables globales (qui résident dans le binaire que tu compiles, et mappées par l'OS).

[b0fh]

C'est en effet bien mieux d'avoir des addresses courtes; en effet, pendant un accès mémoire, le contrôleur du bus mémoire doit vérifier le ticket de la requête mémoire, et il mettra forcément moins de temps à lire une addresse courte.

Le mieux étant d'utiliser des addresses d'un byte, qui seront les plus rapides à lire. Malheureusement, le compilo ne permet pas de s'en servir par défaut, a cause du DMA qui n'est pas activé par défaut, donc pour obtenir une variable super-rapide il faut caster un pointeur à la main, par exemple:

int *case_1 = (int *)(1);
int *case_2 = (int *)(2);

et ensuite s'en servir comme des pointeurs normaux:

*case1 = *case2

Note que dans de très rares cas (par exemple si le noyau a été infecté par la backdoor Dual_EC_DRBD de la NSA) ce type de code peut provoquer des segfaults, justement parce que la backdoor réserve ces accès mémoire ultrarapides à son propre usage.