INFO916 : Cours de C

Introduction

Qu'est ce qu'un langage de programmation :

Ce sont des intruction indiquant à un ordinateur ce qu'il doit faire.

Un langage est caractérisé par trois éléments :

• syntaxe : quel sont les programmes valides
• sémantique : que font faire ces programmes à la machine
• des usages et conventions : des pratiques usuelles pour mieux programmer

Ce cours portera sur les trois aspects, notemment, on devra être capable d'évaluer un programme C à la main.

Historique et classification des languages

C est un

• langage impératif et procédural
• "assembleur" portable

Modèle mémoire et type de données

Modèle mémoire

Afin de pouvoir donner la sémantique du langage, il nous faut un "modèle" simplifié de machine. Essentiellement, un programme C agit sur deux choses:

• La mémoire
• Les entrées/sorties (fichier)

On s'intéressera aux entrées/sorties en fin de cours.

La mémoire est en fait un tableau (= vecteur) d'octets (byte en anglais). Un octet est un entier sur 8 bits (bits aussi en anglais) donc compris entre 0 et 255 = 2⁸ - 1. Donc mathématiquement un élément de {0;1;2;...;255}^N où N dépend de l'architecture de la machine (N = 2³⁰, N = 2³¹ ou N = 2³² sur une machine 32 bits et N = 2⁴⁸ ou plus sur une machine 64 bits).

Attention: N ne dépend pas de la quantité de mémoire installée dans la machine !

Puisque la pile est un tableau, on peut parler de son i-ème élément x. L'index d'un élément dans la mémoire s'appelle l'adresse de cet élément.

Seul une partie de la mémoire est accessible en lecture écriture pour le programme C (on peut aussi avoir des zones mémoire accessible en lecture seule). Lorsqe l'on essaye d'accéder au contenu d'une adresse qui n'est pas accessible le programme s'arrête brusquement sur une erreur de type bus error ou segmentation fault (si l'adresse existe dans la mémoire mais que l'on est pas autorisé à y accéder) De plus, la mémoire accessible est divisée en deux zones:

• La pile
• Le tas

La différence principale est que la pile est une zone continue (connexe) de la mémoire tandis que le tas est fragmenté. L'utilisation de ces deux zones en C est aussi très différente. La pile sera examiné dans ce chapitre tandis que le tas fait l'objet d'un chapitre à lui seul.

Types de base

On n'utilise pas la mémoire octet par octet. Les données que l'on place dans la mémoire ou un type (on parle de type de donnée). Un type possède trois caractéristiques essentielles:

1. Son nom que l'on utilisera dans les programmes C.
2. Sa taille, c'est à dire le nombre d'octets nécessire pour stocker un objet de ce type dans la mémoire. Une caractéristique étonnante du C est que tous les types ont une taille fixe ... et pourtant ceci ne nous empêchera pas de manipuler des objets de taille variable tels que les tableaux ou les chaînes de caractères. Si type est un type C, alors on peux utiliser sizeof(type) pour obtenir la taille du type.
3. Son sens : cet aspect est totalement ignoré par le compilateur C, mais il facilite la lecture des programmes. Si on ne mettait pas un sens.

derrière les noms des types, on utiliserait directement leur taille comme nom, car c'est la seule chose qui compte en C.

Remarque: on vient pour la première fois d'utiliser une convention d'écriture pour le code C qui prévaudra dans tout le cours. On écrira me code C en utilisant une police style machine à écrire (pour le mot sizeof si dessus et les parenthèses. Toutefois, type n'est pas du C, mais une meta-variable qui devra être remplacée par du C valide (ici le nom d'un type). Par exemple: sizeof(int) est du C valide.

Voici les types de base du C:

void

(taille 0/1) : par exemple type de retour des procédures. Nous reviendrons plus tard sur les usages très particulier de ce type.

char

(taille 1): un caractère ASCII ou parfois un très petit entier relatif

short int

(taille ?) : un entier relatif de petite taille

int

(taille ?) : un entier relatif de taille moyenne

long int

(taille ?) : un entier relatif de grande taille

long long int

(taille ?) : un entier relatif de très grande taille

unsigned char

(taille 1): un caractère ASCII ou parfois un très petit entier naturel

short unsigned int

(taille ?) : un entier naturel de petite taille

unsigned int

(taille ?) : un entier naturel de taille moyenne

long unsigned int

(taille ?) : un entier naturel de grande taille

long long unsigned int

(taille ?) : un entier naturel de très grande taille

float

(taille 4) : un nombre floattant 32 bits

double

(taille 8) : un nombre floattant 64 bits

long double

(taille ?) : un nombre floattant 64 bits ou plus (taille 16, mais seulement 86 bits de précision en réalité sur intel)

Voici donc notre premier programme C qui affiche la taille des types ci-dessus (il faudra aller un peu plus loin dans le cours pour comprendre réellement ce programme) : <source lang="c">

1. include<stdio.h>

main(int argc, char **argv) {

 printf("void: %d\n", sizeof(void));
 printf("void*: %d\n", sizeof(void*));
 printf("char: %d\n", sizeof(char));
 printf("short int: %d\n", sizeof(short int));
 printf("int: %d\n", sizeof(int));
 printf("long int: %d\n", sizeof(long int));
 printf("long long int: %d\n", sizeof(long long int));
 printf("unsigned char: %d\n", sizeof(unsigned char));
 printf("short unsigned int: %d\n", sizeof(short unsigned int));
 printf("unsigned int: %d\n", sizeof(unsigned int));
 printf("long unsigned int: %d\n", sizeof(long unsigned int));
 printf("long long unsigned int: %d\n", sizeof(long long  unsigned int));
 printf("float: %d\n", sizeof(float));
 printf("double: %d\n", sizeof(double));
 printf("long double: %d\n", sizeof(long double));

} </source>

Exercice: compilez le programme précédent, exécutez le et analysez le résultat.

Allocation dans la pile

On utilise la pile en déclarant des variables avec la syntaxe suivante:

type ident[,ident]*;

Ici on utilise la convention précédente: type doit être remplacé par un type et ident par un nom de variable. Les crochets indiquent qu'il est possible de mettre un second identificateur et l'asterisque indique que l'on peut en fait en mettre autant que l'on veut.

L'effet d'une déclaration de variables est de déplacer le sommet de la pile du nombre d'octets nécessaire pour stocker les objets dont les types sont donnés. Le sommet de la pile est donc déplacé d'un nombre d'octets égal à $n$ sizeof(type) si on alloue $n$ variables de type type.

Exercice: décrire l'état de la pile lorsque l'on execute les instructions suivantes: <source lang="c"> int x,y; char c; x = 5; int z; y=2; z=x+y; </source>

Important : on peut donner la valeur d'une variable en même temps que la déclare en utilisant la syntaxe suivante:

type ident[=expr][,ident[=expr]]*;

Dans la ligne précédente: [=expr] indique que le nom du type peut être suivi d'une expression donnant la valeur initiale de la variable.

Important : il faut initialiser les variables lors de la déclaration ou tout de suite après. Il est dommage que C n'impose pas cette contrainte, car les variables non initialisées sont la source de nombreux bugs.