SIF-1053 Architecture de ordinateurs

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:

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:

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 : e2 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 (Exemple d’utilisation des types)
#include <stdafx.h> const double pi = ; 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 = 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)

- X*=2 x/=2 ^ ~

//operateurs mathématiques (arithmetiques) int i = 13 , j = 5 , k ; double x = ; x = x + i * j ; // x = k = i % j ; // k = 3

//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)

//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!

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

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

//operateurs op= double x = 2.2; int i = 4 ; x += 1.1 ; // x = x += (i << 1) // i est d’abord decale de 1 a gauche // x =

//operateurs ++ ou -- int x = 5; int z = ++x; int y = x++; // z = 6 y = 6 et x = 7

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

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 conditionnelles char c ; if (c) { // si c != NULL bloc d’instructions executees } else // si c == NULL bloc d’instructions executees

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 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 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 de boucles (do…while) int i = 0; int a = 0; do { a = a + i; i = i + 1; } while ( i < 10)

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 de boucles (for)

Structures de boucles (for) int a = 0; for (int i = 0; i < 10; i++) // equivalent au while (condition) {} { a = a + i; }

Structures d’aiguillage (switch) switch (expression) { case const1 : instructions case const2 : … default : }

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

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

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.

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

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.

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

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

SIF-1053 Architecture de ordinateurs

Présentations similaires

Présentation au sujet: "SIF-1053 Architecture de ordinateurs"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

SIF-1053 Architecture de ordinateurs

Présentations similaires

Présentation au sujet: "SIF-1053 Architecture de ordinateurs"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back