Cours C pour les systèmes embarqué

M.RAHMOUNE

Partie I : Rappel du langage C

Partie II: Manipulation de la mémoire : les opérations binaire,

Partie III: Programmation pour les systèmes embarqués

Ecole Nationale des Sciences Appliquées d ’Oujda

Historique

Langage C, est un langage structurée, développé en 1970

par Dennie Ritchie aux Laboratoires Bell d'AT&T, il est
l'aboutissement de deux langages :
• BPCL développé en 1967 par Martin Richards.
• B développé en 1970 chez AT&T par Ken Thompson.

ANSI/ISO

1988

(et 1999)
Le C est Le langage de développement le plus répandu dans les
entreprise (et ailleurs).
 Bibliographie

[Brian W. Kernighan Dennis M. Ritchie] Le livre du C Norme ANSI

[Claude Delannoy] Le livre du C premier langage

[Claude Delannoy] Programmer en langage C

…...
 La gestion de la mémoire

Logique de
(28) 256 états

Logique de 2 états
insuffisante 1
0

logique binaire
 La gestion de la mémoire
La mémoire d’un ordinateur
• La mémoire comporte trois zone d allocation
• Chaque zone sert a mémoriser trois types de variables

exécutable
Code
Cache Registres
(cmos) Unité
RAM Logique
(silicium)
Zone statique
Dynamique
(Stack/pile)
Mémoire

Mémoire
virtuelle Zone d ’allocation
(disque) mémoire
(Heap, tas)
Mémoire
Statique
 La gestion de la mémoire

Tout objet manipulé par l'ordinateur est stocké dans sa mémoire.

On peut considérer que cette mémoire est constituée d'une série de « cases ». Des
cases dans lesquelles sont stockées les valeurs des variables ou les instructions du
programme. Pour pouvoir accéder à un objet (la valeur d'une variable ou les
instructions à exécuter par exemple), c'est-à-dire au contenu de la case mémoire
dans laquelle cet objet est enregistré, il faut connaître le numéro de cette case.
Autrement dit, il faut connaître l'emplacement en mémoire de l'objet à manipuler.
Cet emplacement est appelé l'adresse de la case mémoire, et par extension, l'adresse
de la variable ou l'adresse de la fonction stockée dans cette case et celles qui la
suivent
Toute case mémoire a une adresse unique. Lorsqu'on utilise une variable ou une
fonction, le compilateur manipule l'adresse de cette dernière pour y accéder. C'est
lui qui connaît cette adresse, le programmeur n'a pas à s'en soucier.
Une adresse est une valeur. Cette valeur est constante, car en général un objet ne se
déplace pas en mémoire
 La gestion de la mémoire

0101011110111 Pour que la conversion des caractères en codes binaire

soit universel. Des normes standard sont été établis:

ASCII (American Standard Code for Information Interchange)

Ici un fichier ascii
ici l’écran codes ASCII standards

codes ASCII étendus

Segment N+2

Segment N+1
Sans segmentation
Segment N +
Offset de l ’objet
en mémoire Un adressage sur 64 bits
Segment N-1
= 64 Ko (65.536 octets
 Généralité Sur Les Flux (Ou Flots)

• La lecture et l’écriture dans un fichier sont des opérations d’entrée / sortie.

– Utilisation de la bibliothèque iostream (déjà utilisée pour les E/S
écran/clavier)
écran/clavier

L’écran a les dimensions 24 lignes × 80 caractères en général

 Le langage C

Le C est un langage structuré, typé et modulaire, extensible

• Langage polyvalent permettant le développement de systèmes

d'exploitation, de programmes applicatifs scientifiques et de
gestion.
• Langage structuré.
• Langage évolué qui permet néanmoins d'effectuer des
opérations de bas niveau (< assembleur d'Unix >).
• Portabilité (en respectant la norme ANSI !) due a l'emploi de
bibliothèques dans lesquelles sont reléguées les
fonctionnalités liées à la machine.
• Grande efficacité et puissance
 Plan sommaire du cours C

C est un langage compilé … normalisation tardive (97/98...)

Protocole de communication entre le programmeur et le processeur.

Code C

Librairies
Code préprocesseurs

Fichier(s)) Objet
Fichier(s
Programme

L’extension d’un fichier est .c ou un .h pour un fichier d’entête

 Les Fichiers Texte En C

Une suite de données

Stockées en mémoire secondaire (disque dur, CD, Diquette…).
– Sous forme d’octet (comme en mémoire centrale).
– A quoi ça sert:
• Les données en mémoire centrale durent uniquement le temps de
programme => Mais un fichier est persistant.
• Beaucoup plus de place en mémoire secondaire (disque dur…).
• Mais! L’accès à la mémoire secondaire est beaucoup plus long
9 x 10-3 sec par rapport 9*10 -9 sec pour l’accès à la mémoire.
 Les Fichiers Hello C Word

# include <stdio.h> Directive du processeur

inclure fichier .h
#define PI 3.14159
/* fichier hello */ commentaire C
main() Une seule fonction main par
programme C

{
printf(« hello to C word "); Une instruction se termine par ;
return 0; Bloc / Programme principale
}
 Structure d’un programme C
• Programme C :
une ou plusieurs fonctions dont au moins une fonction main stockées
dans un ou plusieurs fichiers.
• Fonction :
• type et nom de la fonction suivis d'une liste d'arguments entre
parenthèses,
• instruction composée constituant le corps de la fonction.
• Instruction composée : délimitée par les caractères { et }
• Instruction simple : se termine par ;
• commentaire : encadre par les délimiteurs /*et */
• Instruction préprocesseur : commence par #
Les sources d'une application écrite en langage C peut être stocke dans un ou plusieurs
fichiers dont le suffixe ou l’extension .c
La compilation de ces sources s'effectue a l'aide de la commande cc. Sans autre
spéciation, cette commande enchaîne 3 étapes :
• appel au préprocesseur
• appel au compilateur,
• appel a l'éditeur de liens.
 Généralité: Jeu de caractère utilisé en c

• 26 lettres de l'alphabet (minuscules, majuscules) et les chiffres de 0 à 9

• caractères spéciaux :
! * + \ " <

# ( = | } >

% ) ~ ; ] /

^ - [ : , ?

& _ { ' . (espace)

• séquences d'échappement telles :

• passage a la ligne (\n),

• tabulation (\t),
• backspace (\b).
 Identificateur et mots-
mots-clés
• Identificateur :
nom donné aux diverses composantes d'un programme; variables, tableaux,
fonctions.
 Forme de lettres et de chiffres ainsi que du caractère permettant une plus
grande lisibilité. Le 1er caractère doit obligatoirement être une lettre ou bien
un caractère .
 Peut contenir jusqu'a 31 caractères minuscules et majuscules.
 Il est d'usage de réserver les identificateurs entièrement en majuscules
aux variables du préprocesseur.
Exemple:
- Identificateur valide : x y12 somme_1 _temperature
noms surface n_de_chier TABLE
- Identificateurs invalides :
4eme commence par un chiffre
x#y caractère non autorise (#)
no-commande caractère non autorise (-)
taux change caractère non autorise (espace)
 Les mots réservés

auto extern sizeof break float Static

case for struct char goto switch

const if typedef continue int union

default long unsigned do register Void

double return volatile else short while

enum signed
 Structure d’un programme C
#include <stdio.h>
#define PI 3.14159
/* calcul de la surface d'un cercle */
main()
{
float rayon, surface;
float calcul(float rayon);
printf("Rayon = ? ") ;
scanf("%f", &rayon) ;
surface = calcul(rayon) ;
printf("Surface = %f\n", surface) ;
}
/* définition de fonction */
float calcul(float r)
{
/* définition de la variable locale */
float a ;
a = PI * r * r ;
return(a);
}
 Opérateur Séquentiel

L'operateur séquentiel (,) permet de regrouper des sous-expressions sous forme

de liste. Ces sous expressions sont évaluées en séquence.

Exemple
int i;
float r;
double dble , d;
char *ptr;
char buffer[100];
d = (i = 1 , r = 2.718f , dble =
2.7182818);
r = (float)(ptr = buffer , i = 10);
 Les types de base

• Le langage contient des types de base qui sont les entiers, les réels simple et
double précision et les caractères que l'on identifie a l'aide des mots-clés int, float,
double et char respectivement.

• De plus il existe un type ensemble vide : le type void.

• Les mots-clés short et long permettent d'influer sur la taille mémoire des entiers et
des réels.
 Les types de base

Syntaxe type
void Ensemble vide
pas de type
char caractère
short int entier cours
int entier
long int entier long
float réel simple précision
double réel double précision
long double réel de précision étendue

Liste des différents types de base

 Les types de base

• La taille d'un entier par défaut est soit 2 soit 4 octets (dépend de la
machine). 4 octets est la taille la plus courante.

• La taille d'un entier court est en général 2 octets et celle d'un entier long 4
octets.

• La taille d'un entier court est inferieure ou égale a la taille d'un entier par
défaut qui est elle-même inferieure ou égale a celle d'un entier long.
char ≤ short int ≤ int ≤ long int
float ≤ double ≤ long double
• Les types short int et long int peuvent être abrégés en short et long.

• Le type char occupe un octet. Un caractère est considère comme un entier

qu'on pourra donc utiliser dans une expression arithmétique.
 Les types de base

• Les deux mots-clés unsigned et signed peuvent s'appliquer aux types

caractère et entier pour indiquer si le bit de poids fort doit être
considère ou non comme un bit de signe.

• Les entiers sont signés par défaut, tandis que les caractères peuvent
l'être ou pas suivant le compilateur utilisé.

• Une déclaration telle que unsigned char permettra de designer une

quantité comprise entre 0 et 255, tandis que signed char désignera une
quantité comprise entre -128 et +127.

• De même unsigned long permettra de designer une quantité comprise

entre 0 et 232-1, et long une quantité comprise entre -231 et 231-1.
 Les types de base

#include <stdio.h>
unsigned char mask;
long val;
main()
{
unsigned int indice;
float x;
double y;
char c;
...
return;
}
double f(double x)
{
unsigned short taille;
int i;
unsigned long temps;
double y;
...
return y;
 Les constantes Littérales
Constantes entières
•Une constante entière peut s'écrire dans les systèmes décimal, octal ou
hexadécimal.
•Une constante entière préfixée :
 du chiffre 0 est une constante octale,
 des caractères 0x ou 0X est une constante hexadécimale.
•Une constante entière est par défaut de type int.
•Elle est de type long si elle est suffixée par les lettres l ou L et non signée
lorsqu'elle est suffixée par les lettres u ou U.
Exemple
base 10 22 56 1789 32765
22u 56L 29UL 1L
base 8 0643 0177 0644 0755
0177L 0222UL 0777u 0766ul
base 16 0xff 0Xabcd 0x80 0X1
0xffL 0X1uL 0X7fU 0x5fUL
 Les constantes Littérales

Constantes réelles
Une constante réelle (ou constante en virgule flottante) est un nombre exprime
en base 10 contenant un point décimal et éventuellement un exposant sépare du
nombre par la lettre e ou E.

Une constante réelle est par défaut de type double.

Elle sera du type float si on la suffixe par la lettre f ou F.

Exemples

0. 1. 0.2 1789.5629
50000. 0.000743 12.3 315.0066
2E-8 0.006e-3 1.66E+8 3.1415927
1.6021e-19f 6.0225e23F 2.718281 6.6262e-34
 Les constantes Littérales

Constantes caractères
Une constante caractère est assimilée a un entier sur un octet dont la valeur
correspond au rang du caractère dans la table ASCII.
Une constante caractère est constituée soit :
 d'un caractère entre apostrophes ;
 d'une suite de deux caractères entre apostrophes dont le premier est
le caractère \. Ces caractères s'appellent des codes d'échappement ;
d'un mot de la forme '\nnn', nnn étant la valeur octale de l'entier
associe au caractère ;
 d'un mot de la forme '\xnn', nn étant la valeur hexadécimale de
l'entier associe au caractère.
 Les constantes Littérales
Constantes caractères
 Les constantes Littérales

Exemples
Valeur entière associée
'A' ==> 65
'x' ==> 120
'3‘ ==> 51
'$' ==> 36
'' ==> 32
'\n' ==> 10
'\t' ==> 9
'\b' ==> 8
'\"' ==> 34
'\\' ==> 92
'\'' ==> 39
'\0' ==> 0
'\177' ==> 127
'\x0a' ==> 10
'\000' ==> 0
 Les constantes Littérales
Constantes chaîne de caractères
•Une constante chaîne de caractères est une suite de caractères entre guillemets.
•En mémoire, cette suite de caractères se termine par le caractère ('\0').
•La valeur d'une chaîne de caractères est l'adresse du premier caractère de la
chaîne qui est donc du type pointeur de caractères (char ).
•Ne pas confondre "A" et 'A' qui n'ont pas du tout la même signification !
•Pour écrire une chaîne de caractères sur plusieurs lignes on peut :
 soit terminer chaque ligne par \,
 soit la découper en plusieurs constantes chaîne de caractères, le
compilateur effectuera automatiquement la concaténation.
exemple
char *chaine = "\
\n\
\t/----------------------------------------------\\\n\
\t| Pour écrire une chaîne sur plusieurs lignes, |\n\
\t| il suffit de terminer chaque ligne par \\ |\n\
\t\\---------------------------------------------/\n";
char *chaine = "écriture d'une chaîne de caractères "
"sur plusieurs lignes\n\n";
 Opérateurs arithmétiques

Une expression est constituée de variables et constantes (littérales et/ou symboliques)

reliées par des opérateurs.

Il existe 5 operateurs arithmétiques :

• l'addition (+),
• la soustraction (-),
• la multiplication (*),
• la division (/),
• le reste de la division entière (%).

Leurs opérandes peuvent être des entiers ou des réels hormis ceux du dernier qui agit
uniquement sur des entiers.

Lorsque les types des deux opérandes sont différents, il y a conversion implicite dans
le type le plus fort suivant certaines règles.
 Règle de conversion

• si l'un des opérandes est de type long double, convertir l'autre en long double,

• sinon, si l'un des opérandes est de type double, convertir l'autre en double,

• sinon, si l'un des opérandes est de type float, convertir l'autre en float,

• sinon, si l'un des opérandes est de type unsigned long int, convertir l'autre en unsigned
long int,

•sinon, si l'un des opérandes est de type long int et l'autre de type unsigned int, le
résultat dépend du fait qu'un long int puisse représenter ou non toutes les valeurs d'un
unsigned int ; si oui, convertir l'opérande de type unsigned int en long int ; si non,
convertir les deux opérandes en unsigned long int,

• sinon, si l'un des opérandes est de type long int, convertir l'autre en long int,

• sinon, si l'un des opérandes est de type unsigned int, convertir l'autre en unsigned int,

• sinon, les deux opérandes sont de type int.

 Règle de conversion

Les operateurs + et - admettent des opérandes de type pointeur, ceci pour

permettre notamment de faire de la progression d'adresse.

exemple char *pc;

int *pi;
int a, b, c;
...
...
c = 2*a + b%2;
pc = pc + a;
pi = pi - c;
 Opérateurs logiques

Le type booléen n'existe pas. Le résultat d'une expression logique

vaut 1 si elle est vraie et 0 sinon.
Réciproquement toute valeur non nulle est considérée comme vraie et
la valeur nulle comme fausse.

Les operateurs logiques comprennent :

• operateurs relationnels :

inférieur à (<),

inferieur ou égal à (<=),

supérieure à (>),

supérieure ou égal à (>=).

• l'operateur de négation ( !).

 Opérateurs logiques

• 2 operateurs de comparaison :

identique à (==),

différent de ( !=).
• 2 operateurs de conjonction :

le et logique (&&),

le ou logique (||).
•Le résultat de l'expression :

!expr1 est vrai si expr1 est fausse et faux si expr1 est vraie ;

expr1&&expr2 est vrai si les deux expressions expr1 et expr2 sont
vraies et faux sinon.

L'expression expr2 n'est évaluée que dans le cas ou l'expression expr1
est vraie ;

expr1||expr2 est vrai si l'une au moins des expressions expr1, expr2 est
vraie et faux sinon.

L'expression expr2 n'est évaluée que dans le cas ou l'expression expr1
est fausse.
 Opérateurs logiques

Exemple
int i;
float f;
char c;
i = 7;
f = 5.5;
c = 'w';
Expressions
f>5
(i + f) <= 1
c == 119
c != 'w'
c >= 10*(i + f)
(i >= 6) && (c == 'w')
(i >= 6) || (c == 119)
(f < 11) && (i > 100)
f>5 ==> vrai (1)
(i + f) <= 1 ==> faux (0)
c == 119 ==> vrai (1)
c != 'w' ==> faux (0)
c >= 10*(i + f) ==> faux (0)
(i >= 6) && (c == 'w') ==> vrai (1)
(i >= 6) || (c == 119) ==> vrai (1)
(f < 11) && (i > 100) ==> faux (0)
 Opérateurs de taille

L'operateur sizeof renvoie la taille en octets de son opérande.

L'opérande est soit une expression soit une expression

de type.

Syntaxe
sizeof expression
sizeof (expression-de-type)

L'opérateur sizeof appliqué à une constante chaîne de caractères renvoie le

nombre de caractères de la chaîne y compris le caractères \0 de n de chaîne.
Si p est un pointeur sur un type t et i un entier :

l'expression p + i
a pour valeur p + i*sizeof(t)
 Opérateurs de taille
Exemples
int menu[1000];
typedef struct cel {
int valeur;
struct cel *ptr;
} Cel;

sizeof menu / sizeof menu[0] ==> nombre d'elements du vecteur menu.

sizeof(long) ==> taille d'un entier long.
sizeof(float) ==> taille d'un flottant simple precision.
sizeof(struct cel) ==> taille d'un objet du type struct cel.
sizeof(Cel) ==> taille d'un objet du type Cel.
 Opérateurs d’ad. Et d’ind.

L'operateur & appliqué à un objet renvoie l'adresse de cet objet.

L'operateur * appliqué à un pointeur permet d'effectuer une indirection

c'est-a-dire retourne l'objet pointe.

Si vect est un vecteur, la valeur de la constante symbolique vect est égale

à &vect[0].

Si a est un objet de type t, &a est de type t *.

Réciproquement, si p est un objet de type t * , *p est de type t.

 Opérateurs d’ad. Et d’ind

Exemples
int u;
int v;
int *pu;
int *pv;
typedef struct cel
{
int valeur;
struct cel *ptr;
} Cel;
Cel c1, *c2;
u=3;
pu = &u ;
v = *pu ;
pv = &v ;
c2 = &c1 ;
 Opérateurs de manipulation de bits

Opérateurs arithmétiques "bit a bit«

Ils correspondent aux 4 opérateurs classiques de l'arithmétique

booléenne :

• le non logique (~),

• le et logique (&),
• le ou logique (|),
• le ou exclusif (^).
 Opérateurs de manipulation de bits
Les opérandes sont de type entier. Les opérations s'effectuent bit
à bit suivant la logique binaire.

int a, b, c, flag;
int Mask;
a = 0x6db7; |-0-|-0-|0110 1101|1011 0111|
b = 0xa726; |-0-|-0-|1010 0111|0010 0110|
 Opérateurs de manipulation de bits

c = a&b ; |-0-|-0-|0010 0101|0010 0110| (0x2526)

c = a|b ; |-0-|-0-|1110 1111|1011 0111| (0xefb7)
c = a^b ; |-0-|-0-|1100 1010|1001 0001| (0xca91)
flag = 0x04;
c = Mask & flag;
c = Mask & ~flag;
 Opérateurs de décalage

Il existe 2 opérateurs de décalage :

• décalage à droite (>>),

• décalage à gauche (<<).

Le motif binaire du 1er opérande, qui doit être un entier, est décalé du nombre de
bits indique par le 2eme opérande.

Dans le cas d'un décalage a gauche les bits les plus a gauche sont perdus. Les
positions binaires rendues vacantes sont remplies par des 0.

Lors d'un décalage a droite les bits les plus a droite sont perdus. Si l'entier a
décaler est non signé les positions binaires rendues vacantes sont remplies par
des 0, s'il est signé le remplissage s'effectue à l'aide du bit de signé.
 Opérateurs de décalage
Exemple

int etat;
int oct;
int ent;
int a;
a = 0x6db7; |-0-|-0-|0110 1101|1011 0111|
a = a << 6;
a = 0x6db7;
a = a >> 6;
ent = 0xf0000000;
ent = ent >> 10;
 Opérateurs de décalage

a = 0x6db7; |-0-|-0-|0110 1101|1011 0111|

a = a << 6; |-0-|0001 1011|0110 1101|1100 0000|
(0x1b6dc0)
a = 0x6db7;
a = a >> 6; |-0-|-0-|0000 0001|1011 0110|
(0x1b6)
ent = 0xf0000000;
ent = ent >> 10; |1111 1111|1111 1100|-0-|-0-|
(0xfffc0000)
oct = (etat >> 8) & 0xff;
 Opérateurs de décalage
Ce sont des opérateurs qui modifient l'ensemble des valeurs courantes des
variables intervenant dans l'évaluation d'expressions.
Operateurs d'affectation
Les operateurs d'affectation sont :

• L'affectation simple (=).

• Les affectations combinées :

+= -= *= /= %=
&= |= ^= <<= >>=

L'affectation est une expression. La valeur de ce type d'expression est la

valeur de l'expression située a droite de l'affectation.
On appelle g-valeur toute expression pouvant figurer à gauche d'une
affectation.
 Opérateurs de décalage
Un identificateur de vecteur n'est pas une g-valeur.
Une expression de la forme :
e1 op= e2 est équivalente à
e1 = e1 op e2

Exemple int valeur;

int i;
char c;
unsigned char masque;
int n;
i = 2; n = 8;
...
i += 3;
n -= 4;
valeur >>= i;
c &= 0x7f;
masque |= 0x1 << (n - 1);
masque &= ~(0x1 << (n - 1));
 Opérateurs d’incrémentation et décrémentation
Les operateurs d'incrémentation (++) et de décrémentation (--) sont des
opérateurs unaires permettant respectivement d'ajouter et de retrancher 1 au
contenu de leur opérande.
Cette opération est effectuée après ou avant l'évaluation de l'expression suivant
que l'opérateur suit ou précède son opérande.
Ces operateurs ne s'appliquent qu'a des g-valeurs.

Exemple int i, j, tab[100];

char buffer[2048];
char *ptr;
int *p_ent;
i = 99;
j = 2;
i++;
p_ent = tab;
*(p_ent + --i) = ++j;
ptr = buffer;
*ptr++ = '\n';
 Opérateurs conditionnels

L'operateur conditionnel ( ? :) est un opérateur ternaire. Ses opérandes sont

des expressions.

Syntaxe
expr1 ? expr2 : expr3

La valeur de l'expression expr1 est interprétée comme un booléen. Si elle est

vraie, c'est-a-dire non nulle, seule l'expression expr2 est évaluée sinon c'est
l'expression expr3 qui est évaluée.

La valeur de l'expression conditionnelle est la valeur de l'une des expressions

expr2 ou expr3 suivant que l'expression expr1 est vraie ou fausse.
 Opérateurs conditionnels
Exemple

int i;
int indic;
int a, b;
int c;
...
indic = (i < 0) ? 0 : 100;
c += (a > 0 && a <= 10) ? ++a : a/b;
c = a > b ? a : b;
 Les Variables

• Une variable est une abstraction d ’une portion de mémoire

• Une variable est caractérisée par :
(Nom, adresse, valeur, type, durée de vie, portée)
• L’utilisateur décide du nom et du type de la variable.
• L’emplacement de la déclaration décide de sa portée et de sa longévité. Son adresse
est déterminée pendant l’exécution et sa valeur dépend des instructions dans
lesquelles elle apparaît.

Le nommage des variables ne respecte pas de règle particulière hormis

! l'exclusion des espaces et des caractères accentués
 Les Variables
Type
Le C est un langage typé, chaque entité doit disposer d’un type.
Faisant la différence entre le nom (l ’identifacateur) variable (255
caractère max en C) et son type. La variable correspond a une
portion de la mémoire et que sa taille sera défini par un nombre de
bytes ou d ’octets déterminé par le type la variable

Void : type vide ( pas de type )

Char : caractères 1byte
int : entiers
float : réels
double : réels en double précision
Tableux
Pointeurs

structures , unions et énumérations

 Les Variables
Types -Tailles
Il existe d’autre type entier ou réel
les entiers longs long int,
int ou long (int est facultatif)
les entiers courts short int,
int ou short
les réels en quadruple précision long double
La taille des types n'est spécifiée dans aucune norme elle dépend de la machine

sizeof char ≤ short int ≤ int ≤ long int

float ≤ double ≤ long double

Les types char et int peuvent être signés ou non

unsigned char
signed char
unsigned int
signed int
unsigned long int
long unsigned int
 Les variables
La portée d'une variable

C permet de déclarer des variables et de les initialiser dans un bloc.

bloc La porté d’une
variable dépend de l’endroit ou il est placé:
globale Les variables globales sont déclarées en dehors de toute fonction Elle est
allouée et initialisé automatiquement avant l'entrée dans la fonction 'main'.
Elle est nettoyée et libérée automatiquement après la sortie de la fonction 'main'.

locale (dite également automatique) est visible dans le block d’instructions dans
lequel elle à été déclaré et ce, à partir de sa déclaration. Elle est allouée et initialisée.
Elle est nettoyée et libérée automatiquement, lorsqu’on sort du block d’instructions

Dynamique est totalement contrôlée par le programmeur.

Nous parlerons plus tard de ce type de variable.
 Les variables
classe de stockage
Le C dispose des classes de stockage qui permettent de spécifier la porté de la
variable :
•auto : la classe de stockage par défaut. Les variables ont pour portée le bloc
d’instructions où sont définis. Leur durée de vie est restreinte à ce bloc.
•static : permet de créer des variables dont la portée est le bloc d’instructions en
cours, mais qui, contrairement aux variables auto, ne sont pas détruites lors
de la sortie de ce bloc. À chaque fois que l’on rentre dans ce bloc
d’instructions, les variables statiques existeront et auront pour valeurs celles
qu’elles avaient avant que l’on quitte ce bloc.
• const : ce mot clé est utilisé pour rendre le contenu d’une variable non modifiable.
• extern : est utilisée pour signaler que la variable peut être définie dans un autre
fichier.
• register : permet de créer une variable dont l’emplacement se trouve dans un registre
du microprocesseur.
• volatile : cette classe de variable sert lors de la programmation système. Elle indique
qu’une variable peut être modifiée en arrière-plan par un autre programme
(par exemple par une interruption, par un autre processus).
• mutable : on verra sa définition dans la POO
 Les variables
la portabilité
Le type de la variable dépend de type de machine:
• int est codé sur 16 bits  PC en mode réel (DOS) et sous Windows 3.x.
• int est codé sur 32 bits  PC en mode protégé 32 bits (Windows 9x ou NT,
DOS, Linux) et sur les Macintosh
• int est codé sur 64 bits.  DEC Alpha et la plupart des machines UNIX

Bibliothèque stdint.h. <stdint.h>

intN_t : int8_t, int16_t, int32_t et int64_t,
leurs versions non signées uint8_t, uint16_t, uint32_t et uint64_t
 Forme Générale d’une déclaration

La forme générale d'une déclaration est la suivante :

< type > < construction > [,< construction >,...];

où type est un type élémentaire (type de base, énumération de constantes) ou

un type que l'on s'est défini, et un construction est soit un identificateur soit
un objet plus complexe construit a l'aide de
constructeurs homogènes ou hétérogène
 Constructeurs homogène

Des objets plus complexes peuvent être formés à l'aide des

constructeurs homogènes :

• les constructeurs de pointeurs,

• les constructeurs de vecteur,
• les constructeurs de fonction.

symbole Objet construit

[] tableau
* pointeur
() fonction
 Les Pointeurs

Définitions

• Un pointeur p est une variable qui sert à contenir l ’adresse mémoire

d ’une autre variable
• Si la variable v occupe plus d ’une case mémoire, l ’adresse contenue
dans le pointeur p est celle de la première case utilisé par v
• La variable v est appelé variable pointée
• Si p contient l ’adresse de v alors on dit que p pointe sur v
• Le pointeur possède un type qui dépend du type des variables pointées
• Un pointeur peut contenir aussi l ’adresse d ’une fonction, on parlera alors de
pointeur de fonctions
 Les Pointeurs
Déclaration

• Lorsqu ’on déclare un pointeur on indique le type des variables sur les quelles il
pointe

char * pc; // pc est un pointeur de caractères

int * pi ; // pi est un pointeur d ’entiers
float * pf; // pf est un pointeur de flottants

• Plusieurs déclaration sur une même ligne

int * p1, i1, *p2, i2; // pi est un pointeur d ’entiers

• p1et p2 sont des pointeurs d ’entiers*

• i1,i2 sont des entiers
• Il faut répéter les * pour chaque pointeur
 Les Pointeurs
Adresse d ’une variable : l ’opérateur &

• L ’adresse d ’une variable peut être obtenue grâce à l ’opérateur & suivi
du nom de la variable

int i=5;
printf("valeur de i = " , i);
printf("adresse de i = ",&i);
Résultats d ’exécution:
valeur de i = 5
adresse de i = 0x0012FF78

Ce résultats dépend de la machine

 Les Pointeurs
Affectation d’une adresse à un pointeur

int i=5;
adresse
int * pi; 0x05 0x0012FF78
Pi=&i; 0x00 0x0012FF79
i
printf("valeur de i %d ", i); 0x00 0x0012FF7A
printf("adresse de i %d ", &i); 0x00 0x0012FF7B
printf ("valeur de p %d ", p);

Résultats d ’exécution:
valeur de i = 5 0x78
adresse de i = 0x0012FF78 pi 0xFF
valeur de pi = 0x0012FF78 0x12
0x00
 Les Pointeurs
Incompatibilité de types

• On ne peut pas affecter à un pointeur de type T1 l’adresse d ’une variable d ’autre

type T2

int i=5;
char * pc;
pc=&i;
! Erreurs

• On peut cependant forcer la conversion.

• A utiliser avec précaution ....

int i=5;
char * pc;
pc= ( char *) &i;
 Les Pointeurs
Opérateur d ’indirection (*)
• Cet opérateur permet d ’accéder à la valeur de la variable pointée
• Si p contient l adresse de la variable v alors *p désigne la variable v elle même
int i=5;
int * pi=&i;
printf("valeur de i %d ", i);
printf("adresse de i %d ", &i);
printf("valeur de p %d ", p);
printf ("valeur pointé par p %d ", *p);

Résultats d ’exécution:
valeur de i = 5
adresse de i = 0x0012FF78
adresse de pi = 0x0012FF78
valeur de *pi =5
 Les Pointeurs
Pointeur Void
• Les pointeurs void sont un type particulier de pointeur
• Ils peuvent pointer sur une variable de n’importe quel type
• On ne peut pas utiliser l ’opérateur d’indirection * sur un pointeur void. Il faut
d ’abord le convertir en un pointeur d ’un type donné.

int a=5, b=6;

int * pi=&a;
void * pv = &b; //correct
pv=pi //correct
pi =pv // !!! Erreur!!!
pi=(int*) pv //correct
printf("valeur pointé par pv %d ", *pv); // !!! Erreur!!!
printf("valeur pointé par pv %d ", *((int *) pv )); //correct
 Les Pointeurs
Incrémentation et Décrémentation d ’un pointeur
• soit p un pointeur de type T
• soit t la taille en octets du type T
• soit a la valeur de p (adresse contenue dans p)
• si on exécute p++ alors la nouvelle valeur de p sera égale à a+t
int i=5; int *pi=&i;
printf("valeur de pi avant incrémentation %d " ,pi); pi++;
printf("valeur de pi après incrémentation %d" , pi);
Résultats d ’exécution:
valeur de pi avant incrémentation = 0x0012FF78
valeur de pi après incrémentation = 0x0012FF7C
int x=1.25; double *px=&x;
printf("valeur de px avant incrémentation = %d" , px); px++;
printf("valeur de pix après incrémentation = %d" px);
Résultats d ’exécution:
valeur de px avant incrémentation = 0x0012FF78
valeur de px après incrémentation = 0x0012FF80

• Le même principe s ’applique pour p--

 Les Pointeurs
Addition et soustraction d’un entier
• soit p un pointeur de type T
• soit t la taille en octets du type T
• soit a la valeur de p (adresse contenue dans p)
• soit n un entier
• si on exécute p+n alors la nouvelle valeur de p sera égale à a+n*t

int i=5; int *pi=&i;

printf("valeur de pi avant l ’addition = %d" , pi);pi+2;
printf("valeur de pi après l ’addition = %d" , pi);

Résultats d ’exécution:
valeur de pi avant l ’addition = 0x0012FF78
valeur de pi après l ’addition = 0x0012FF80

• Le même principe s’applique pour la soustraction d ’un entier

 Les Pointeurs
Exemple récapitulatif

• Soit pi un pointeur d ’entier

Numéro de case mémoire

42 46 47 48 49 50 51 52 53 54 58

pi-- pi++
pi-2 pi+2

pi
 Les Tableaux et Les Pointeurs

• Les identificateurs de tableaux et de pointeurs sont similaires

• L’identificateur d’un pointeur désigne l’adresse de la première case mémoire de
la variable pointée
• De même,l’identificateur d’un tableau désigne l’adresse de la première case
mémoire du tableau
• Il existe cependant une différence majeur:
 La valeur du pointeur peut être modifiée
 L’adresse du tableau ne peut pas être modifiée
• L’identificateur d’un tableau peut être considéré comme un pointeur constant
 Constructeurs homogène

char lignes[100];
int *p_entier;
double fonc();
Les déclarations précédentes permettent de définir respectivement :
- un vecteur de 100 caractères,
- un pointeur d'entier,
- une fonction retournant un réel double précision.

Ces constructeurs peuvent se combiner entre eux, permettant ainsi de définir des
objets encore plus complexes.

char *chaines[100];
int mat[100][40];
char **argv;
 Constructeurs homogène

Le constructeur homogène * est moins prioritaire que les deux autres.

De ce fait, les déclarations précédentes permettent de définir
respectivement :

- un vecteur de 100 pointeurs de caractère,

- un vecteur de 100 éléments, chaque élément étant un vecteur de
40 entiers,
- un pointeur de pointeur de caractère.
 Constructeurs homogène

L'utilisation de parenthèses permet de modifier la priorité et donc l'ordre

d'évaluation.
int (*tab)[10];
char (*f)();
char *(*g)();
float *(*tabf[20])();

Cet exemple permet de définir respectivement :

- un pointeur de vecteur de 10 entiers,

- un pointeur de fonction retournant un caractère,
- un pointeur de fonction retournant un pointeur de caractère,
- un vecteur de 20 pointeurs de fonction retournant un pointeur de reel
simple précision.
 Les Tableaux et Les Pointeurs
const int MAX=7;
int tab[MAX]; int *p;
p=tab; *p=0; //tab[0]=0
P++; *p=10; //tab[1]=10
p=&tab[2]; *p=20; //tab[2]=20
p=tab+3; *p=30; //tab[3]=30
p=tab; *(p+4)=40; //tab[4]=40
p[5]=50; *p=0; //tab[5]=50
*(tab+6)=60; //tab[6]=60
for ( int n=0; n<MAX; n++) printf(" %d/n, tab[n]);

Résultats d ’exécution:
0 10 20 30 40 50 60
• L’instruction telle que tab=p aurait provoqué une erreur à la compilation
Erreur de compilation : cannot convert from ‘ int * ' to ‘ int [7]'
 Affichage des Tableaux et Pointeurs
• Dans le cas d’un tableau ou de pointeur de caractère, l’affichage produit la
chaîne de caractère commençant à la première case du tableau ou à la case
d’adresse indiquée par le pointeur et finissant par la première case qui contient
le caractère \0 (fin de la chaîne) (code ASCII=0
ASCII=0).
• Dans les autres cas, l’affichage produira l’adresse de la première case du
tableau ou la valeur du pointeur (adresse contenue dans l’adresse )
• Pour obtenir l’affichage de la valeur d’un pointeur de caractère (c’est à dire
l’adresse qu’il contient) il faut le convertir en pointeur void avant
const int MAX=7; const int MAX=7;
int t[MAX]={1,2,3}; int *p; p=t; char t[MAX]= " ABCDEF " ; char *p; p=t;
printf( " t=%d ", t ); printf( " p %d ",p); prinf(" t= " ,t ); printf(" p " , p);
prinf("&t= %d" ,&t); printf("&p =%d,&p) ; printf("&t= ", ,&t ); printf("&p = ",&p) ;
printf( "*t= %d" ,*t); printf(" *p = %d" printf( "*t= " , *t ) ; printf( " *p = ", p) ;
,*p) ; Printf( " (void*) p = " ,(void *) p);
Résultats d ’exécution: Résultats d ’exécution:
t=0x0012FF54 p=0x0012FF54 t=ABCDEF p=ABCDEF
&t=0x0012FF54 p=0x0012FF50 &t=0x0012FF54 p=0x0012FF6C
*t=1 p=1 *t=A p=A
(void*) p=0x0012FF54
 Allocation dynamique
Normalement, une variable est créée automatiquement lors de sa déclaration.
Cela est faisable parce que les variables à créer ainsi que leurs tailles sont
connues au moment de la compilation (c'est le but des déclarations). Par
exemple, une ligne comme :
int tableau[10000];
signale au compilateur qu'une variable tableau de 10000 entiers doit être créée.
Le programme s'en chargera donc automatiquement lors de l'exécution.

1er situation :

Mais supposons que le programme gère une liste de clients. On ne peut pas
savoir à l'avance combien de clients seront entrés, le compilateur ne peut donc pas
faire la réservation de l'espace mémoire automatiquement. C'est au programmeur de le
faire. Cette réservation de mémoire (appelée encore allocation) doit être faite pendant
l'exécution du programme. La différence avec la déclaration de tableau précédente,
c'est que le nombre de clients et donc la quantité de mémoire à allouer, est variable. Il
faut donc faire ce qu'on appelle une allocation dynamique de mémoire.
 Allocation dynamique
2ème situation :
Supposant qu’un programme ait besoin d’afficher 100 objets graphiques différents et
que ces objets sont très volumineux ( en espace mémoire).
Supposant aussi qu’un instant donné, le programme n’a besoin d’afficher simultanément
et au maximum que 10 objets parmi 100.
Supposant que la taille de la mémoire permet au maximum le stockage simultané de 30
objets graphiques
Allouer les 100 objets de façon statique est impossible puisque l’espace mémoire est
insuffisant.
En revanche, déclarer dynamiquement 10 objets est tout à fait possible et le programme
pourra alors s’exécuter sans problème pour 100 objets à des instants différentes.

Technique en C
Il existe deux principales fonctions C permettant de demander de la mémoire
au système d'exploitation et de la lui restituer. Elles utilisent toutes les deux les
pointeurs, parce qu'une variable allouée dynamiquement n'a pas d'identificateur, étant
donné qu'elle n'est pas déclarée. Les pointeurs utilisés par ces fonctions C n'ont pas de
type. On les référence donc avec des pointeurs non typés. Leur syntaxe est la suivante :
 Allocation dynamique

Intérêt de l’allocation dynamique

• L’allocation dynamique permet une gestion plus flexible de la mémoire

• Un programme n’utilise la mémoire dont il a besoins qu’au moment du besoins

• Ainsi il évite de monopoliser de l’espace mémoire aux instants où il n’en a pas

besoins et permet donc à d’autres programmes de l’utiliser

• La mémoire peut ainsi être partagée de manière plus efficaces entre plusieurs
programmes.

• Il est impératif d’appeler l’opérateur free lorsqu’on n’a plus besoin de

l’espace mémoire correspondant sinon l’allocation dynamique perd tout son
intérêt.

• L’allocation dynamique sert les autres programmes mais elle peut aussi servir
le programme lui-même
 La fonction malloc

Demande d'allocation mémoire (malloc) :

Syntaxe :
#include <stdlib.h>
void *malloc ( size_t size);
Description :
malloc demande l'allocation d'un bloc de mémoire de size octets consécutifs dans
la zone de mémoire du tas.

• Les opérateurs malloc permet l’allocation de l’espace mémoire nécessaire

pour stocker un élément d’un type T donné.

malloc( taille_en_octets) abréviation de « Memory ALLOCation »

 La fonction malloc

• malloc demande l'allocation d'un bloc de mémoire de size octets consécutifs dans la
zone de mémoire du tas. Elle attend donc comme paramètre la taille de la zone de
mémoire à allouer et renvoie un pointeur non typé (void *).

•Si l'allocation réussit, malloc retourne un pointeur sur le début du bloc alloué.
•Si la place disponible est insuffisante ou si size vaut 0, malloc retourne NULL.

if ( ptr == NULL) {
printf (Allocation mémoire impossible \n");
exit(1);}
else {printf(“continuer le programme”);}

• Les fonctions d'allocation dynamique retournent des pointeurs sur des void. Il faut donc
opérer des conversions de types explicites pour utiliser ces zones mémoire en fonction du
type des données qui y seront mémorisées. Lorsqu'on alloue une variable typée, on doit
faire un transtypage du pointeur renvoyé par malloc en pointeur de ce type de variable.

T *p = (T*) malloc (sizeof T )

 La fonction malloc

• Pour allouer un d’un tableau de n élément de type t

ptr = (t *) malloc(n * sizeof (t))
• Il peut être fait appel à une macro afin d'alléger l'écriture:
#define MALLOC(t, n) (t *) malloc(n * sizeof (t))

• Pour utiliser les fonctions malloc, vous faite appel à la librairie stdlib.h
#include <stdlib.h>
 La fonction calloc

Demande d'allocation mémoire (calloc) :

Syntaxe :
#include <stdlib.h>
void *calloc (size_t nelem, size_t elsize);

Description :
La fonction calloc réserve un bloc de taille nelem x elsize octets consécutifs. Le
bloc alloué est initialisé à 0.
Valeur retournée :
• Si succès, calloc retourne un pointeur sur le début du bloc alloué.
• Si échec, calloc retourne NULL s'il n'y a plus assez de place ou si nelem ou elsize valent 0.

int *str = NULL;

str = (char *) calloc(10, sizeof (int));
 La fonction realloc
Demande de réallocation mémoire (realloc) :
Syntaxe :
#include <stdlib.h>
void *realloc(void *ptr, size_t size);
Description :

La fonction realloc ajuste la taille d'un bloc à size octets consécutifs.

Arguments :
ptr : pointeur sur le début d'un bloc mémoire créé par malloc, calloc,
ou realloc. Si ce pointeur est NULL, realloc équivaut à malloc.
size : nouvelle taille du bloc en octets.
Valeur retournée :
• Si succès, cette fonction retourne l'adresse de début du bloc réalloué.
Cette adresse peut avoir changé par rapport à celle fournie en argument.
Dans ce cas, le contenu de l'ancien bloc est copié à la nouvelle adresse et
l'ancienne zone est automatiquement libérée.
• Si échec, (pas assez de place en mémoire ou size à 0), realloc retourne la valeur
NULL.
 La fonction free
Libération mémoire (free) :
Syntaxe :
#include <stdlib.h>
void free(void *ptr);
Description :
La fonction free libère un bloc mémoire d'adresse de début ptr.
Ce bloc mémoire a été précédemment alloué par une des fonctions malloc, calloc, ou
realloc.
Attention :
• Il n'y a pas de vérification de la validité de ptr.
• Ne pas utiliser le pointeur ptr après free, puisque la zone n'est plus réservée.
• A tout appel de la fonction malloc ( ou calloc ) doit correspondre un et un
seul appel à la fonction free.
• Les appels pour libérer des blocs de mémoire peuvent être effectués dans
n'importe quel ordre, sans tenir compte de celui dans lequel les blocs ont été
obtenus à l'allocation.

Valeur retournée : aucune

 La fonction free

• Pour que l’allocation dynamique soit utile et efficace, il est impératif de libérer l’espace
réservé avec malloc, calloc, realloc dès que le programme n’en a plus besoin.

• Cet espace pourrait alors être réutilisé soit par le programme lui-même soit par d’autre
programmes

• Libération d’un élément simple : opérateur free

int *p = (int *) malloc (sizeof (int));
*p =5;
printf (*p);;
free ( p);
 Gestion de Mémoire
La pile
• La pile contient les variables qui sont déclarées à l’intérieur des fonctions ou à des blocs ({…})
• Ces variables sont appelées variables locales ou automatiques
• Elles sont créés à l’appel de la fonction et détruites à la sortie de la fonction
(respectivement à l’entrée et à la sortie du bloc)
• Leurs durées de vie est donc la durés de vie de la fonction ou du bloc
La zone statique
• La zone d’allocation statique contient les variables qui sont déclarées en dehors de toutes
fonction ou à l’intérieur d’une fonction mais avec le qualifiant static.
• Ces variables sont appelées variables globales ou statiques
• Elles sont créés à l’exécution du programme et détruites à la fin de celui-ci
• Leurs durées de vie est donc la vie du programme.
Le tas
• Le tas contient les variables qui sont créés par le programme au cours de son
exécution. On parle d’allocation dynamique.
• Ces variables sont appelées variables dynamiques
• Elles sont créés lorsque le programme utilise la fonction malloc et détruites lorsqu’il
utilise la fonction free.
• Leurs durées de vie est donc variable (comme à l’exécution du malloc et se termine à
l’exécution du free)
• Si le programme oublie d’appeler delete (ce qui est un signe de mauvaise programmation!)
sur une variable créée avec new, celle-ci sera quand même détruite à la fin de l’exécution du
programme.
 Tableaux dynamiques à 2 dimension
Exemple de tableau de chaînes …
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main()
{ char **ptr = (char **) NULL;
char buffer[BUFSIZ];
int nb = 0, i;
for( ;; ) {
printf( "Entrer une chaîne : " );
scanf( "%s", buffer );
if( ! strcmp( buffer, "fin" ) ) break;
ptr = (char **) realloc( ptr,++nb*sizeof(char *) );
ptr[nb-1] = (char *)malloc((strlen(buffer)+1)*sizeof(char) );
strcpy( ptr[nb-1], buffer );
}
for( i=0; i < nb; i++ ){printf( "%s\n", ptr[i] ); free( ptr[i] );}
free( ptr );
}
 Tableaux dynamiques à 2 dimension
• Il n’est pas possible en C++ d’allouer dynamiquement un tableau en 2 dimension de la
même façon que cela se fait pour les tableaux statiques.

• La valeur de la deuxième dimension doit être connue à la compilation

malloc(10* i*sizeof(int ) // OK malloc (i*j*sizeof(int)// Erreur!!

• Il existe cependant différentes solutions pour simuler un tableau à deux dimension (ou n)

• Le choix de la meilleure solution dépend de différents paramètres

 L’usage qui sera fait du tableau

Accès séquentiel, par ligne, par colonne, …

Accès aléatoire
 Nombre de lignes et/ou de colonnes

Fixe

Variable
 Avec ou sans gestion d’indices
….
 Les Variables: typdef
Définitions de types
Il arrive que l’on utilise des types un peu complexes en C. Par exemple l’écriture

typedef unsigned long ulong;

ulong p[3][5];

On a défini deux nouveaux types, ulong identique à unsigned long

Les clauses typedef sont donc essentiellement des raccourcis d’écriture, mais qui aident
beaucoup à lire les programmes :

Les déclarations de pointeurs ou de fonctions seront grandement facilitées en utilisant

typedef. Ainsi, voici quelques déclarations :

typedef int pfonc(double); // type fonction(double), de résultat

int pfonc pf1 = unefonction;
pfonc tpf[10] = { unefonction }; // tableau de 10 fonction
 Les Variables: enum

Les énumérations sont des types définissant un ensemble de constantes qui

portent un nom que l'on appelle énumérateur.
Elles servent a rajouter du sens a de simples numéros, à définir des variables
qui ne peuvent prendre leur valeur que dans un ensemble fini de valeurs
possibles identifiées par un nom symbolique.

enum [nom]
{
enumerateur1,
enumerateur2,
enumerateur3,
...
enumerateurn
};
 Les Variables: enum

Les constantes figurant dans les énumérations ont une valeur entière
affectée de façon automatique par le compilateur en partant de 0 par
défaut et avec une progression de 1.
Les valeurs initiales peuvent être forcées lors de la définition.

enum couleurs {noir, bleu, vert, rouge, blanc, jaune};

enum couleurs{noir = -1,bleu, vert, rouge = 5,blanc, jaune};

Dans le 1er exemple, les valeurs générées par le compilateur seront :

noir 0 vert 2 blanc 4

bleu 1 rouge 3 jaune 5

et dans le 2e :

noir -1 vert 1 blanc 6

bleu 0 rouge 5 jaune 7
 Constructeurs hétéromogène

Les constructeurs hétérogènes permettent de définir des objets renfermant des entités
de nature différente. Il en existe 3 :

• les structures,
• les champs de bits,
• les unions.

Les structures permettent de regrouper des objets dont les types peuvent être
différents.
 Les structures

Les structures permettent de regrouper des objets dont les types peuvent être différents.
Déclaration d’une structure
Struct Nom_Structure{ Champs
ou
type_champ1 Nom_Champ1; données membres
type_champ2 Nom_Champ2;
type_champ3 Nom_Champ3;
} [var1, var2, ..., varM ];

struct Personne
{ Les objets regroupés sont les
membres ou composantes de la
int Age;
structure qui les contient.
char Sexe;
};
 Les structures
•Les structures sont un exemple de définition de nouveaux types.

• Lors de la définition d'une structure des objets peuvent être déclarés et seront du type
associe a celle-ci.

• Ils peuvent être déclares ultérieurement mais dans ce cas la structure devra
nécessairement avoir un nom et struct nom est le nom du type associe.

• La taille d'une structure est au moins égale a la somme des tailles de ses membres du
fait d'éventuels alignements mémoires. L'operateur sizeof permet d'en connaître la taille.

Exemple
struct
{
char c;
unsigned int i;
float tab[10];
char *p;
} a, b
 Les structures

Définition d’une variable structurée

struct Nom_Structure Nom_Variable_Structuree, ...; struct Personne Pierre, Paul;

Accès aux champs d’une variable structurée

.
Nom_Variable Nom_Champ; Pierre.Age = 18; personne *pierre;
Nom_pointeur Nom_Champ; Pierre.Sexe = 'M'; Pierre -> Age=18
Pierre -> sexe=‘M’
Tableau de structures

struct Nom_Structure Nom_Tableau [Nb_Elements];

 Les structures
Déclaration d’une structure...
Il est toutefois possible de déclarer une structure sans en donner sa définition
struct exemple;
La définition doit se trouver plus loin dans le programme. Cela est très
semblable aux prototypes de fonctions.
On peut aussi définir des structures croisées :
struct exemple1;
struct exemple2 {
exemple1* pex1;
//...
};
struct exemple1 {
exemple2* pex2;
// ...
};
Ce qui serait impossible autrement. Notons toutefois que les opérations
nécessitant la taille de exemple1 sont interdites dans exemple2 ; en particulier, on
ne peut pas placer un champ de type exemple1 dans exemple2. Les fonctions
acceptant un paramètre de ce type peuvent par contre être déclarées (mais
difficilement définies puisqu’on ne peut utiliser aucun membre de la structure).
 Les structures

Un champ de bits est un ensemble de bits contigus a l'intérieur d'un même mot.

Le constructeur de structures permet de définir un découpage mémoire en champs de

bits. Les membres de cette structure désignent les différents champs de bits. Ils
doivent être du type unsigned int et indiquer le nombre de bits de chaque champ.

Syntaxe
struct [ nom ]
{
unsigned int champ1 : longueur1;
unsigned int champ2 : longueur2;
...
unsigned int champn : longueurn;
};
 Les structures
Champs de bits
L’unité usuelle de compte en informatique est l’octet en général. Cependant, dans
certains cas, on doit accéder à certains bits individuellement dans une donnée.
Pour cela, on dispose d’opérateurs sur les types d’entier, comme le décalage à gauche
ou à droite (<< , >>), le « et » , le « ou » et le « ou exclusif » logiques (&, |, ^).
Cependant, lorsqu’on doit faire de nombreux accès aux bits séparés d’une donnée,
cela devient trop long, et désagréable, de spécifier une opération logique chaque fois.
Les structures à champs de bits permettent de résoudre ce problème.
Une telle structure est semblable à toute autre, mais derrière le nom des champs du
type int ou unsigned, on précise un nombre de 1 à 16 indiquant la taille en bits du
champ. Voici un exemple simple :
struct champbits {
Cette structure occupe seize bits unsigned basbas : 4;
(4 fois 4) en mémoire, soit la taille unsigned bashaut : 4;
d’un entier usuel unsigned hautbas : 4;
int hauthaut : 4; };
Les champs de bits sont utilisés comme des entiers ordinaires ; lors d’une affectation,
les bits excédentaires sont supprimés, les bits manquants sont nuls. Par exemple, si
l’on écrit : champbits cb; int i = 30 // 30 == 0x1E
cb.bashaut = i; // met 0xF == 15 dans cb.bashaut
i = cb.bashaut; // maintenant i == 15
 Les structures

Les champs de bits sont utilisés comme des entiers ordinaires ; lors d’une
affectation, les bits excédentaires sont supprimés, les bits manquants sont nuls. Par
exemple, si l’on écrit :

champbits cb; int i = 30 // 30 == 0x1E

cb.bashaut = i; // met 0xF == 15 dans cb.bashaut
i = cb.bashaut; // maintenant i == 15

•Un champ peut ne pas avoir de nom. Sa longueur indique alors le nombre de bits que l'on
veut ignorer.

•Une longueur égale a 0 permet de forcer l'alignement sur le début du mot mémoire
suivant.
 Les structures
Exemple

struct zone
{
unsigned int a: 8;
unsigned int : 0;
unsigned int b: 8;
unsigned int : 8;
unsigned int c: 16;
};
struct zone z1, *z2;
Remarques

• Les champs de bits sont évalués de gauche a droite sur certaines machines et de
droite a gauche sur d'autres. Ce type de données n'est donc pas portable.

• On ne peut pas référencer les champs via une adresse.

 Les unions
• La taille d’une structure est la somme des tailles de leurs composants. Leur taille
peut donc devenir très grande. Or il arrive que certains champs ne soient pas utilisés
lorsque d’autres le sont, parce qu’ils sont mutuellement incompatibles

• Le constructeur union permet de définir des données de type différent ayant la

même adresse mémoire

Syntaxe union [ nom ]

{
< liste de declarations >
};

Remarques

• A la définition d'une union est associe un nouveau type : union nom lorsque nom a
été précisé à la définition.

• La taille d'une union est celle de la composante ayant la taille maximum.

 Les unions

•L’union groupe des données, comme les structures, mais au lieu de se trouver
placées les unes derrière les autres en mémoire, elles se trouvent toutes à la même
adresse.

• La syntaxe et les règles d'utilisation de l'union sont celles de la structure

union arg { char *caractère; int entier; };

union longgroupe {
long l;
unsigned mots[2];
unsigned char octets[4];
}
• cette union n’occupe que quatre octets en mémoire
 Les systèmes embraqués

Systèmes temps réels

• En charge du contrôle d'un processus
• Liés à la dynamique du processus à contrôler
• Soumis à des contraintes temporelles
• Pas forcément rapides (contrairement aux idées reçues)
• Prédictibles
• Contraintes matérielles fortes
• Mémoire
• Coût
• Taille
Développement systèmes temps réel

• Différence forte machine hôte / machine cible Machine hôte :

• Entrées / Sortie Standard

• IDE (spécifiques ou pas)
• Simulation de la cible / environnement / processus

• Entrées / Sorties ?
• Difficilement utilisable hors de son environnement

• Utilisation de méthodes formelles

• Tests (critères de couverture)
• Simulation fonctionnelle (exhaustive ou non) sur machine
hôte

• Critères de validation
• Temporelle
• Énergétique
• Empreinte mémoire
• …
 Les systèmes embraqués

Les systèmes embraqués fonctionnent sur batterie, l’objectif principal de

développement est l’autonomie maximale. Le microcontrôleur doit donc pouvoir
être placé en mode « veille » le plus souvent possible.
Une programmation événementielle par interruption est donc indispensable.
Un programme C embraqué devra toujours contenir une boucle sans fin : while(1)
Cette boucle contiendra un code minimum (ou pas de code). while(1){ }
- Si le microcontrôleur le permet la boucle contiendra une instruction de mise en
veille et basse consommation, le microcontrôleur se réveillant lors d’un événement
déclenchant une interruption.
- Les constantes seront placées en ROM.
- La programmation sera événementielle (interruptions).
 Microprocesseur

Les microcontrôleurs possèdent une mémoire ROM (souvent EEPROM

FLASH) importante (32KO à 1024 KO) mais une mémoire RAM (SRAM) ne
dépassant que rarement les 2KO. (Les transistors intégrés sur la puce sont
consacrés de préférence aux périphériques plutôt qu’à la mémoire) Il faut donc «
économiser » l’espace RAM.
Le linker place le module CRT (C Run Time) en début de programme
avant la fonction main. Le CRT initialise la/les piles, les variables et les
constantes. Les valeurs d’initialisation des constantes se trouvent forcement en
ROM et sont recopiées par le CRT en RAM. Cela n’a aucun intérêt pour les
constantes (qui ne seront jamais modifiées), cependant le C ANSI en raison de
son histoire place les constantes en RAM.
Dans un microcontrôleur les constantes doivent systématiquement être
placées en ROM. Il existe en C embarqué un qualificatif indiquant la mémoire
cible.
Afin d’optimiser la taille du code et la vitesse d’exécution il est
indispensable d’utiliser au maximum des variables et constantes du même type
que le type natif du microcontrôleur ( char pour un microcontrôleur 8bits).
Pas de Système d’exploitation (OS) dans un microcontrôleur.
Architecture de base Microprocesseur
 Microprocesseur

Microprocesseur (dans le même boitier):

• Processeur
• Mémoire
• Périphériques
• Bus de communication
• Entrées / Sorties

Informations importantes des datasheets

• Les ports d'Entrées / Sorties
• La description des périphériques intégrés

Timer ?

Convertisseurs A/D ?

liaison série ?
• L'organisation de la mémoire

Intégrée ou non
• Les registres
 Microprocesseur
Timer
• Permettent de mesurer le temps
• Sont liés à la fréquence physique d'oscillation
• Programmables et sources d'interruptions ou non
Mémoire
• Une place pour le programme

En RAM pour les premiers tests

En EEPROM (ou Flash) pour les tests plus poussés

En ROM une fois en production
• Une place pour les variables

En RAM bien sûr
• Une place pour la pile

En RAM mais pas n'importe où (début ou fin ?)

Dépend des micro-contrôleurs (implémentation matérielle de
push / pop)
Registres (Stockés en RAM )
 Microprocesseur
Registres de configuration (Stockés en RAM )
• Souvent nombreux
• 8 / 16 / 32 bits
• À une adresse mémoire particulière
• À considérer bit par bit

Registres 'utilisateur‘
(le registre UCSRnA du micro. ATmega128)
• 8 / 16 / 32 bits
• À une adresse mémoire particulière
• Permettent de stocker les données sur lesquelles travailler (∼ variables)
• Sont utilisés par les instructions de calcul assembleurs
 adresse physique

Les registres des microcontrôleurs sont à des adresses imposées par le

concepteur or le linker d'un compilateur C a le contrôle total des adresses, il choisit
ou sont rangées variables et constantes. Définir une adresse physique permet par
exemple de définir comme une variable l'adresse d'un registre (adresse imposée par
le micro contrôleur)
Exemple, on veut associer au mot mamem la mémoire RAM à l'adresse 0x80.
Ceci est un nombre : 0x80

#define mamem (unsigned char *)0x80

char c;
void main (void)
{
mamem = 0xAA; // on met 0XAA dans la mémoire 0x80
c=mamem; // c= 0xAA
while(1);
}
 Microprocesseur

Bus (communication)
 Microprocesseur

Bus (communication)
 Généralités sur les Interruption
● Une interruption est un arrêt temporaire de l'exécution normale du
programme principal par le microprocesseur afin d'exécuter un autre
programme (appelé routine d'interruption ou programme d'interruption).
Ce programme d'interruption va permettre de gérer l'évènement
qui a provoqué cette interruption.

● Tous les circuits périphériques (Timer0, Timer1, Timer2……) contenus

dans le microprocesseur (PIC) sont susceptibles de générer une
interruption.
 Interruptions en C

Le C ne sait pas traiter les interruptions. Lors de sa standardisation, la programmation

événementielle était beaucoup moins développée qu’aujourd’hui. (Beaucoup moins de
périphériques embarqués)
La gestion des interruptions impose :
- De placer le code de traitement à une adresse imposé par le microcontrôleur (vecteur
d’interruption)
-De terminer le sous programme d’interruption par une instruction « retour
d’interruption » à la place d’un simple « retour ». (Lors d’une interruption, généralement
tout le contexte des registres du microcontrôleur est sauvé dans la pile, ce qui n’est pas le
cas lors de l’appel d’un simple de sous programme)

Le C possède une directive de compilation #pragma qui permet à l’éditeur du

compilateur d’adapter le C à la cible. Ces directives ne sont pas standards et leur nom
change d’un éditeur à l’autre.
Il existe une directive #pragma forcer_adresse
qui force le linker à placer le code à une adresse précise.
Il existe une directive
#pragma cette_fonction_est_une_interruption qui indique au compilateur de
placern à la fin de la fonction une instruction de retour de sous programme d’interruption.
 Interruptions en C: exemple

#pragma code vecteur_d_IT=0x08 // force le linker sur vecteur d'IT

void une_fonction(void)
{
_asm goto traite_IT _endasm // saut absolu sur SP d’interruption
}
#pragma code // redonne libertee au linker
#pragma interrupt traite_IT // traite_IT est un SP d’interruption
void traite_IT(void)
{
if (INTCONbits.INT0IF) // vérifie que l'IT est INT0
{
Tache() ;
INTCONbits.INT0IF=0; //efface le drapeau d'IT
}
}
 Interruptions : Exemple

#include <avr/interrupt.h>
// 16-bit variables x et y
unsigned short x, y;
// interrupt change la value de x
ISR(XXX_vect) { x = 0x3333; }
int main() {
// valeur donnée de x
x = 0x1111;
// interruption global
sei();
// donne la valeur de x à y
y = x;
}
 Interruptions : Exemple
clignoter une LED dans chaque demie seconde
Pour Arduino ou pour le MSP430

#include <avr/io.h> la librairie définition de constantes d’accès aisé aux entrées et sorties

#include <util/delay.h> ajoute des fonctions permettant de mettre une execution en pause,
comme _delay_ms qui prend en argument le nombre de seconde

#define F_CPU 8000000L

La fréquence du microprocesseur doit être définie r pour la fonction _dealay _ms. Sans celà, les temps
d’attente seraient approximatifs.

#define DELAY 500

Void main(){
DDRB=(1<<DDR0); // on configure la broche 0 du port B en mode sortie
PORTB &(1<<DDB0); // on s’assure que la broche est éteinte
for(; ;) //boucle infinie
PORTB^=(1<<DDB0); // on bascule la broche à l’autre état (1 si 0 et 0 si 1)
_delay_ms(DELAY); // on attend une demie-seconde
}
 Interruptions : Exemple
Led qui clignote en utilisant les interruption
#include <homelab/pin.h> //librairie qui gère les couleurs du led
#include <homelab/delay.h>
#include <homelab/timer.h> //librairie les timers (horloges)
#include <avr/interrupt.h> // librairie d’interruptions
// Determinant les couleurs des LED-s.
pin led_red = PIN(C, 5); pin led_green = PIN(C, 3);
// lnterruption
ISR(TIMER1_CAPT_vect) {// Modification de l’état du led vers.
pin_toggle(led_green);
}
int main(void) { // Réglage de la couleurs du LED-s en sortie.
pin_setup_output(led_red);
pin_setup_output(led_green); // réglage de la minuterie dans le mode CTC.
timer1_init_ctc( TIMER1_PRESCALE_1024, TIMER1_CTC_TOP_ICR);
// la valeur maximale du timer est 14400, avec une période d’1 s
//Formule: 14,7456Mhz / 1024 = 14400
timer1_set_input_capture_value(14400);
// interruption réalisé
Timer1_input_capture_interrupt_enable(true);
// interruption globale.
sei(); .
while (true) {// boucle sans fin
// Délai de1000 ms.
sw_delay_ms(1000);
// Changement d’état de la led rouge.
pin_toggle(led_red); }
}