Previous Next Contents




C-II : sommaire

C-II  1

Eléments lexicaux

  1. Séparateurs et commentaires
  2. Identificateurs
  3. Constantes littérales
  4. Mots réservés
  5. Directives du pré-processeur

C-II  2



Séparateurs et commentaires

C-II  3

Identificateurs

C-II  4

Constantes littérales

C-II  5

Mots réservés

C-II  6

Directives du pré-processeur

C-II  7

Déclarations
  1. Déclarations
  2. Définition vs. déclaration

C-II  8

Déclarations

[á class_allocñ] á typeñ ident {','ident['='á express.ñ]}';'

Ex :
register int r=0, c, d=1;
static int K;
char chaine[300] = "ceci est un exemple";
int fonc(char *, int);
int a;
... [instructions quelconques] ...
int b=0;
for (int i=0; i<10; i++) b += i*i;
// ATTENTION: i n'est pas locale au for
a = fonc(chaine, r);
...

C-II  9

Définition vs. déclaration (1)

C-II  10



Définition vs. déclaration (2)

Exemples de déclarations qui sont également des définitions
int monnumeroglobal=0;
static double pi = 3.14;
char* version = "Version 1.1";
extern int size = 128;
struct A { int a; };
static int prev(int i) {
   return ((i-1 < 0) ? size : i-1);
}
int next(int i) {return(i+1) % size;}

Exemples de déclarations qui ne sont pas des définitions
extern int monnumeroglobal;
extern char* version;
extern int size;
struct A;
extern int next (int i);
int prev (int i);

C-II  11



Définition vs. déclaration (3)

(cas 1) -- int foo = 3;
(cas 2) -- int foo;
(cas 3) -- extern int foo;
(cas 3) -- extern int foo = 3;

cas 1
: lors de la compilation, un espace mémoire est réservé et initialisé avec la valeur 3.
cas 2
: lors de la compilation, un espace mémoire est réservé. La valeur initiale est indéterminée.
cas 3
: la variable foo est déclarée. La réalité de sa définition sera prise en compte uniquement lors de l'édition de lien : recherche de sa définition dans l'ensemble des fichiers qui constituent le programme.
cas 4
: la variable foo est définie. Lors de l'édition de lien, on vérifiera qu'elle n'est pas définie par ailleurs dans un autre fichier constituant le programme.

C-II  12

Types
  1. Types élémentaires
  2. Booléens
  3. Constantes
  4. Pointeurs
  5. Références

C-II  13

Types élémentaires
Tailles limites :
--> limits.h pour les types entiers,
--> float.h pour les types réels.



C-II  14

Booléens

C-II  15

Constantes

C-II  16

Pointeurs
á typeñ '*' identificateur';'
int i,j;
int *iptr, k;
// iptr pointeur sur entier MAIS k entier

iptr = &i;
i = 5; // *iptr est égal à 5
(*iptr) = 6; // i a la valeur 6;
iptr = & j;

Remarque :  Le pointeur nil est 0 (NULL)
Attention : NULL!=NUL

C-II  17

Pointeurs et constantes

Trois cas sont possibles...

  1. Pointeur sur une valeur constante :
    const int a = 3, b = 5; // b est constant
    const int * pt1 = &a, * pt2 = &b;
    // *pt1 et *pt2 sont constants
    int const * pt3 = pt1; // Ecriture valide
    pt1 = &b; // Ok
    *pt1 = 7; // Erreur

  2. Pointeur constant sur une valeur non constante :
    int c = 3, d = 10;
    int * const pt2 = &c, * const pt3=&c;
    // pt2 et pt3 sont constants
    pt2 = &d; // Erreur
    *pt2 = 7; // Ok

  3. Pointeur constant sur une valeur constante :
    const int a = 3, const b = 5;
    const int * const pt3 = &a;
    pt3 = &b; // Erreur
    *pt3 = 7; //Erreur


C-II  18

Références (1)
á typeñ '&' nom '=' lvalue';'

C-II  19

Références (2)

C-II  20

Expressions et Opérateurs

  1. Définition
  2. Opérateurs arithmétiques
  3. Opérateurs d'incrémentation/décrémentation
  4. Opérateurs logiques
  5. Opérateur d'affectation
  6. Opérateurs relationnels
  7. Opérateurs d'accès aux objets

C-II  21

Expressions

C-II  22

Opérateurs arithmétiques

Opérateur Rôle Usage
+ addition (binaire) expr + expr + ...
     
- soustraction (unaire) - expr
- soustraction (binaire) expr - expr
     
* multiplication (binaire) expr * expr
     
/ division (binaire) expr / expr
     
% modulo (binaire) expr % expr


Fonctions supplémentaires disponibles dans la bibliothèque mathématique : pow, exp, log, sin, etc.
      fichier d'entête : <math.h>
      bibliothèque : libm.a

C-II  23

Opérateurs d'incrémentation/décrémentation

pile[x++] = val Û ì
í
î
pile[x] = val ;
x = x + 1 ;
val = pile[--x] Û ì
í
î
x = x - 1 ;
val = pile[x] ;
Ecrire ce qui se passe pour pile[++x] = val ; et val = pile[x--] ;.

C-II  24

Opérateurs bits à bits

Opérateur Rôle Usage
& Et op1 & op2
     
| Ou (inclusif) op1 | op2
     
^ Ou exclusif op1 ^ op2
     
~ Négation ~ op1
     
<< décalage à gauche (× 2) op1 << op2
     
>> décalage à droite (÷ 2) op1 >> op2

Ecrire les expressions pour tester :
- si le k-ième bit d'un entier est à 1,
- l'égalité du k-ième et i-ième bits d'un entier.

C-II  25

Opérateur d'affectation
int i,j;
i = 0;
j = i;


a = a + 2 ; Þ a += 2 ;
y = y & 0x0f ; Þ y &= 0x0f ;
x = x * (y + z) ; Þ x *= y + z ;

C-II  26

Opérateurs relationnels

Opérateur Rôle Usage
== égalité expr == expr
!= inégalité expr != expr
> stt supérieur expr > expr
>= stt supérieur ou égal expr >= expr
< inférieur expr < expr
<= inférieur ou égal expr <= expr
! non logique !expr
&& et logique expr && expr
|| ou logique expr || expr

C-II  27

Autres opérateurs

C-II  28

Opérateurs d'accès aux objets

Opérateur Rôle Usage
& adresse &expr
* contenu *expr
[ ... ] indexation expr[i]
. sélecteur de champ expr.x
-> sélecteur de champ expr->x
:: portée ::expr


Attention : de multiples rôles pour les symbôles '&' et '*' :

  Rôle
& référence dans une déclaration,
  opérateur logique ET dans une expression,
  opérateur adresse devant une variable.
* pointeur dans une déclaration,
  accés au contenu devant un pointeur,
  opérateur de multiplication dans une expression.

--> rôles mutuellement exclusifs.

C-II  29

Instructions de contrôle
  1. Instruction Conditionnelle
  2. Instruction de choix
  3. Instructions d'itérations
  4. Instructions de ruptures

C-II  30

Introduction

Deux types d'instructions
  1. Les instructions simples terminées par un ';'
  2. Les instructions composées utilisant { ··· }
    { ··· } est un bloc.
Structuration des instructions par
  1. instructions conditionnelles,
  2. instructions de choix,
  3. instructions d'itération.

C-II  31

Instruction conditionnelle
if '('á expressionñ')' á instruction1ñ
   [ else á instruction2ñ ]
Ou en cascade
if '('á expression1ñ')' ···
else
   if '('á expression2ñ')' ···
   else
      if '('á expression3ñ')' ···



C-II  32




Exemple d'instructions conditionnelles

#include <math.h>
// calcul des racines
...
double delta = b*b - 4*a*c;
if (delta < 0) cout << "pas de sol. ";
else if (delta == 0)
   cout << "rac. double " << b/(2*a);
   else {
      double rac = sqrt (delta);
      cout << "rac." << (-b+rac)/(2*a)
         "et" << (-b-rac)/(2*a));
   }
...

C-II  33

Instruction de choix

switch '('á expressionñ')' {
   [case á csteñ ':'] [á instructionñ]
      [break ';']
   [default ':' [á instruction ñ]]
}

switch(expression_entiere)
{
    case valeur1 : liste_instructions
    case valeur2 : liste_instructions
       ...
    case valeurN : liste_instructions
    default : liste_instructions             /* Facultatif */
}

C-II  34




Exemple d'instruction de choix

// Compter le nb voyelles, nb blancs ou TAB,
// et le nb des autres caractères.
int main (void)
{
   int nbv, nbb, nba, flag=1;
   char c;
   nbb = nba = nbv = 0;
   while (flag) {
      cin.get(c);
      if(cin.eof()) flag = 0; // end-of-file
      else {
         switch (c) {
         case 'a' : case 'e' :
         case 'i' : case 'o' :
         case 'u' : case 'y' : nbv++; break;
         case ' ' :
         case '\t': nbb++; break;
         default : nba++;
      } } }
   cout << nbv << ``voyelles, '' << nbb
      << `` blancs '' << nba << `` autres'';
}

C-II  35

Instructions d'itération



C-II  36




Exemple d'instructions d'itération
// Calcul de puissance ab par
// multiplications successives.
int puis( int a, int b)
{
   int p = 1;
   #ifdef SIMPLE
   for (int i = 0; i < b; i += 1) p = p * a;
   #else
   for (int i = 0; i < b;
         p *= a, i += 1) {;}
// Corps de boucle est l'instruction vide.
   #endif
   return p;
}
// Calcul de factorielle
int fact( int n)
{
   int i = n;
   while (n>=0) i *= --n;
   return i; }

C-II  37

Instructions de rupture

C-II  38




Exemple d'instructions de rupture
#include<stdio.h>
...
// écriture dans un tableau avec arrêt dès que
// le tableau est plein ou que fin d'entrée
   char tab[100];
   int i, c, j;
   for (i=0; i < 100; i++) {
      c = getchar() ;
      if (c == EOF) break;
      tab[i] = c; // c!= EOF
   }
// i a le nombre exact d'elts du tableau
...
for (j=0;j<i;j++) {
// traite toutes les entrées sauf
// celles commençant par #
   if (tab[j] == '#') continue;
   traite_val(tab[j]);
   }
   ...

C-II  39

Entrées/Sorties
  1. Entrées/Sorties en C
  2. Entrées/Sorties en C++

C-II  40

Entrées/Sorties en C

C-II  41

E/S en C : Fonctions de base

Ensemble de fonctions d'E/S sur stdin/stdout :
if (scanf("%f %f",&x,&y) != 2)
   printf("mauvaise lecture\n.");
else
   printf("x=%lf, y=%lf\n",x,y);

C-II  42






#include <stdio.h>
int lectecr1 (void) {
   int c; /* Noter def. comme int */
   c=getchar();
   while (c != EOF) {
      putchar(c); c=getchar();
}
return 0;
}
int lectecr2 (void) {
   int c;
   while ((c=getchar()) != EOF) putchar(c);
   return 0;
}

C-II  43

Entrée/sortie en C++

Extension des entrées/sorties standards du C par des classes : stream et iostream

C-II  44






Exemple
#include <iostream.h>
...
int a, b;
cout << "Entrez deux valeurs : ";
cin >> a >> b; // ! et non &a, &b
cout << a << " + " << b;
cout << " = " << a+b << endl;
...
Personne p;
cin >> p; // si redéfini
             // pour classe Personne
...





Previous Next Contents