Vous êtes sur la page 1sur 18

LANGAGE C :

I] Généralités.

 mise au point en 1972  Denis Ritchie /Brian Kernighan


 TURBO C

II] Pourquoi un programme ?

4x1=4 i=1
……  faire une répétition
4x10=40 4xi=
afficher le résultat
i=i+1

 Exécuter des tâches répétitives


 Faire des calculs compliqués
 PC  que des calculs arithmétiques et logiques
 des répétitions, des entrées /sorties ( saisie de données, affichage de résultat )

III] Premier programme.

1 # include <stdio.h>
- 3 main ()
{
4 /* premier programme*/
2 5 printf (“Bonjour\n”);
6 return 0 ;
- }

Dans un programme en C, on trouve un ensemble de fonction : ici, 1 seule fonction : main ()


Minimum en C : main ()
{
-
-
}

1 : # include <stdio.h>
 standard inpout / outpout : permet d’inclure au programme des bibliothèques (
librairies), qui contiennent les définitions d’autres fonctions ( instructions).

Bibliothèques  nom = .lib


Fichiers d’entêtes  nom = .h

# include <stdio.h>
# include <math.h>
# include <graphics.h>
# include <string.h>

4 : /* commentaire */  ignoré pour l’exécution du prog.

Ex. : / *……….
5 : instruction ( fonction ) printf  affiche à l’écran une chaîne ( X# ) ou la valeur d’une variable ( résultat
d’un calcul )
 toujours ‘’ ‘’
ici : ‘’ Bonjour \n ‘’
affiché à l’écran
\n : code de saut de ligne ou signe de formattage
ici \n est facultatif : saut de ligne + retour à la ligne

Dès que l’on trouve un \ entre les ‘’ ‘’ d’un printf , le système attend derrière une lettre
pour exécuter une commande

\n : nouvelle ligne  saut de ligne + retour à la ligne


\t : tabulation ( par défaut 8 caractères)
\b : backspace  revient d’un caractère en arrière
\g : bell (sonnette)

Pour afficher un \ il faut écrire : \\


Pour afficher un ‘’ il faut écrire : \’’

Ex. : printf ( ‘’Bonjour \’’toi\’’\n’’) ;  Donne à l’écran : Bonjour ‘’ toi’’

6 : Return 0  retourne un code au système d’exploitation

autre Ex. :

#include <stdio.h>
main ()
{ char nom [20];
printf (‘’entrez votre nom : ‘’);
scanf (‘’%s’’,nom) ;
printf (‘’\n Vs vs appelez : %s’’, nom) ;
return 0
}

 char nom[20] ; déclaration de variables : une variable est un nom auquel on affectera une valeur
Ce nom comporte uniquement des lettres minuscules ou majuscules, des chiffres et __ ( 31 premier caractère
untilisé par le C )
Ex. : Pgcd différent de pgcd = 2 variables différentes

Déclaration de variable en début de prog.


Nom de la variable précédé du type
Char  caractère
Si un caractère : sans [] ex. : char x :
Si plusieurs caractères : donnez le nbre +1 ex. : char nom [20]
*différents type utilisés en C :
int  entier ex. : int a, b, c ;
float  réel ex. : float x1, x2 ;

*scanf est la fonction ( instruction) de saisie au clavier d’une valeur. Dans scanf, on trouve 1 symbole de
formattage % suivi d’une lettre enter ‘’ ‘’. Pas de \ dans scanf, ni de texte)

%s  chaîne de caractère
%c  caractère unique
%d  entier
%f  réel
%e  réel exponentiel
%x  entier héxadécimal

Ex. : int a ;
float x ;
scanf (‘’%d’’, &a) ;
scanf (‘’%f’’, &x );
ou scanf (‘’%d %f’’, &a,&x) ;

Dans l’exemple, %s dans printf sera remplacé par le contenu de la variable nom
-printf (‘’\n Vs vs appelez : %s, ‘’ nom) ;  pas de & dans les printf

 donne à l’écran

Généralisations : on déclare 3 variables :


int a ;
float x ;
char truc ;
scanf (‘’ %c %d %f ‘’,&truc, &a, &x) ;

on affecte les valeurs Z à truc, 10 à a et –312.7 à x.


on affiche : printf (‘’ x=%f, truc=%c et a=%d’’, x, truc, a) ;

A l’écran on a : ……….x = -312.7, truc = Z et a = 10 _

IV] Résumé.

1/ Fonction d’affichage de donnés.

*printf (‘’ ‘’, ….) ;


liste variables, facultative si existe il y a %….entrée ‘’ ‘’
* il y a cprintf ( )  même syntaxe
* puts  pour afficher du texte ex :puts ( ‘’bonjour ‘’) ;
mais pas puts ( ‘’ x = %d ‘’ , x) ;
* putch ( ) et putchar ( ) permet d’affiché un seul caractère ex : putch ( ‘ A )  apostrophe

2/ Fonction de saisie de données.

* scanf (‘’%….’’) ;
* gets pour la saisie de chaîne
ex. : char ch[20]
gets ( ch) ou scanf ( ‘’%s’’, ch) ;
* getch et getche et getchar  caractère seul
ex. : char x ;
x=getch ( ) ou getche ou getchar équivaut à scanf (‘’%c’’, &x) ;

LES TYPES DE DONNEES EN C.

I] Définition.

Ensemble des valeurs qui peut prendre 1 variable. Donc un type et un seul est associé à une variable.
Le type peut être définit par l’utilisateur ( complexe ) ou à partir de types existants  type standard  float,
int , char

II] Type entiers.

1 octet = 1 byte = 8 bits  sont codés sur 2 octets  216 = 65536


non signé  0 à 65535  unsigned int
signé  -32568 à +32767  int

ou 4 octets  -231 à +231-1  long (signé)


231 = 2 147 483 648 ex : long y ;
y = 1 438 700
0 à 232-1  non signé  unsigned long

ou 1 octet (entier court)


non signé  0 à 28-1 (0 à 255)  unsigned char
signé  -128 à +127  char

Ex. de type char :

27 20
128 64 32 16 8 4 2 1

Ex. : on saisit le caractère A ; x = getch () on tape A

Code ASCII  (41)H ou (65)10


Cas 1 : 0100| 0001
On saisit l’entier 41 avec scanf (‘’%d’’, & y) ;
Cas 2 : 0010 |1001
On veut reprendre les valeurs en mémoire et afficher les résultats
Cas 1 : printf (‘’%c’’, x)  A
printf (‘’%d’’, x)  65
cas 2 : printf (‘’%d’’, y)  41
printf (‘’%c’’, y)  )
scanf (‘’%d’’, &y)
scanf (‘’%c’’, x)  dans les deux cas on tape 1

III] Réels.

Codés sur 4, 8 ou 10 octets sous la forme exposant

float  4 octets  +/- 3.4E+/-38  float x ;


double  8 octets  +/- 1.7E+/- 308  double x ;
long double  10 octets  -3.4E-4932 à + 1.1E+4932  long double x ;

Saisie ou affiche pour float  %f


double et long double  %lf
int  %d
long  %ld

On peut préciser un nbre de chiffres défini à l’avance lors d’un affichage (et d’une saisie ) :
Entiers printf (‘’%4d’’, x) si x = 3, on affiche : _ _ _ 3 _
 complété avec des 0
%04d  0003 _
 cadrage à gauche
%-4d  3000 _

réels  %5.3f 5 : parti entière et 3 partie décimal


Ex. : printf (‘’%5.3f’’, x) avec x = 3.14
_ _ _ _3.14 _

saisie sous forme exponentielle  %e

LES OPERATEURS EN C.

I] L’affectation.

Symbole = : a =3.5 et non 3.5 = a

II] Opérateurs arithmétiques.

_+
_-
_*
_/
incrémentation de 1  a=a+1  a++
décrémentation de 1  b=b-1 b—

1/ Logique ( sur un ensemble de bit).

ET logique  &&
Résultat nul si au moins 1 des opérateurs est nul sinon 1
Y = 5&&3  y vaut 1
Y = 0&&2  y vaut 0

OU logique  | |
Complément  !
Comparaison  = =
Résultat égal 1 si les deux termes sont égaux sinon 0
Ex. : printf (‘’%d’’, a= =b)

2/ Opérateur binaire ( sur bit ).

ET bit à bit  &


OU ‘’  |
OU exclusif  ^
Complément  ~
Décalage à droite  <<n
Décalage à gauche  >>n
Avec n nbre de décalage

LES STRUCTURES DE CONTROLE.

I] Structure alternative simple.

Si condition vraie alors instruction 1


Instruction 2
…………….
Sinon instruction 10
Instruction 20

 if ( )………
……….
else ……….
……….
Equation du premier degré :

Ax+b = 0  x = -b/a  a différent de 0

#include <stdio.h>
main()
{ float a, b, x ;
printf (‘’donnez la valeur de a et b :’’);
scanf (‘’%f %f’’, &a, &b) ;
if (a= = 0)
printf (‘’ a nul , pas de calcul ‘’) ;
else
{ x = -b/a ;
printf (‘’ solution x = %f’’, x) ;
}
}

dans la condition on trouve les opérateur logiques :

= = != < > <= >=


les structurs peuvent s’imbriquer, le premier else se rapporte toujours au dernier if sauf si précisé par {}

II] Structure répétitive.

1. while ()  tant que (condition vraie)


répéter …….
…….
En C :
while ( condition vraie )
{_
_
}
Le test s’effectue avant la boucle de répétition qui peut ne pas être exécutée.

Exemple : Somme des n premiers entiers >0 ; n saisie au clavier

S=n+(n-1)+(n-2)+…+2+1+0

#include <stdio.h>
main()
{unsigned int S,n;
puts (‘’Donnez un entier : ‘’) ;
scanf (‘’%d’’, &n) ;
S=0 ;
while (n >0)
{ S=S+n ;
n=n-1 ;
}
printf (‘’la somme est : S=%d’’, S) ;
}
2. do {…….} while ()  répéter tant que condition vraie
le test étant fait en fin de boucle, la boucle est exécutée au moins une fois.

Exemple : calcul de factorielle

n! = n x (n-1) x…….x 2 x 1 pour n>0

#include <stdio.h>
main()
{ int F,n;
puts (‘’donner un entier >0’’);
scanf (‘’%d’’, &n) ;
F=1;
do
{F=Fxn;
n = n – 1;
} while (n>1);
printf (‘’ la factorielle est : %d’’, F) ;
}

III] Itéractions ou boucles.

Structure répétitive particulière si on connaît la condition d’arrêt de la répétition avant d’exécuter


cette répétition.

For (condition vraie ; condition de poursuite ; modif de la condition)

 si plusieurs conditions séparer avec des ,


 toujours les ;

for ( ) ou for ( )
_instruction {…….plusieurs instructions
}

Ex : Ecrire les nombres de 10 en 10 de N1 à N2 :

#include <stdio.h>
main()
{ int N1, N2, x;
puts (‘’Donner 2 entiers N1 supérieurs à N2) ;
scanf (‘’%d %d’’, &N1, &N2) ;
for ( x = N2 ; x <= N1 ; N2 = N2 + 10)
x = x + 10;
printf (‘’la somme est : x = %d’’, x);
}

Autres exemples de boucle :

Exemple : écrire 100 fois ‘’OK’’ sur une ligne :

for ( i = 1 ; 1 <= 10 ; i++)


{ printf (‘’\n OK’’);
}

 jamais de ; en fin des for !!!


Exemple avec des conditions multiples :

main()
{ int i,j ;
for ( i = 2 , j = 4 ; ( i<5) && ( j>2) ; i++ , j--)
printf (‘’ i = %d et j = %d \n’’, i , j);
}

Remarque : dans les conditions de poursuite de boucles on peut comparer une variable à 2 valeurs par
exemple : 0 <= x <= 10  en C il faut écrire : ( x>= 0) && ( x <= 10)

IV] Sorties des structures répétitives.

 break : permet de sortir d’une structure répétitive for ou while ou do….while.


 continue : permet de passer à l’instruction suivante

main()
{ int i, j ;
for ( i = 1 ; i < 10 ; i++)
{ printf (‘’i = %d’’, i);
if ( i == 5 ) break
} printf (‘’i = 5’’);
}

break fait sortir du bloc dans le quel il se trouve

ou for ( i = 1 : i <10 ; i++)


{ if ( i ==3) continue ;
else printf (‘’ i = %d’’, i);
}

V] Sélections multiples.

case…..
…….
……..
default : ……. ;
}
la variable ne peut ête que de type entier ou caractère.

Exemple : main()
printf (‘’i = ? :’’ ) ; scanf ( ‘’%d’’, &x);
switch ( i )
{ case 0 : printf (‘’zero \n ‘’) ; break ;
case 1 :
case 2 : printf (‘’ un ou deux \n ‘’) ; break ;
case 4 : break
case 5 : printf (‘’cinq \n’’) ; break ;
case 200 : printf (‘’deux cent \n’’; break ;
case 50 : printf (‘’cinquante \n’’) ; break ;
} default : printf (‘’autre case’’);

default doit être le dernier cas à envisagé , pas besoin de break.


ALGORITHMIQUE.

I] Algorithme.

Représentation physique ( sous forme graphique ) de la méthode d’analyse d’un problème pour
arriver à sa solution.

II] Symbole utilisé.

Arbre programmatique :

la représentation se fait suivant 2 axes :


III] Exemple : équation du 1° degrés.

#include <stdio.h>
main()
{ float a, b, x;
printf (‘’ Donner a et b : ‘’);
scanf (‘’%f %f’’, &a, &b) ;
if ( a = = 0 )
printf (‘’ impossible’’) ;
else
{ x = - a/b ;
printf (‘’ x = %f ‘’, x);
}
}

Algorithme de la somme n des premiers entiers  n saisie au clavier

changement de type ou transcodage ou outcasting : il suffit d’écrire le nouveau type entre () devant la
variable :
int a ; a=1
float x ; x = a/3  dans x on aurait 0
x = ( float ) a/3  x = 0.3333 mais pas x = (float) (a/3)

Supposons que l’on écrive x = 1/3


Pour avoir un résultat réel écrire x = 1.0/3 ou x = 1./3

LES TABLEAUX.

I] Définition.

Suite séquentielle de données de même type. Le nombre d’éléments définit la taille du tableau,
chaque élément est acessible par l’intermédiaire d’un indice, le premier élément est toujours repéré par
l’indice 0

II] Déclaration.

Exemple d’un tableau à une dimension comportant 7 éléments de type int :


type  int t1 [7] ;
t1  nom
7  nbre d’éléments

indices  0 1 2 3 4 5 6
toujours de type entier supérieur ou égal :
8 4 3 -1 6 4 -30
 1 élément du tableau

l’accès d’un élément se fait à partir de son indice


écrire dans une case  t1 [3] = -1
lire dans un case  x = t1 [3]

IMPOSSIBLE DE REMPLIR OU D‘AFFICHER LE CONTENU GLOBAL D’UN TABLEAU

printf (‘’%d’’, t1) ;  ne pas écrire ça !!


scanf (‘’%d’’, &t1) ;

Pour afficher/saisir il faut passer par les structures de répétition.

int i ;
for ( i = 0 ; i < 7 ; i++)
printf (‘’%d ‘’, t1[i]) ;
Saisie du tableau :

I=0;
while ( i < 7 )
{ printf (‘’\n t1 [%d] =…’’, i) ;
scanf (‘’%d’’, &t1[i]) ;  toujours & pour les char, int , float par pour les chaînes.
i++ ;
}
t1 [0] = 10 (scanf)
t1 [1] = …..

ATTENTION : en C pas de tests sur les limites d’un tableau par exemple avec le tableau précéder à 7
éléments on peut écrire printf (‘’%d’’, t1[60]) ;  pas d’erreur affiche un résultat

III] Tableau à 2 dimensions.


En partant de l’exemple précédent, on peut avoir 3 lignes de 7 colonnes déclaration int t1[5][7]
 ces indices définicent des lignes ou des colonnes : dépend de celui qui la déclaré.

IV] Tableau à 4 dimensions.

Exemple : float tab [4][5][365][6][2000]

V] Opérations sur les tableaux.

Toutes les opérations arithmétiques ou logiques sont possibles éléments par éléments

if ( t1 == t2)  faux mais ne donne pas d’erreur car le nom d’un tavbleau est l’addresse mémoire du premier
élément du tableau.
if ( t1[i][j] == t2[i][j])

On peut initialiser un tableau lors de sa déclaration

float tab1[3][4] = {{-1.5,3,4.1,6} , {6,-3.8,-5,0} , {4,-6,-3.2,2}} ;


float tab2 [ ][ ] ;  possible mais conseillé

VI] Tableau de chaîne.

C’est le cas particulier d’un tableau à une dimension un caractère dit de fin de chaîne doit être placé à la fin
du tableau
Tableau noté  ‘\0’
Ex.  nom avec 20 lettres max.  char x[21]
 20 caractères plus celui de chaînes
ex. :
char jours [9]
scanf (‘’%s ‘’, jours) ;
 jamais de & ni de []

J E U D I
0 1 2 3 4 5 6 7 8 9

achiffage d’une chaîne  printf (‘’%s’’, jours);

ATTENTION : scanf (‘’%c’’, &jours [3]) ;


printf (‘’%c’’, jours [1]) ;  afficherait (e)

TABLEAUX DE CHAINES.

Opération sur les chaînes de caractères


Passer par des fonctions  bibliothèque <string.h>
Ex : char ch1[30], ch2[30] ;
ch1 = ‘’truc’’  non
ch1=ch2  non
copy  strcpy (ch1, ch2)
strcpy (ch1, ‘’truc’’)
Pas de différences minuscules ou majuscules
Comparer 2 chaînes  strcmp (ch1, ch2)
Stricmp (ch1,ch2)
Stricmp (ch1, ‘’truc’’)
 renvoie –1 si 1ère chaîne < la 2ème
 0 si les deux chaînes sont identiques
 +1 1ère chaîne > la 2ème

En C, si on a plusieurs caractères la notation est : ‘’ oui ‘’


Si un seul caractère : ‘ A ‘

ATTENTION : ‘’A’’ et différent de ‘A’


 la lettre ‘’A’’ plus caractère de fin de chaîne
char rep ;
 1 seul caractère dans la variable
if (rep == ‘’0’’ )  non  if (rep ==’0’)
 l’opérateur de comparaison est utilisable pour les caractères seuls

cas de plusieurs caractères :


char rep1[3] ;
if (rep1 == ‘’oui’’)  non  if ( strcpy ( rep1, ‘’oui’’))

LES POINTEURS.

I] Définition.

C’est une variable qui contient l’adresse d’une autre variable. Un pointeur doit être déclaré avant
utilisation et de même type que la variable pointée.
Le pointeur contient une adresse qui est de type entier > 0
Une valeur particulière de pointeur est nommée NULL  c’est un pointeur qui pointe sur rien ( aucune
adresse)
Déclaration : int *p1 ; * : symbole du pointeur
float *y ; p1, y : nom de la variable
 on dit que y pointe sur un réel

II] Utilisation des pointeurs.

Exemple : main()
{ int i, j, *p ; déclaration des variables
i=5 ;
p = &i ;  & : symbole d’adresse dans p on met l’adresse de i
met dans j le  j = *p ;
contenu de la *p = j + 2 ;  la valeur de l’expression j + 2 (7) est rangé dans le contenu de
variable point } la va riable pointée par p donc i
par p donc j = 5

A retenir : &i :signifie adresse de la variable i


*p :signifie que l’on agit sur le contenu de la variable pointée par p

III] Opération sur les pointeurs.

Exemple : int *alpha ;


float *beta ;
alpha = alpha + 1 ;
beta = beta + 1 ;
-suposons que alpha contienne 1000 et que beta contienne 2000
-que sont alpha + 1  1000 + 1  1002
de même beta + 1  2000 + 1  2004
incrémenter de 1 un pointeur signifie pointer sur l’élément suivant ( du type pointé), ici alpha = alpha + 1
signifie que alpha qui pointait sur une variable entière (adresse 1000) pointe sur la variable entière suivante
(+1) d’adresse 1002 car un entier est codé sur 2 adresses
De même pour beta qui pointe sur un réel codé sur 4 octets ( 4 adresses) beta + 1 pointe sur le réel suivant
d’adresse 2004.

IV] Pointeurs et tableaux.

Ex : main()
{ int a[10], *ptab, x ;
a[0] = 11 ;a[1] = 12 ;a[2] = 13 ;a[3] = 14 ;
ptab = c;
x = *ptab; /1
ptab = ptab + 1; /2
x = * ptab; /3
x = *ptab + 1; /4
x = *(ptab + 1); /5
}

-solutions : /1 x vaut 11
x = *ptab  on met dans x le contenu de la variable pointée par ptab
/2 ptab = ptab + 1  ptab contient l’adresse de a[1] ou ptab pointe sur a[1]
/3 x = *ptab ; x vaut 12  on aurait pu écrire x = a[1]
/4 x = *ptab + 1 ; x vaut 13
/5 x = * (ptab + 1 )  pemet de pointer le 3ème élément a[2]
* (ptab + 1) représente le contenu de l’élément pointé par (ptab + 1) donc le contenu du 3ème élément a[2]
x vaut 13
x = * (ptab + 1) est identique à x = a[2]
la valeur ptab n’est pas modifié

V] Application.

main()
{ int x, y, *z ;
printf (‘’z pointe sur x’’) ;
x = 11 ;
z = &x ;
printf (‘’adresse de x : %d’’, z) ;
printf (‘’valeur de x : %d’’, x) ;
y = *z ;
*z = 49 ;
printf (‘’valeur de y : %d’’, y) ;
printf (‘’valeur de x : %d’’, x) ;
}

IV] Transferts de données entre fonctions.

1/ Passage d’arguments par adresses.

passage d’arguments par adresses (par référence) permet à une fonction de modifier les valeurs des variables
de la fonction appelante

Exemple : permutation de 2 nbres

Passage d’arguments par valeurs


#include <stdio.h>
void permut1 (int n1, int n2);
main()
{ int a, b;
scanf (‘’%d %d’’, &a, &b);
permut1 (a, b);
printf (‘’a = %d et b = %d’’, a, b);
}
void permut 1 (int n1, int n2) ;
{ int x ;
x = n1 ;
n1 = n2 ;
n2 = x ;
printf (‘’dans la fonction n1 = %d et n2 = %d’’, n1, n2) ;
}
Si on avait appelé les variables de la foncton a et b au lieu de n1 et n2 il n’y aurait pas eu permutation pour
autant  pas de changement :
Changement :
#include <stdio.h>
void permut1 ( int *n1, int *n2);
main()
{ int a, b;
scanf (‘’%d %d’’, &a,&b);
permut1 (&a,&b);
printf (‘’a = %d et b = %d’’, a, b);
}
void permut1 ( int *n1, int *n2) ;
{ int x ;
x = *n1 ;
*n1 = *n2 ;
*n2 = x ;
printf (‘’ ‘’, *n1, *n2) ;
}

Remarque :
Quand on utilise des fonctions et des pointeurs on a souvent un message d’erreur ( ou un warning) de type
Lvalue required, conclusions essayer les différentes cpmbinaisons &, * et rien devant les variables sources de
l’erreur.

VII] Déclarations de variables globales.

Une variable globale est une variable dont la valeur est connue dans toutes les fonctiond d’un programme.
Ex : permutation de deux nbres

#include <stdio.h>
int a, b ; /* variables globales */
void permut (void);
main()
{ scanf (‘’%d %d’’, &a, &b);
permut (a, b);
printf (‘’a = %d et b = %d’’, a, b) ;
}
void permut ()
{ int x ; /* x est une variable locale */
x=a;
a=b;
b=x;
}

VIII] Fonctions récursives.

Ex. : calcul de factorielle  !n = n x (n-1) x……x 2 x 1

main()
{ int x ;
scanf (‘’%d’’, &n) ;
printf (‘’ factorielle de %d est %d’’, x, fact (x)) ;  appel de fonction
}
int fact (int n ) ;
{ if (x >= 1)
if ( x = = 1)
return 1;
else
return x*fact ( x-1);
}

LES STRUCTURES.

I] Définition.

Collection ou ensemble d’éléments de type différent ( entier, réels, chaînes,…) dans une même entité
logique.
Ex. : struct date { char jour, char mois[12], int an}
 type  entier court

date est un nouveau type de variable, il faut des noms de variables de ce type. Déclaration des variables de
type structure date ;
struct date d1, d2, x ;
 type  variables

II] Méthode de déclaration.

1/ -struct point { int x ;


int y ;
char couleur[30] ;
}
déclaration des variables de type struct point
struct point p1, p2 ;

2/ -struct { int x ;
int y;
char couleur[30];
} p1;  nom de la variable dans la structure

3/ combinaison des 2 méthodes


-struct point { int x ;
int y ;
char couleur[30] ;
}p1, p2, p3 ;

4/ autre possibilité avec type def :


type def permet de définir un type de variable
type def int entier ;
int x, y ;
entier a, b, z ;

type def struct { int x ;


int y;
char couleur[30] ;
} point;
déclaration variables  point p1, p2, x;

III] Utilisation.

Dans les déclarations précédentes point est une structure p1 et p2 sont des variables de type structure
point x, y et couleur sont les champs ou membres de la structure.
Pour accéder à un nombre de la structure la notation est variable structure.champ
Ex. : p1.x = 300
p1.y = p1.x
( saisie au clavier : scanf (‘’%d’’, &p1.x) ;
scanf (‘’%s’’, p1.couleur) ; )
p1.couleur = ‘’rouge’’  ne marche pas
strcpy (p1.couleur, ‘’rouge’’)  OK
printf (‘’%s’’, p1.couleur) ;
si on a déclaré int n ;
n = p1.y
si on a deux structures p1 et p2 de même type, on peut recopier l’une dans l’autre par p1 = p2.
Identique à : p2.x = p1.x
p2.y = p1.y
p2.couleur = p1.couleur

IV] Pointeur vers une structure.

Struc point {int x ;


int y ;
char couleur[30] ;
}p1, *p2 ;
on accède à un champ par la notation : p2-> x = 300 ( signe – plus signe >)

V] Tableaux de structures.

0 int x int y char couleur [30]

.
.
x

Déclaration struct point { int x ;


int y ;
char couleur[30] ;
} p1, t[500] ;

pour accéder à un champ d’un élément du tableau, on note :


t[0].x t[50].x
t[0].y

Remarque : t[10].couleur représente la couleur du 11ème élément du tableau


t[10].couleur[0] représente la 1ère lettre du champ couleur du 11ème élément du tableau.

VI] Réservation mémoire pour les structures.

Une structure est une variable dynamique  réserver mémoire avec malloc ou calloc avant de lui
affecter une valeur.
P1 = (struct point*) malloc (sizeof(p1)) ;

DU C AU C++.

I] Introduction au C++.

Un compilateur C++ reconnaît tous les programmes écrits en C.


modif  l’extension du programme source .CPP au lieu de .C
 à la place de stdio.h, on utilise la bibliothèque iostream.h
 printf et scanf peuvent être remplacés par cout et cin avec les opérateurs de redirection << et >>
 dans une fonction de type void on peut ne rien préciser
 les commentaires sur une seule ligne sont précédés de //
 les déclarations de variables peuvent être placées n’importe ou dans le programme mais avant leur
utilisation.

II] Exemple : demande un entier n et affiche la liste des entiers compris entre 1 et n et calcule le nombre
d’entier affiché.

#include <iostream.h>
int lit_nombre(); // prototype
main()
{ int fin ;
fin = lit_nombre() ;
long total = 0 ;
for (int i = 1 ; i <= fin ; i++)
{ total = total + i;
cout << ‘’i = ‘’ <<i<<’’, total =’’ <<total<<endl
}
cout << ‘’total final = ‘’ << total
}
int lit_nombre()
{ cout << ‘’taper un nombre’’ ;
int n ;
cin >> n ;
return n ;
}