Concepts avancés du langage C

Un pointeur rappelons-le est une variable destinée à contenir une adresse. Une adresse référence un objet en mémoire. Une fonction (pendant l'exécution) est tout simplement une suite d'instructions en mémoire. On peut donc pointer sur une fonction tout comme on peut pointer sur n'importe quelle variable.

Une fonction possède un type. Par exemple, considérons les fonctions f et g suivantes :

int f()
{
    printf("Fonction : f.\n");
    return 0;
}

int g()
{
    printf("Fonction : g.\n");
    printf("-------------\n");
    return 0;
}

Ces fonctions ont le même type et leur type est fonction retournant un int et ne prenant aucun argument.

Mais attention ! La taille occupée en mémoire par une fonction ne peut pas se déduire de son type. Par exemple, f occupe moins de place que g, cela est plus qu'évident. En conséquence : on ne peut pas affecter une « fonction » à une variable. Cependant, rien ne nous empêche de pointer sur une fonction. En se basant toujours sur l'exemple précédent, on peut déclarer le type de f et g comme suit :

typedef int F(void);

Et on peut donc déclarer un pointeur sur F de la manière suivante :

F * p;

Ensuite, il suffit de savoir que lorsqu'elle n'est pas utilisée en unique argument de sizeof ou de l'opérateur & (« adresse de »), une expression de type fonction est toujours convertie par le compilateur en l'adresse de cette fonction. Cela signifie que les expressions :

&f     f    *f   **f  ***f   ...

sont toutes équivalentes. Elles valent toutes &f.

Donc une fois p correctement initialisée, il y a plus d'une manière d'appeler la fonction pointée :

p()   (p)()  (*p)()   ...

Au niveau global, un programme C est constitué d'une ou plusieurs fonctions, chacune ayant éventuellement une tâche bien précise. Quel que soit le nombre de fonctions constituant le programme, une doit être désignée comme étant le point d'entrée du programme, c'est-à-dire celle qui sera automatiquement appelée par l'environnement d'exécution lorsqu'on exécute le programme. Cette fonction est bien entendu dépendante de la plateforme. Par exemple sous Windows le nom de cette fonction est main pour une application console, WinMain pour une application fenêtrée, NtProcessStartup pour un driver, etc.

Cependant, pour permettre aux programmeurs d'écrire des applications totalement portables, le comité chargé de normalisation du langage C a désigné une fonction appelée main (héritée d'UNIX) comme point d'entrée d'un programme C standard. C'est ensuite au compilateur et au linkeur de faire en sorte que le programme puisse être exécutable sur la plateforme cible.

main est une fonction qui doit retourner un int. Les deux prototypes possibles pour cette fonction sont :

>> int main(void)
>> int main(int argc, char * argv[])

Ces arguments (argc et argv), lorsqu'ils sont utilisés, seront évidemment initialisés par l'environnement d'exécution (sinon par qui alors ?). Il est donc clair que les valeurs placées dans ces variables sont dépendantes de l'environnement. Néanmoins :

argv[0] n'est jamais NULL et pointe sur une chaîne qui représente le nom du programme. Si argc est supérieur à 1, argv[1] à argv[argc-1] représentent les paramètres du programme. Dans tous les cas, argv[argc] vaut toujours NULL. Dans la plupart des implémentations, les « paramètres du programme » sont les arguments de la ligne de commande. Par exemple sous Windows, en exécutant le programme prog.exe avec la ligne de commande :

prog abc xy

On aura :

• argc = 3
• argv[0] = « prog »
• argv[1] = « abc »
• argv[2] = « xy »
• argv[3] = NULL

La fonction exit▲

void exit(int status);

La fonction system▲

int system(char const * string);

La fonction sprintf▲

int sprintf(char * buffer, const char * format, ...);

Un algorithme récursif est un algorithme dont la définition fait référence à lui-même. Par exemple, étudions l'algorithme qui permet de calculer la puissance d'un nombre c'est-à-dire an. Nous-nous limiterons au cas où a est de type réel et n de type entier relatif. Voici l'algorithme :

Algorithme « calcul de a p (n) »

/* Cet algorithme donne une définition de a p (n) (a puissance n) */

Debut
    Si n > 0
        a p (n) = a * (a p (n - 1))
    Sinon
        Si n < 0
            a p (n) = (1/a) p (-n)
        Sinon
            /* n == 0 */
            a p (n) = 1
        FinSi
    FinSi
Fin

Et voici un exemple d'implémentation en langage C :

double a_puissance_n(double a, int n)
{
    if (n > 0)
        return a * a_puissance_n(a, n - 1);
    else
        if (n < 0)
            return a_puissance_n(1/a, -n);
        else
            return 1.0;
}

Ainsi, en calculant a_puissance_n(1.5, 3) par exemple, on obtiendra successivement

• 1.5 * a_puissance_n(1.5, 2)
• 1.5 * 1.5 * a_puissance_n(1.5, 1)
• 1.5 * 1.5 * 1.5 * a_puissance_n(1.5, 0)
• 1.5 * 1.5 * 1.5 * 1.0

Nous pouvons bien constater que les appels de fonction récursive s'empilent. Une fonction reste toujours « en vie » tant que la suivante n'a pas retourné, car elle doit justement attendre la valeur de retour de cette dernière avant de pouvoir à son tour retourner la sienne. Donc, derrière leur simplicité enfantine, les fonctions récursives consomment généralement énormément de mémoire. Heureusement, il n'y a pas d'algorithme récursif qu'on ne puisse écrire sous forme d'itération…