introduction au c
Download
Skip this Video
Download Presentation
Introduction au C

Loading in 2 Seconds...

play fullscreen
1 / 45

Introduction au C - PowerPoint PPT Presentation


  • 94 Views
  • Uploaded on

Introduction au C. SIF-1053 Architecture 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)

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Introduction au C ' - dora


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
introduction au c
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
introduction au c1
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
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

structures des programmes en c identificateurs
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
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
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
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
structures des programmes en c exemple d utilisation des types
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

structures des programmes en c instructions
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 instructions1
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

structures des programmes en c op rateurs et expressions2
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 expressions3
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 expressions4
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 expressions5
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 expressions6
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 expressions7
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 expressions8
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 expressions9
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 expressions10
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 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 ;
  • }
structures des programmes en c structures de contr le1
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 le2
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;
structures des programmes en c structures de contr le3
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 le4
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 le5
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 le6
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 le7
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 le8
Structures des programmes en C (Structures de contrôle)
  • Structures d’aiguillage (switch)
  • switch (expression)
  • {
  • case const1 :
  • instructions
  • case const2 :
  • instructions
  • default :
  • instructions
  • }
structures des programmes en c structures de contr le9
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 tableaux matrices
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
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
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 fonctions1
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 fonctions2
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 fonctions3
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;}
structures des programmes en c fonctions4
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 fonctions5
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

structures des programmes en c fonctions6
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;}}
ad