Download resume de language c and more Essays (university) Informatics Engineering in PDF only on Docsity!
1. Les bases
1.1 La structure d’un programme Un programme simple se compose de plusieurs parties :
- des directives de précompilation
- une ou plusieurs fonctions dont l’une s’appelle obligatoirement main(), celle-ci constitue le programme principal et comporte 2 parties :
- la déclaration de toutes les variables et fonctions utilisées
- des instructions y compris les appels des autres fonctions Les commentaires débutent par /* et finissent par */, ils peuvent s’étendre sur plusieurs lignes. 1.2 Les directives de précompilation Elles commencent toutes par un #. Commande signification #include <stdio.h> permet d’utiliser les fonctions printf() et scanf() #include <math.h> (^) permet d’utiliser les fonctions mathématiques #define PI 3.14159 définit la constante PI
#undef PI à partir de cet endroit, la constante PI n’est plus définie
#ifdef PI // si la constante PI est définie, on compile les instructions1, sinon, les instructions instructions 1 ... #else instructions 2 ... #endif Parmi ces directives, une seule est obligatoire pour le bon fonctionnement d’un programme : #include <stdio.h>. En effet, sans elle, on ne peut pas utiliser les fonctions utiles pour l’affichage à l’écran : printf() et la lecture des données au clavier : scanf(). Nous verrons le fonctionnement de ces fonctions plus tard.
1.3 La fonction main()
Elle commence par une accolade ouvrante {et se termine par une accolade fermante }. À l’intérieur, chaque instruction se termine par un point-virgule. Toute variable doit être déclarée. main(){ int i ; /* declaration des variables / instruction; ... } Exemple de programme simple : #include <stdio.h> #include <stdlib.h> / Mon 1er^ programme en C */ main(){ printf("Bonjour mes amis\n") ; system(‘’pause’’) ; return 0 ; }
2. Variables et constantes 2.1 Les constantes Constantes entières 1, 2, 3,... cons tint n=10 ; Constantes caractères ’a’,’A’,... const char cara=’a’ ; Constantes chaînes de caractères "Bonjour" ; const char ch[20]="Bonjour" ;
Cours Résumé de C
Exemple d’utilisation :
Pas de constantes logiques Pour faire des tests, on utilise un entier. 0 est équivalent a faux et 1 à vrai.
2.2 Les variables 2.2.1 Noms des variables
Le C fait la différence entres les MAJUSCULES et les minuscules. Donc pour éviter les confusions, on écrit les noms des variables en minuscule et on réserve les majuscules pour les constantes symboliques définies par un #define. Les noms doivent commencer par une lettre et ne contenir aucun blanc. Le seul caractère spécial admis est le soulignement (_). Il existe un certain nombre de noms réservés (while, if, case, ...), dont on ne doit pas se servir pour nommer les variables. De plus, on ne doit pas utiliser les noms des fonctions pour des variables. Déclaration des variables : Pour déclarer une variable, on fait précéder son nom par son type. Il existe 6 types de variables :
Type Signification Valeur min Valeur max char caractère codé sur un octet -2^7 (-128) 27 (+127) short entier court codé sur 2 octets -2^15 (-32768) à 215 -1 (+32767) unsigned short entier court codé sur 2 octets 0 à 216 -1 (+65535) long entier long codé sur 4 octets -2^31 +2^32 - int entier codé sur 4 octets -2^31 +2^31 - float réel codé sur 4 octets -2^31 +2^31 - double réel double codé sur 8 octets -2^63 +2^63 - On peut faire précéder chaque type par le préfixe unsigned, ce qui force les variables à prendre des valeurs uniquement positives. Exemples de déclarations : déclaration int a ; a est un entier int z=4 ; z est un entier = unsigned int x ; x est un entier positif (non signé) float zx, zy ; (^) zx et zy sont de type réel float zx=15.15 ; zx est de type réel et vaut 15. double z ; z est un réel en double précision char zz ; zz est une variable caractère char yz=’a’ ; yz est une variable caractère et vaut ’a’ Il n’y a pas de type complexe. 2.3 Les opérateurs
Le premier opérateur à connaître est l’ affectation "=". Exemple : {a=b++" ;} Il sert à mettre dans la variable de gauche la valeur de ce qui est à droite. Le membre de droite est d’abord évalué, et ensuite, on affecte cette valeur à la variable de gauche. Ainsi l’instruction i=i+1 a un sens. Pour les opérations dites naturelles, on utilise les opérateurs +, -, *, /, %. % est l’opération modulo : 5%2 est le reste de la division de 5 par 2. 5%2 est donc égal à 1. Le résultat d’une opération entre types différents se fait dans le type le plus haut. Les types sont classés ainsi :
char < short < int < float < double
#include <stdio.h> #include <stdlib.h> const int n=10; const char cara='a'; const char ch[20]="bonjour"; main(){ printf("%d %c %s \n",n, cara,ch); system("pause"); return 0; }
printf("%d",n) ; /* affiche la valeur de n au format d (decimal) */ printf("n=%d",n) ; / * affiche ’n=3’ / printf("n=%d, m=%d",n,m) ; / affiche ’n=3, m=4’ / } printf("n=%5d",n) ; / affiche la valeur de n sur 5 caracteres : ’n=^ 3’ */ Le caractère % indique le format d’écriture à l’écran. Dès qu’un format est rencontré dans la chaîne de caractère entre " ", le programme affiche la valeur de l’argument correspondant.
printf("n=%d, m=%d , k= %f " ,n, m, 25.5);
ATTENTION! le compilateur n’empêche pas d’écrire un char sous le format d’un réel ⇒ affichage de valeurs
délirantes. Et si on écrit un char avec un format décimal, on affiche la valeur du code ASCII du caractère. Tableau des formats utilisables %d int entier (décimal) %u unsigned entier non signé (positif) %hd short entier court %ld long entier long %f float réel, notation avec le point décimal (ex. 123.15) %e float réel, notation exponentielle (ex. 0.12315e+03) %lf double réel en double précision, notation avec le point décimal %le double réel en double précision, notation exponentielle %c char caractère %s char chaîne de caractères
Remarque : une chaîne de caractères est un tableau de caractères. Elle se déclare de la façon suivante : char p[10] ;. Mais nous reviendrons sur la notion de tableau plus tard.
La fonction scanf()
Dans un programme, on peut vouloir qu’une variable n’ait pas la même valeur à chaque exécution. La fonction scanf() est faite pour cela. Elle permet de lire la valeur que l’utilisateur rentre au clavier et de la stocker dans la variable donnée en argument. Elle s’utilise ainsi : main(){ int a ; scanf("%d",&a) ; // se trouve dans la librerie stdio.h } On retrouve les formats de lecture précisés entre " " utilisés pour printf(). Pour éviter tout risque d’erreur, on lit et on écrit une même variable avec le même format.
Le & est indispensable pour le bon fonctionnement de la fonction. Il indique l’adresse de la variable, mais nous
reviendrons sur cette notion d’adresse quand nous aborderons les pointeurs.
La librairie string.h
La librairie string.h fournit un certain nombres de fonctions très utiles pour manipuler des chaînes de caractères en C. En effet, le C ne sait faire que des affectations et des comparaisons pour 1 seul caractère. char p, q ; /* p et q sont des caractères / char chaine1[10], chaine2[10] ; / chaine1 et chaine2 sont des chaînes de caractères */ p = ’A’ ; chaine1 = "Bonjour" ; chaine2 = "Hello" ; if (p == q) ;
/* instruction valide / / instruction NON valide (1) / / instruction NON valide (2) / / instruction valide / if (chaine1 == chaine2) / instruction NON valide (3) */
Pour faire les affectations (1) et (2), et la comparaison (3), il faudrait donc procéder caractère par caractère. Ces opérations étant longues et sans intérêt, on utilise les fonctions déjà faites dans string.h. Pour les opérations d’affectation (1) et (2), il faut utiliser la fonction strcpy (string copy), et pour une comparaison (3), la fonction strcmp (string compare). #include<stdio.h> #include<string.h> main(){ char chaine1[10], chaine2[10] ; int a ; strcpy(chaine1,"Bonjour") ; /* met "Bonjour" dans chaine1 / strcpy(chaine2,"Hello") ; / met "Hello" dans chaine2 / a=strcmp(chaine1,chaine2) ; / a reçoit la différence chaine1 et chaine2 / / si chaine1 est classé alphabétiquement avant chaine2, alors a<0 / / si chaine1 est classé après chaine2, alors a>0 / / si chaine1 = chaine2, alors a = 0 / / Ici, "Bonjour" est alphabétiquement avant "Hello", / / donc chaine1 est plus petite que chaine2, et a < 0 */ }
4. Les instructions de contrôle Ce sont des instructions qui permettent notamment de faire des tests et des boucles dans un programme. Leur rôle est donc essentiel. Pour chaque type d’instruction de contrôle, on trouvera à la fin de la partie 4 les organigrammes correspondant aux exemples donnés. 4.1 Les instructions conditionnelles Les tests if
L’opérateur de test s’utilise comme suit : if (condition) {instruction ;} /* Si condition est vraie alors instruction est exécutée / if (condition) { instruction 1 ; } else { instruction 2 ;} } / Si expression est vraie alors l’instruction 1 est exécutée / / Sinon, c’est l’instruction 2 qui est exécutée / if (condition 1) { instruction 1 ; } else if (condition 2){ instruction 2 ; } else if (condition3){ instruction 3 ; } else { instruction 4 ; } / Souvent, on imbrique les tests les uns dans les autres */ Remarque : les instructions à exécuter peuvent être des instructions simples {a=b ;} ou un bloc d’instructions {a=b ; c=d ; m=pow(4,2),...}.
Si condition?
Instruction 1
Instruction 2
non
oui
L’expression est évaluée à chaque itération. Tant qu’elle est vraie, les instructions sont exécutées. Si dès le début elle est fausse, les instructions ne seront jamais exécutées. ATTENTION! Si rien ne vient de modifier l’expression dans les instructions, on a alors fait une boucle infinie : while (1) { instructions }. Boucle infinie Exemple d’utilisation de la boucle while: #include <stdio.h> main(){ float x=1.0, R=1.e5 ; while (x < R) { x = x+0.1*x ; printf("x=%f",x) ; } } La boucle do ... while
À la différence d’une boucle while, les instructions sont exécutées au moins une fois : l’expression est évaluée en fin d’itération. compteur=valeur_initiale
do { instructions ... ; incrémentation du compteur ;
} while ( condition_d’arret ) ;
Les risques des faire une boucle infinie sont les mêmes que pour une boucle while. Les instructions break , continue et goto. break fait sortir de la boucle. continue fait passer la boucle à l’itération suivante. Goto fait sauter à une adresse (référence dans le programme)
5. Les fonctions
Créer une fonction est utile quand vous avez à faire le même type de calcul plusieurs fois dans le programme,
mais avec des valeurs différentes. Typiquement, pour le calcul de l’intégrale d’une fonction mathématique f.
Comme en mathématique, une fonction prend un ou plusieurs arguments entre parenthèses et renvoie une valeur.
5.1 Déclaration
On déclare une fonction ainsi : Type nom_de_la_fonction( type1 arg1 , type2 arg2, ... , typen argn) { */ prototype */ déclaration variables locales ; instructions ; return (expression) ; } Type est le type de la valeur renvoyée par la fonction. type1 est le type du 1 er argument arg1 .... Les variables locales sont des variables qui ne sont connues qu’à l’intérieur de la fonction. expression est évaluée lors de l’instruction return (expression) ; c’est la valeur que renvoie la fonction quand elle est appelée depuis main().
La 1ere^ `ligne de la déclaration est appelée le prototype de la fonction. Exemple de fonction : float affine( float x ) { /* la fonction ’affine’ prend 1 argument réel x et renvoie un argument réel (ax+b)*/
int a,b ; a=3 ; b=5 ; return (ax+b) ; / valeur renvoyée par la fonction */ } On n’est pas obligés de déclarer des variables locales : float norme( int x, int y ){ /* la fonction ’norme’ prend 2 arguments entiers et renvoie un résultat réel / return (sqrt(xx+yy)) ; / sqrt est la fonction racine carree */ } On peut mettre plusieurs instructions return dans la fonction : float val_absolue( float x ) { if (x < 0) { return (-x) ; } else { return (x) ; } } Une fonction peut ne pas prendre d’argument, dans ce cas-là, on met à la place de la déclaration des arguments, le mot-clé void : double pi ( void ) { /* pas d’arguments */ return(3.14159) ; } Une fonction peut aussi ne pas renvoyer de valeur, son type sera alors void : void mess_err ( void ) { printf("Vous n’avez fait aucune erreur \n") ; return ; /* pas d’expression après le return */ } Appel de la fonction
Une fonction f() peut être appelée depuis le programme principal main() ou bien depuis une autre fonction g() à la condition de rappeler le prototype de f() après la déclaration des variables de main() ou g() : #include <stdio.h> main(){ int x ,y ,r ; int plus( int x, int y ) ; /* déclaration du prototype de la fonction plus(x,y)/ x=5 ; y=235 ; r=plus(x,y) ; / appel d’une fonction avec arguments / } int plus( int x, int y ){ / définition de la fonction plus(x,y)/ void mess( void ) ; mess_err() ; / appel d’une fonction sans arguments */ return (x+y)) ; } void mess( void ) { printf ("Vous n’avez fait aucune erreur\n") ; return ; }
int i,j,k;
for (i=0 ; i < taille1 ; i++){ //Première dimension for (j=0 ; j < taille2 ; j++){ //Deuxième dimension for (k=0 ; k < taille3 ; k++){ //troisième dimension tableau[i][j][k] = 0 ; } } }
Cas d’un tableau de caractères
Un tableau de caractères est en fait une chaîne de caractères. Son initialisation peut se faire de plusieurs
façons : char p1[10]=’B’,’o’,’n’,’j’,’o’,’u’,’r’ ; char p2[10]="Bonjour" ; /* initialisé par une chaîne littérale / char p3[ ]="Bonjour" ; / p3 aura alors 8 éléments */
ATTENTION! Le compilateur rajoute toujours un caractère ‘\0’ à la fin d’une chaîne de caractères. Il faut
donc que le tableau ait au moins un élément de plus que la chaîne littérale.
7. Les pointeurs 7.1 Stockage des variables en mémoire
Lors de la compilation d’un programme, l’ordinateur réserve dans sa mémoire une place pour chaque variable déclarée. C’est à cet endroit que la valeur de la variable est stockée. Il associe alors au nom de la variable l’adresse de stockage. Ainsi, pendant le déroulement du programme, quand il rencontre un nom de variable, il va chercher à l’adresse correspondante la valeur en mémoire. Pour les déclarations de variables suivantes on aura les résultats suivants :
main(){ int a=10; long n=24; float x=77.9; printf(" valuer a=%d adresse de a &a=%x \n",a,&a); printf(" valeur de n=%ld adresse de n &n=%x \n",n,&n); printf(" valeur de x=%.2f adresse de &x=%x \n",x,&x); system("pause"); return 0; }
24
10
&x=28ff
&n=28ff
&a=28ff
mémoire
main(){ int a=10; long n=24; float x=77.9; printf("\n\n"); printf(" valeur de a=%d adresse de a &a=%x \n",a,&a); printf(" (adresse de a)+1: &a+1=%x \n",&a+1); printf("\n"); printf(" valeur de n=%ld adresse de n &n=%x \n",n,&n); printf(" (adresse de n)+1 &n+1=%x \n",&n+1); printf("\n"); printf(" valeur de x=%.2f adresse de x &x=%x \n",x,&x); printf(" (adresse de x)+1 &n+1=%x \n",&n+1); printf("\n"); //printf("%d %c %s \n",i,cara,ch); system("pause"); return 0; }
Explication du schéma et résultat obtenu:
- Chaque case supporte une donnée codée sur 8 bits (1 octet)
- x est codé sur 4 octets et son adresse est (28ff3c), donc l’adresse de n sera (28ff3c)+(4)=(28ff40).
- n est codé sur 4 octets et son adresse est (28ff40), donc l’adresse de a sera (28ff40)+(4)=(28ff44).
7.2 Définition et déclaration d’un pointeur
Un pointeur est une variable qui a pour valeur l’adresse d’une autre variable : celle sur laquelle elle pointe! Un pointeur est toujours associé à un type de variable et un seul. Au moment de la déclaration, on détermine le type de variable pointé par le pointeur, en écrivant le type concerné, puis le nom du pointeur avec une * devant : int pta ; / la variable pta est un pointeur sur un entier/ int a ; / la variable a est un entier*/ l’écriture ptr=&a signifie que le pointeur ptr pointe vers l’adresse de a.
7.3 Opérateur d’adresse : &
Pour affecter l’adresse de la variable a au pointeur pta, on écrit l’instruction : pta=&a ;
Cet opérateur signifie donc adresse de.
**7.4 Opérateur d’indirection : ***
Cet opérateur, mis en préfixe d’un nom de pointeur signifie valeur de la variable pointée ou, plus simplement, valeur pointée.
int a=10 ; int ptint ; / declaration d’un pointeur sur un entier / ptint=&a ; / ptint pointe sur a / ptint=12 ; / la variable pointée par ptint reçoit 12/ printf("a=%d \n",a) ; /* affiche "a=12" */ En fait, manipuler ptint revient à manipuler a.
7.5 Mémoire et pointeurs On reprend l’exemple de la partie 7.1 en ajoutant un pointeur d’entier : int a=25 ; short b=58 ; int c=114 ; int *ptint ; ptint=&a ; Etat de la mémoire :
nom adresse^ valeur en décimal a bfbff000 25 b bfbff004 58 c bfbff006 114 ptint bfbff00f bfbff Exercices :
1. Ecrire un programme en C qui permet d’éliminer un caractère dans une chaine de caractères.
- Saisir 10 réels, les ranger dans un tableau. Calculer et afficher la moyenne et l'Écart-type.
- Saisir une matrice d'entiers 2x2, calculer et afficher son déterminant.
Place Réservée à b
mémoire
&a=(bfbff000)
&b=(bfbff004)
&c=(bfbff006)
&ptint=(bfbff00f)
00
58
14
25
00 00
00
01
00 00
Place Réservée à a
Place Réservée à c Poid faible de la valeur (bfbff000)
Note : Les expressions se situant dans une même case sont équivalentes. Au niveau de la mémoire, les éléments d’une colonne contiennent les adresses des éléments de la colonne qui est juste à sa droite.Voici l’état de la mémoire pour un tel exemple : nom Adresse valeur tab (bfbff000) 00 00 00 25 (bfbff004) 00 00 00 47 (bfbff008) 00 00 01 75 (bfbff00c) 00 00 21 74 pttab (bfbff010) bf bf f0 00 (bfbff014) bf bf f0 04 (bfbff018) bf bf f0 08 (bfbff01c) bf bf f0 0c
Pttab+i Pttab[i] *(Pttab+i) tab+i
*(Pttab[i]) **(Pttab+i) *(tab+i) tab[i]
Exemple int l1[4] = { 11 , 22 , 33 , 44 } ; int l2[3] = { 55 , 66 , 77 } ; int l3[1] = { 88 } ; int *pt[3] = { l1 , l2 , l3 } ; Les éléments de tab sont les adresses de tableaux ne comportant pas le même nombre d’éléments. pt est en fait un tableau dont les 3 lignes n’ont pas la même longueur.
Pointeur de pointeur pointeur Equivalence pt pt[0]≡l1 l1[0] ↔ pt[0][0] l1[1] ↔ pt[0][1] l1[2] ↔ pt[0][2] l1[3] ↔ pt[0][3] pt+1 pt[1]≡l2 l2[0] ↔ pt[1][0] l2[1] ↔ pt[1][1] l2[2] ↔ pt[1][2] pt+2 pt[2]≡l3 l3[0] ↔ pt[2][0]
Voici l’état de la mémoire pour cet exemple : nom Adresse valeur L1 (bfbff000) 00 00 00 11 (bfbff004) 00 00 00 22 (bfbff00 8 ) 00 00 00 33 (bfbff00c) 00 00 00 44 L2 (bfbff010) 00 00 00 55 (bfbff014) 00 00 00 66 (bfbff018) 00 00 00 77 L3 (bfbff01c) 00 00 00 88 pt (bfbff020) (bf bf f0 00) (bfbff024) (bf bf f0 10) (bfbff028) (bf bf f0 1c)
Explication : Les cases mémoire des variables a, b et c contiennent leur valeur. Celles de la variable
ptint contiennent l’adresse de la valeur pointée. En effet, la valeur stockée est (bfbff000), ce qui est bien l’adresse de a.
8.6 Exemple
Voici un petit exemple d’illustration : #include <stdio.h> main(){ float px ; float x=3.5 ; px=&x ; printf ("adresse de x : 0x%lx \n",&x) ; printf ("valeur de px : 0x%lx \n",px) ; printf ("valeur de x : %3.1f \n",x) ; printf ("valeur pointee par px : %3.1f \n",px) ; return 0 ; }
Le programme précédent affichera ceci à l’écran : L’adresse de x : 0xbfbffa3c La valeur de px : 0xbfbffa3c La valeur de x : 3. La valeur pointée par px : 3.
Séries d’Exercices :
- Ecrire un programme en c qui permet de:
- Lire un tableau de 20 réels
- Afficher les éléments de ce tableau
- Chercher et afficher un élément x dans ce tableau
- Calculer et afficher la moyenne et l’écart type des éléments de ce tableau.
- Trier ce tableau par ordre croissant
- Ré-afficher ce tableau trié
- Refaire l’exercice1 en utilisant des fonctions (Lire_Tableau, Afficher_Tableau, Moyenne, Ecart_type, Rechercher et Trier_Tableau).
