SIF-1053 Architecture de ordinateurs Introduction au 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

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.

Structures des programmes en C #include <stdafx.h> const int compteur = 5; void ecrire (int val); int produit (int val); int var_glob = 10; void main ( ) { int somme = 0; for (int i = 0 ; i < compteur ; i++) somme = somme + (i + var_glob); ecrire ( somme ); printf ("\nLe produit est : %d\n", produit (1)); } void ecrire (int val) printf ("\nLa somme est: %d\n", val); 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

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.

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"

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

Structures des programmes en C (Commentaires) #include <stdafx.h> const int compteur = 5; void 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

Structures des programmes en C (Types de base) Description int entier float réel simple précision double réel double précision char caractère

Structures des programmes en C (Taille de chaque type) Dimension (octets) bool 1 char, unsigned char, signed char short, unsigned short 2 int, unsigned int 4 long, unsigned long float double 8 long double

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

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

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

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

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 { }.

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

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

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

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

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)

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!

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

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

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

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

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

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

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 ; { x = 15 + z; z = y - 1 ; }

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

Structures des programmes en C (Structures de contrôle) Structures conditionnelles int a = 9 , b = 6 ; if ( a & b ) // a & b == 0 (faux: 1001 & 0110 == 0000) printf("%i", a ) ; else printf("%i", b ); // affichage de b if (a && b ) // a && b == VRAI printf("%i", a ); // affichage de a printf("%i", b );

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

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)

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)

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

Structures des programmes en C (Structures de contrôle) Structures de boucles (for)

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

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

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

Structures des programmes en C (Entrée) Entrée de données (scanf)

Structures des programmes en C (Entrée) Entrée de données (scanf)

Structures des programmes en C (Entrée) Entrée de données (scanf)

Structures des programmes en C (Entrée) Entrée de données (scanf)

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

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

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

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

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.

Structures des programmes en C (Fonctions) Passage de paramètres #include <stdafx.h> int valeur_positive (int val); void main ( ){ const int val1 = -100; int pos1 = valeur_positive(val1); printf("%i\n", pos1 ); // affichage de 0 const int val2 = 600; int pos2 = valeur_positive(val2) ; printf("%i\n", pos2 ); } // affichage de 1 int valeur_positive (int n){ if (n > 0) return 1; else return 0;}

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.

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++ ; printf("%i", i); // i == 11

Structures des programmes en C (Fonctions) Passage de paramètres par adresse (référence) #include <stdafx.h> int valeur_positive (int val, int & valref); void main ( ){ const int val1 = -100; int val; int pos1 = valeur_positive(val1, val); printf("%i", val ); // affichage de -200 const int val2 = 600; int pos2 = valeur_positive(val2, val) ; printf("%i", 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;}}