1 / 47

Introduction au C

Introduction au C. PRO -1027 Programmation Scientifique en C. 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)

wynona
Download Presentation

Introduction au C

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Introduction au C PRO-1027Programmation Scientifique en C • 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) • Préséance des opérateurs

  27. Structures des programmes en C (Opérateurs et expressions) • Préséance des opérateurs

  28. 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++

  29. 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 ; • }

  30. 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 • }

  31. 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;

  32. 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

  33. 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)

  34. 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)

  35. 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

  36. 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; • }

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

  38. 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 ; • }

  39. 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};

  40. 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

  41. 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

  42. 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

  43. 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.

  44. 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;}

  45. 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.

  46. 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

  47. 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;}}

More Related