Language-C.ppt

1
Introduction au Langage C,C++
Formation Admin INSTA
Source « Université de Metz »

3
Mon Premier Programme en C
#include <stdio.h>
void main()
{
printf("Bonjour!n");
}
Inclusion de la bibliothèque
contenant la fonction printf
Point d'entré du programme
première
instruction
Début du programme
Fin du programme

4
Définition d'une variable
nom:
Unique pour chaque variable
Commence toujours par une lettre
Différenciation minuscule-majuscule
type:
Conditionne le format de la variable en mémoire
Peut être soit un type standard ou un type utilisateur
valeur:
Peut évoluer pendant l'exécution
initialisation grâce à l'opérateur d'affectation

5
Types de variable
charcaractères
int entiers
short [int] entiers courts
long [int] entiers longs
float nombres décimaux
double nombres décimaux de précision
supérieure
long double nombres décimaux encore plus
précis
unsigned int entier non signé
[..] signifie facultatif

6
Déclaration d'une variable
Type nom_de_la_variable [= valeur]
Exemple:
int nb;
float pi = 3.14;
char c = 'a';
long i,j,k;
double r = 6.2879821365;

7
Affichage de la valeur d'une variable
en C
printf("format de l'affichage", variables)
Exemple
int i =8;int j = 10;
printf("i vaut: %d j vaut: %d n",i,j);
float r = 6.28;
printf("le rayon = %f n",r);
Autres formats:
%c caractère
%lf double
%s chaîne de caractères
%e réel en notation scientifique

8
Affichage de la valeur d'une variable
en C++
cout <<chaîne 1 <<variable 1<<chaîne 2 <<variable 2;
Exemple
int i =8;int j = 10;
cout <<"i vaut:" << i <<"j vaut:"<<j <<'n';
float r = 6.28;
cout<<"le rayon = "<< r <<'n';

9
Instructions de base
opérateurs de base
+,-,*, /  opérateurs arithmétique de base
%  reste d'une division entière
==  test d'égalité
!= test de différence
<, >, <=, >= test de comparaison
!  négation
||  ou logique pour évaluer une expression
&&  et logique pour évaluer une expression

10
opérateurs de base
a = 2+3 valeur de a: 5
r = 3%2 valeur de a: 1
a = (3==3) valeur de a: 1
a = (6==5) valeur de a: 0
a = (2!=3) valeur de a: 1
a = (6<=3) valeur de a: 0
a = !1 valeur de a: 0
a =((3==3) || (6<=3)) valeur de a: 1
a =((3==3) && (6<=3)) valeur de a: 0

11
boucle pour
for(expr1;expr2;expr3)
{
instructions
}
expr1: évaluée 1 seule fois en début de boucle
expr2: évaluée avant chaque itération. Si vrai alors
les instructions de la boucle sont exécutées sinon
la boucle est terminée
expr3: évaluée à la fin de chaque itération

12
boucle pour
exemple
// somme des 100 premiers entiers
int i,s;
s= 0
for(i=0;i<=100;i = i+1)
{
s = s+i; / / ou s+=i;
}
cout <<"s = "<<s<<'n';

13
boucle tant que
while (expression)
{
instructions;
}
expression est évaluée avant chaque itération. Si le
résultat est vrai alors les instructions sont exécutées
sinon on sort de la boucle
exemple
i =0;
n = 20;
while (i<n)
{
i++;
}

14
boucle répéter
do
{
instructions;
} while (expression)
expression est évaluée après chaque itération. Si le
sinon on sort de la boucle
exemple
i =0;
n = 20;
do
{
i++;
} while(i<n)

15
instruction conditionnelle simple si alors
if (expression)
{
instructions;
}
sinon on sort de la boucle.
exemple
int i =5;
int n;
if (i<=20)
{
n =0;
}

16
instruction conditionnelle simple si alors sinon
if (expression)
{
instructions1;
} sinon
{
instrutions2;
}
résultat est vrai alors les instructions1 sont
exécutées sinon on exécute l'ensemble instructions2
exemple
int i =5;int n;
if (i<=20)
n =0;
else
n=5;

17
instruction conditionnelle multiple
switch (expression)
{
case valeur1:
instructions1;break;
case valeur2:
instructions2;break;
.
.
.
case valeur3:
instruction3;break;
default:
instruction4;break;
}
expression est évaluée. Si le résultat vaut valeur1, alors
instruction1 est exécutée et on quitte le switch, sinon
si expression vaut valeur2, ……, sinon on va dans
default pour exécuter instruction4.

18
instruction conditionnelle multiple
exemple
int c='a';
switch (c)
{
case 'a':
file();break;
case 'b':
save();break;
case 'q':
quitter();break;
default:
beep();break;
}

19
l'instruction break
permet d'interrompre prématurément une
boucle et de se brancher vers la première
instruction n'appartenant pas à la boucle
exemple:
int i;int n=20;
for (i=0;i<10;i++)
{
if (n==31) break;
n=n+2;
}
cout <<n<<'n';
Quand n vaut
31 alors la
boucle est
interrompue

20
Les Pointeurs
Deux manières d'utiliser une variable
Par son nom adressage direct
compilateur réserve de la mémoire pour la variable
exemple:
int x =17;

21
Les Pointeurs
Par son adresse adressage indirect
une variable de type pointeur contient l'adresse
d'une autre variable
Le lien entre pointeur et la variable pointée est
géré par le programmeur
exemple:
int x =17;
int * px = &x;
px
pointe
vers x

22
Les Pointeurs
déclaration d'un pointeur
type * nom_du_pointeur
exemples
char *buffer;
int *pf;
float *ppi;
 C'est au programmeur d'initialiser le pointeur

23
Les Pointeurs
initialisation d'un pointeur
Il faut lui fournir l'adresse d'une variable existant en
mémoire
Il doit pointer vers une zone mémoire réservée par le
compilateur comme étant une variable
utilisation de l'opérateur d'adressage &
int f;
int *pf,*pg;
pf = &f;
pg =(int*)malloc(sizeof(int));
.
.
free(gf);
création du
lien entre le
pointeur et la
variable allocation
dynamique
d'une variable
de type int
création du
lien entre pg
et l'espace
mémoire
réservé
libération de
l'espace
réservé

24
Les Pointeurs
utilisation de l'opérateur d'indirection *
travaille la valeur de la variable pointée
exemples
int i =8;
int *pi;
pi = &i;
cout <<*pi<<'n';
*pi = 19;
cout <<i<<'n';
8
19

25
Les tableaux statiques à 1 dimension
définition
Ensemble de variables de même type, de
même nom caractérisées par un index.
déclaration
type nom_tableau[dimension]
exemples:
char buffer[80];
int mat[10];
doit être
une
constante

26
Les tableaux statiques à 1 dimension
accès aux éléments du tableau
Nom_tableau[indice]
exemples:
buffer[5] = 'c';
mat[6] = 10;
 le premier élément commence à l'indice 0 !!
 Les valeurs ne sont pas initialisées !!
 Les débordements ne sont pas vérifiés

27
Les tableaux statiques à 2 dimensions et
plus
définition
Il s'agit d'un tableau de tableaux
déclaration
type nom_tableau[dim1][dim2]…[dimn]
exemples:
char buffer[20][80];
int mat[6][10];
char livres[100][60][80];

28
Les tableaux statiques à 2 dimensions
et plus
accès aux éléments
nom_tableau[ind1][ind2]…[indn]
exemples:
livre[30][15][20] = 'c';
mat[5][6] =13;
cout << mat[5][6]<<'n';

29
Lien entre le nom d'un tableau à 1
dimension et les pointeurs
Nom du tableau = adresse du premier élément
du tableau
nom_tableau[i] peut s'écrire *(nom_tableau+i)
exemples:
char buffer[80];
*buffer = 'C'; accès au premier caractère
*(buffer + 5) = 'V'; accès au 6 ème caractère

30
un tableau 2d est un tableau de tableau de
dimension 1
On peut donc dire que le nom d'un tableau 2d est
l'adresse d'un tableau d'adresse de tableaux de
dimension 1
On dit aussi qu'il s'agit d'un pointeur de pointeur
exemple:
int TAB[6][7];
int **p; déclaration d'un pointeur de pointeur
p = TAB; initialisation du pointeur de pointeur

31
TAB
0
1
2
3
4
5
0 1 2 3 4 5 6
tableaux de pointeurs
vers des tableaux
d'entiers
tableaux d'entiers

32
Initialisation dynamique d'un tableau
Tableau une dimension
int * t;
t = (int*)malloc(20*sizeof(int));
nom
du
tablea
u
fonction de
calcul
automatiqu
e de la
taille d'un
entier en
octet
fonction
d'allocation
dynamique
de la
mémoire
nombre
d'élément
s dans le
tableau

33
Tableau à deux dimensions n*m
déclaration dynamique du tableau de n
pointeurs et des n tableaux à une dimension
de m éléments
quelques lignes de code sont nécessaires
(voir transparent suivant)

34
Tableau à deux dimensions n*m
int **TAB,l;
TAB = (int**)malloc(n*sizeof(int*));
for (l=0;l<n;l++)
{
TAB[l] = (int*)malloc(m*sizeof(int));
}
désallocation:
for (l=0;l<n;l++)
free(TAB[l]);
free(TAB);

35
Les structures de données
intérêt
Rassembler des données hétérogènes
caractérisant une entité pour en faire un
type utilisateur.
exemple:
point dans l'espace 3 entiers
nœud d'un arbre binaire 2 adresses vers les
fils, 3 entiers pour les données du nœud
noms et références des pièces mécaniques
constituant une voiture
600 tableaux de caractères + 600 entiers pour
la référence

36
déclaration
struct nom_structure
{
type1 nomchamps1;
type2 nomchamps2;
.
.
.
typeN nomchampsN;
};

37
exemple et utilisation
struct pt
{
int x;
int y;
int z;
char nom;
};
main()
{
struct pt p;
}

38
simplification de l'écriture
struct pt
{
int x;
int y;
int z;
char nom;
};
typedef struct pt point;
main()
{
point p;
}
typedef struct pt
{
int x;
int y;
int z;
char nom;
} point;
Notations
équivalentes

39
accès aux données
Deux cas de figure
On dispose du nom de la variable
Accès par: NomVariable.NomChamps
exemple
main()
{
point p1;
p1.x = 8; p1.y = 9; p1.z = 10;
cout <<p1.x<<p1.y<<p1.z<<'n';
}

40
accès aux données
Deux cas de figure
On dispose de l'adresse de la variable (pointeur)
Accès par: NomVariable->NomChamps
exemple
main()
{
point *pp1, p1;
pp1 = &p1;
pp1->x = 8; pp1->y = 9; pp1->z = 10;
cout <<pp1->x<<pp1->y<<pp1->z<<'n';
}

41
Les fonctions
définition
Ensemble d'instructions pouvant être
appelés de manière répétitive par un nom
déclaration
type arg_ret nom_f( type arg1,type arg2, …type argn)
{
ensemble instructions
}
- arg_ret est l'argument renvoyé par la fonction (instruction
return
- nom_f est le nom de la fonction
- arg1 …argn sont les arguments envoyés à la fonction

42
Les fonctions
règles d'utilisation
L'ordre, le type et le nombre des arguments
doivent être respectés lors de l'appel de la
fonction
L'appel d'une fonction doit être située après
sa déclaration ou celle de son prototype
(voir exemple transp suivant)
Si la fonction ne renvoie rien alors préciser
le type void

43
Les fonctions
exemple:
int min(int a, int b);
void main()
{
cout <<min(a,b)<<'';
}
int min(int a, int b)
{
if (a <b) return a;
else return b;
}
Prototype de
la fonction
min
Programme
principal
Fonction min
et son bloc
d'instruction
s

44
Les fonctions
Les paramètres se passent par valeur
Recopie en mémoire des paramètres dans
des paramètres temporaires.
Toute modification des paramètres dans la
fonction est sans effet sur les paramètres
originelles
Quand on quitte la fonction, les paramètres
temporaires sont effacés de la mémoire
Recopie dans le sous programme appelant de la
valeur du paramètre retourné par la fonction
return.

45
Les fonctions
exemple:
void permutter(int a, int b)
{
int temp;
temp = a;
a = b;
b= temp;
}
void main()
{
int x=3;int y =5;
permutter(x,y);
cout << "x="<<x<<" y="<<y<<'n';
}
x=3 y=5
Aucune
action sur
les paramètres
x et y

46
Les fonctions
Passage d'arguments par adresse
On passe non pas la valeur de la variable
mais son adresse
Il est donc possible par les pointeurs de
modifier le contenu de l'adresse, donc la
variable originelle
Permet de modifier plusieurs arguments à
la fois dans une fonction
Permet de passer des tableaux en
argument

47
Les fonctions
exemple:
void permutter(int *pa, int *pb)
{
int temp;
temp = *pa;
*pa = *pb;
*pb= temp;
}
void main()
{
int x=3;int y =5;
permutter(&x,&y);
cout << "x="<<x<<" y="<<y<<'n';
}
Action sur
les paramètres
x et y
x=5 y=3

48
Les Fichiers
Les fichiers sont soit:
binaires (un float sera stocké comme il est codé en mémoire
, d'où gain de place mais incompatibilité entre logiciels)
formaté ASCII (un float binaire sera transformé en
décimal puis on écrira le caractère correspondant à chaque
chiffre).
Pour accéder aux données, on le fait
soit:
De manière séquentielle (on accède au contenu dans l'ordre
du stockage)
Par un accès direct (on peut directement accéder à
n'importe quel endroit du fichier)

49
Les Fichiers
Les Fonctions
Prototypées dans stdio.h, io.h, fcntl.h
Ouverture d’un fichier
handle = open(char *nomfic, int mode);
nomfic: pointeur vers une chaîne de caractère contenant le
chemin, le nom du fichier et l’extension du fichier
mode: variable entière dont chaque bit possède une signification
particulière. Utilisation de constantes prédéfinies
O_RDONLY Ouverture pour lecture seule
O_WRONLY Ouverture pour écriture seule
O_RDWR Ouverture pour lecture et écriture
O_APPEND Ajout des données à la fin du fichier
O_CREAT Crée le fichier s’il n’existe pas
O_BINARY Ouvre le fichier en mode Binaire
(Stockage de l’info comme elle est stockée dans la mémoire de
l’ordinateur)
O_TEXT Ouvre le fichier en mode Texte. (On
mémorise le code ASCII de chaque nombre ou caractère)

50
Les Fichiers
Les Fonctions
Écriture dans un fichier
int write(int handle, void *bloc, unsigned taille);
Handle: numéro entier caractérisant le fichier (renvoyé lors de
l’ouverture du fichier avec la fonction open)
Bloc: pointeur vers le bloc de données
Taille: taille en octet de ce bloc
Lecture dans un fichier (idem écriture avec fonction
read)
int read(int handle, void *bloc, unsigned taille);
Fermeture d’un fichier
int close(int handle)

51
Les Fichiers
Exemple
// inclusion des entêtes des fonctions
#include <io.h>
#include <fcntl.h>
#include <string.h>
main()
{
int handle; // numéro caractérisant le fichier
char string[40]; // tableau de caractères
int length; // Variable mémorisant la taille du bloc de données
int x=40; // entier x valant 40
int y=102; // entier y valant 102
// ouverture du fichier Monfichier.txt avec création s'il n'existe pas
// Fichier ouvert en écriture en mode texte
handle = open("c:Monfichi.txt",O_CREAT |O_RDWR |O_APPEND);
// Fonction (idem à printf) qui écrit un message formaté dans un tableau
// de caractères (printf l'écrit vers l'écran)
length=sprintf(string,"valeur de x=%d valeur de y=%d n",x,y);
// Ecriture de la chaîne de caractères dans le fichier
write(handle,string,length);
// Fermeture du fichier
close(handle);
}

Language-C.ppt

Contenu connexe

Tendances (20)

Similaire à Language-C.ppt (20)

Dernier (20)

Language-C.ppt