Introduction au C

1. Introduction au C SIF-1053Architecture de ordinateurs • Sujets • Structures des programmes en C • Types, instructions, opérateurs • Tableaux (matrices) • Chaînes de caractères • Fonctions • Références: • http://www-ipst.u-strasbg.fr/pat/program/tpc.htm • http://fr.wikipedia.org/wiki/C_(langage) • http://www.commentcamarche.net/c/cintro.php3 • http://www-rocq.inria.fr/codes/Anne.Canteaut/COURS_C/ • http://www.iu.hio.no/~mark/CTutorial/CTutorial.html

2. Introduction au C • Le langage C possèdent deux caractéristiques : Les déclarations et les instructions. • Les déclarations permettent de définir les objets qui sont manipulés par les instructions du programme. • Les instructions permettent de spécifier les opérations à effectuer sur ces objets. • Les déclarations spécifient donc des objets. • Les instructions spécifient des actions. • Dans le langage C il n’est pas nécessaire contrairement aux langages ADA ou PASCAL, de déclarer les objets dans la partie déclarative. En C, les objets (variables et constantes) sont déclarés à n’importe quel endroit du programme. Cependant, il est important que l’objet soit déclaré avant l’instruction qui manipule cet objet.

3. Structures des programmes en C • #include <iostream.h> • const int compteur = 5; • int ecrire (int val); • int produit (int val); • int var_glob = 10; • main ( ) • { • int somme = 0; • for (int i = 0 ; i < compteur ; i++) • somme = somme + (i + var_glob); • ecrire ( somme ); • cout << "\nLe produit est : " << produit (1) << "\n"; • } • int ecrire (int val) • { • cout << "\nLa somme est: " << val << "\n"; • } • int produit (int val) • { • int prod = val; • for (int i = 1 ; i <= compteur ; i++) • prod = prod * (i * var_glob); • return prod; • } Exécution: La somme est: 60 Le produit est:12000000

4. Structures des programmes en C (Identificateurs) • Un identificateur peut être formé d’un nombre illimité de caractères alphanumériques ainsi que du caractère “ underscore ( _ ) ”. • Le premier caractère est soit une lettre ou ( _ ). Il est déconseillé d’utiliser le caractère ( _ ) car il peut créer des interférences avec les librairies. • Les lettres en minuscules et en majuscules sont différentes. Un identificateur var est différent d’un identificateur Var.

5. Structures des programmes en C (Identificateurs, constantes) • Les mots réservés suivants ne peuvent être utilisés comme noms d’identificateurs : • asm, auto, break, case, char, class, const, continue, default, delete, do, double, else, enum, extern, float, for, friend, goto, if, inline, int, long, new, operator, overload, private, protected, public, register, return, short, sizeof, static, struct, switch, this, typedef, union, unsigned, virtual, void, while. • Constantes • entières : 1234 • réelles : 123.45 123.4e2 • caractères : ‘a’ ‘;’ ‘1’ • chaînes de caractères : "PRO1027"

6. Structures des programmes en C (Caractères spéciaux) • \b retour arrière (backspace) • \f saut de page (formfeed) • \n nouvelle ligne (newline) • \r retour chariot (return) • \t tabulation horizontale • \v tabulation verticale • \\ le caractère ‘\’ • \’ le caractère ‘’’ • \" le caractère ‘"’ • \0 le caractère NULL

7. Structures des programmes en C (Commentaires) • #include <iostream.h> • const int compteur = 5; • int ecrire (int val); • int produit (int val); • int var_glob = 10; • /* Ce programme calcul: • La somme successive somme = somme + (i + var_glob) • La multiplication prod = prod * (i * var_glob) • */ • // somme: est une variable entière

8. Structures des programmes en C (Types de base)

9. Structures des programmes en C (Taille de chaque type)

10. Structures des programmes en C (Intervalle de valeurs de chaque type)

11. Structures des programmes en C (Intervalle de valeurs de chaque type)

12. Structures des programmes en C (Intervalle de valeurs de chaque type)

13. Structures des programmes en C (Exemple d’utilisation des types) • #include <iostream.h> • const double pi = 3.1416 ; • main ( ) • { • long l = 62456 ; // comme long int • short i = 23 ; // comme short int • float x = 2 * pi ; • char c = ‘a’ , d = ‘+’ ; • cout << "x = " << x ; • cout << "\ni = " << i << " , l = " << l ; • cout << "\nc = " << c ; • } Sorties: x = 6.2832 i = 23,l = 62456 c = a

14. Structures des programmes en C (Instructions) • Chaque instruction en C se termine par un délimiteur de fin d’instruction qui est le point-virgule. • L’instruction la plus simple est l’affectation. Elle peut être simple ou multiple : • i = 4 ; • j = k = l = 12 ; • Une structure de contrôle comme une boucle ou une conditionnelle s’adresse souvent qu’à une seule instruction. • Il est possible de regrouper plusieurs instructions en un groupe d’instructions délimité par les accolades { }.

15. Structures des programmes en C (Instructions) • #include <iostream.h> • main ( ) • { • int i = 4, j = 5 ; // variables preinitialisees • while ( i > 0) • { • int j = 8; • j = j + 1 ; • cout << "\ni = " << i ; • cout << " j = " << j ; • i = i - 1; • } • cout << "\ni = " << i ; • cout << " j = " << j ; • } Sorties: i=4 j=9 i=3 j=9 i=2 j=9 i=1 j=9 i=0 j=5

16. Structures des programmes en C (Opérateurs et expressions)

17. Structures des programmes en C (Opérateurs et expressions) X-=2 - X*=2 x/=2 ^ ~

18. Structures des programmes en C (Opérateurs et expressions) • //operateurs mathématiques (arithmetiques) • int i = 13 , j = 5 , k ; • double x = 12.45 ; • x = x + i * j ; // x = 77.45 • k = i % j ; // k = 3

19. Structures des programmes en C (Opérateurs et expressions) • //operateurs relationnels • int i = 0 , j = 6 ; • if ( i <= j ) // test est vrai • ….. • k = (i > j) ; // k = 0 • k = (i != j) ; // k = 1 • if ( i ) // faux! • if ( j ) // vrai (!= 0 est considere vrai)

20. Structures des programmes en C (Opérateurs et expressions) • //operateurs logiques • int i = 0 , j = 6 ; • if (( i < j ) && (j < 10)) // vrai! • if ( i || j ) // vrai! • if ( i && j ) // faux! • if ( !i ) // vrai! • if ( ! (i < j )) // faux!

21. Structures des programmes en C (Opérateurs et expressions) • //operateurs bit à bit • int i = 13, j = 14; • int k = i & j; // k = 12 • int l = i | j; // l = 15 • k = i << 1; // k = 26 • l = i >> 2; // l = 3 • k = i ^ j; // k = 3

22. Structures des programmes en C (Opérateurs et expressions) • //operateurs d’affectation dans des expressions • a = 10 ; b = 2 ; c = 4 ; • if ( c > ( a = b) ) // vrai! (a=b donne 2) • int a = 1; • while ( a = 1) // DANGER boucle infinie • { • a = a – 1; • }

23. Structures des programmes en C (Opérateurs et expressions) • //operateurs op= • double x = 2.2; • int i = 4 ; • x += 1.1 ; // x = 2.2 + 1.1 • x += 4.4 + (i <<= 1) // i est d’abord decale de 1 a gauche • // x = 3.3 + 4.4 + 8

24. Structures des programmes en C (Opérateurs et expressions) • //operateurs ++ ou -- • int x = 5; • int z = ++x; • int y = x ++; // z = 6 y = 6 et x = 7

25. Structures des programmes en C (Opérateurs et expressions) • Préséance des opérateurs • Visibilité : : • Primaires () [ ] -> • Unaires ! ~ ++ -- + - * & sizeof new delete conversion de type • Arithmétiques * / % • Arithmétiques + - • Décalages << >> • Comparaisons < <= > >= • Comparaisons == != • Bit à bit & • Bit à bit ^ • Bit à bit | • Logiques && • Logiques || • Affectations = op= a + b % c * d  (a + ((b % c) * d)) 3 2 1

26. Structures des programmes en C (Opérateurs et expressions) • Conversion de type (cast) • int i = 12 ; • double x = 4 ; • x = x + i ; // i devient double avant de faire le + • unsigned k = 4 ; • int l = 5 ; • k = l + k ; // l devient unsigned avant de faire le + • int i = 3 ; • float x ; • x = (i / 2) * 3.14 ; // x = 3.14, i/2 = 1 division entiere • x = ((float) i / 2) * 3.14 ; // en C • x = (float (i)/ 2) * 3.14 ; // en C++

27. Structures des programmes en C (Structures de contrôle) • Structures conditionnelles • if (condition) • bloc1 d’instructions de la condition VRAI • else • bloc2 d’instructions de la condition FAUX • Exemple: • if (( x > 0) && (z != 100)) • y = 8 ; • else • { • x = 15 + z; • z = y - 1 ; • }

28. Structures des programmes en C (Structures de contrôle) • Structures conditionnelles • char c ; • if (c) • { • // si c != NULL bloc d’instructions executees • } • else • { • // si c == NULL bloc d’instructions executees • }

29. Structures des programmes en C (Structures de contrôle) • Structures conditionnelles • int a = 9 , b = 6 ; • if ( a & b ) // a & b == 0 • cout << a ; • else • cout << b; // affichage de b • if (a && b ) // a && b == VRAI • cout << a; // affichage de a • else • cout << b;

30. Structures des programmes en C (Structures de contrôle) • Structures de boucles (while) • while (condition) {bloc d’instructions} • int i = 0; • int a = 0; • while ( i < 10) • { • a = a + i; • i = i + 1 • } // a == 45 et i == 10 a la fin du while (i<10) est VRAI

31. Structures des programmes en C (Structures de contrôle) • Structures de boucles (do…while) • Dans la boucle while le test est fait en début de boucle. • Dans la boucle do … while le test est fait en fin de boucle • Dans la boucle do … while le bloc d’instructions est exécuté au moins une fois. • do { • bloc d’instructions } • while (condition)

32. Structures des programmes en C (Structures de contrôle) • Structures de boucles (do…while) • int i = 0; • int a = 0; • do • { • a = a + i; • i = i + 1; • } • while ( i < 10)

33. Structures des programmes en C (Structures de contrôle) • Structures de boucles (for) • for (expr1 ; expr2 ; expr3) • { bloc d’instructions } • expr1: correspond généralement à la valeur initiale de l’indice de boucle • expr2: correspond à la condition d’arrêt de la boucle • expr3: variation de l’indice de boucle

34. Structures des programmes en C (Structures de contrôle) • Structures de boucles (for) • int a = 0; • for (int i = 0; i < 10; i++) // equivalent au while (condition) {} • { • a = a + i; • }

35. Structures des programmes en C (Structures de contrôle) • Structures d’aiguillage (switch) • switch (expression) • { • case const1 : • instructions • case const2 : • instructions • … • default : • instructions • }

36. Structures des programmes en C (Structures de contrôle) • Structures d’aiguillage (switch) • switch ( c) • { • case ‘a’ : x = 0 ; • y = 0 ; • break ; // si le break est enleve, x et y == 1 • case ‘b’ : • case ‘c’ : x = 1 ; • y = 1 ; • break ; • default : x = 2 ; • y = 2 ; • }

37. Structures des programmes en C (Tableaux, matrices) • Déclaration d’un tableau de 4 éléments (vecteur de 4 entiers): • int vec[4]; • Accès aux éléments d’un tableau: vec[0], vec[1], vec[2], vec[3] • Déclaration d’un tableau de 6 éléments (matrice de 2 lignes et 3 colonnes) placés en mémoire de façon linéaire ligne par ligne: mat[0][0], mat[0][1], mat[0][2], mat[1][0], mat[1][2], mat[1][2]: • int mat[2][3]; • Initialisation et définition d’un tableau de 3 entiers: • int vec2[ ]={1,2,3};

38. Structures des programmes en C (Chaînes de caractères) • Une chaîne de caractères est stockée dans un tableau de "char". • Pour permettre l’utilisation de plusieurs fonctions de gestion de chaînes de caractères il faut compléter une chaîne de caractères avec le caractère NULL ('\0'). • char x[]="PRO1027"; // x est un tableau de 8 caractères • // x[7]=='\0' x[7]==0

39. Structures des programmes en C (Fonctions) • Déclaration • type-retour nom-fonction (type1 param1, type2 param2, …) • float fct (int i, float x) // valeur de retour reelle, 2 arguments • void fct1 (int i) // sans valeur de retour, un argument • int fct2 () // fonction sans paramètre

40. Structures des programmes en C (Fonctions) • double fsin (double) ; //prototype de la fonction fsin() • … • int i = 1 ; • double x ; • x = fsin (i) ; // appel a la fonction fsin() • // conversion automatique de i en un double

41. Structures des programmes en C (Fonctions) • Passage de paramètres • Par défaut le passage de paramètre se fait par valeur. • Cela signifie que le paramètre est une variable locale de la fonction, • Si la valeur de l’argument est changé dans la fonction, elle le sera que localement (sur la pile). • La valeur de la variable passée en argument ne change donc pas de valeur au niveau du programme appelant.

42. Structures des programmes en C (Fonctions) • Passage de paramètres • #include <iostream.h> • int valeur-positive (int val); • void main ( ){ • const int val1 = -100; • int pos1 = valeur-positive(val1); • cout << pos1 ; // affichage de 0 • const int val2 = 600; • int pos2 = valeur-positive(val2) ; • cout << pos2 ;} // affichage de 1 • int valeur-positive (int n){ • if (n > 0) • return 1; • else • return 0;}

43. Structures des programmes en C (Fonctions) • Passage de paramètres par adresse (référence) • Ce type de passage de paramètres utilise des variables de type référence (pointeur). • Une variable de type référence est une variable contenant l’adresse d’une autre variable (adressage indirect). • Cette variable doit être initialisée lors de sa déclaration avec l’adresse dont elle est la référence. • L’affectation est donc définitive.

44. Structures des programmes en C (Fonctions) • Passage de paramètres par adresse (référence) • Type & nom = nom de variable int i ; int & j = i ; // j pointe sur i, j fait reference a i i = 10; j++ ; cout << i; // i == 11

45. Structures des programmes en C (Fonctions) • Passage de paramètres par adresse (référence) • #include <iostream.h> • int valeur-positive (int val, int & valref); • void main ( ){ • const int val1 = -100; • int val; • int pos1 = valeur-positive(val1, val); • cout << val ; // affichage de -200 • const int val2 = 600; • int pos2 = valeur-positive(val2, val) ; • cout << val ;} // affichage de 700 • int valeur-positive (int n, int & valref){ • if (n > 0) • {valref = n + 100; return 1} • else • {valref = n – 100; return 0;}}