Le langage C_C++ by hcj

VIEWS: 82 PAGES: 24

									                    Le langage C/C++




         Méthode et outils pour la programmation




                   Françoise Greffier




Langage C/C++             Page 1
                               Le langage C/C++
Types prédéfinis et opérateurs

Les types prédéfinis
                     char      caractère
                     short     entier court
                     int       entier
                     long      entier long
                     float     nombre en virgule flottante
                     double    virgule flottante en double précision
                     bool      booléen dont les valeurs sont true et false

Les opérateur arithmétiques
                    +         addition
                    -         soustraction
                    *         multiplication
                    /         division
                    %         reste de la division entre 2 entiers (modulo)

Les opérateurs de comparaison
                    ==                     égalité
                    !=                     différence
                    <                      inférieur strictement
                    >                      supérieur strictement
                    <=                     inférieur ou égal
                    >=                     supérieur ou égal

Les opérateur logiques
                    &&                     Et
                    II                     Ou
                    !                      Non


Type prédéfini : chaîne de caractères
Le langage C++ comprend une classe string prédéfinie
Cette classe offre de nombreuses méthodes permettant de manipuler les chaînes de
caractères : concaténation, position d’un caractère donné…

L’opérateur d’affection

<Variable> = <Expression>; affecte à la variable la valeur de l’expression
Exemple : i = i + 1; / / incrémentation

Autre formulation :
<Variable> <Opérateur> = <Expression>
où <Opérateur> est en général un opérateur arithmétique.
Exemple : i = i + 1; peut aussi s’écrire i+=1;




Langage C/C++                               Page 2
Les opérateurs sur les flots
Les opérations d’entrée/sortie
La bibliothèque C++ offre des flux (ou flot) pour gérer les opérations d’entrée (saisie) et
de sortie (édition).
Ces flux sont des objets.
Le flux d’entrée est appelé cin
Le flux de sortie est appelé cout
Ces flux sont définis dans la bibliothèque appelée iostream
L’instruction : #include <iostream.h> permet de les utiliser.

Edition
Les informations sont redirigées sur le flux.
Opérateur de redirection noté <<
Exemple d’édition :
  int a = 2;
  cout << a+4;             //6 est affiché

Exemple d’édition :
  cout <<"X = ";
  cout << 5;
  qui peut aussi s’abréger en :   cout << "X =" << 5;

Saisie
Les informations sont lues sur le flux.
Opérateur de redirection noté >>
Exemple de saisie :
  float v;
  cout << "Donnez la valeur de pi : ";
  cin >> v;       //une valeur entrée au clavier définit la variable v



Notations de constantes
                e           Nombre flottant (0.314 x 10+1)
      0.314 +01
      12                    Entier exprimé en décimal (base 10)
      06                    Entier exprimé en octal (base 8)
      Oxf1                  Entier exprimé en hexadécimal (base 16)
      ‘x’                   Caractère x entre apostrophes
      "Bonjour"             Chaîne de caractères
      ‘\n’                  Caractère de passage à la linge
      ‘\t’                  Caractère de tabulation
      ‘\0’                  Caractère NULL




Langage C/C++                            Page 3
Déclaration de constantes et de variables
syntaxe des déclarations
Pour une variable :<type > <Identificateur1>,…,<Identificateurn>;
Pour une constante : const <Type> <Identificateur = <Expression>;

Exemples
                const float Pi = 3.14;   // déclaration d’une constante flottante
                char c;                  //variable de type caractère
                int i, j, k;             // i, j, k sont trois variables de type int
                int i, j = 0, k = 1;     // exemple d’initialisation de variables

Exemple de programme

   # include <iostream.h>

   int main (void)
   {
   int Nombre1, Nombre2, Somme;
      cout << "Entrez le premier nombre : ";
      cin >> Nombre1;
      cout << "Entrez le deuxième nombre : ";
      cin >> Nombre2;
      somme = Nombre1 + Nombre2;
      cout <<"la somme est égale à : "<< somme;
      return 0;
   }

Un bloc d’instructions est toujours délimité par des accolades { }.
Toute fonction main comprend un bloc d’instructions.

Exercice Coder un programme ayant cet effet : après avoir souhaité la bienvenue à
l’utilisateur, lui demander son année de naissance puis afficher son âge cette année.




Langage C/C++                            Page 4
Les structures de contrôle alternative

   Choix simple

if (<Expression>)                      if         (<Expression>)
          <Bloc1>                                  <Bloc1>
                                       else
                                                  <Bloc2>
Sémantique
L’expression est évaluée. Si sa valeur est non nulle (elle est considérée comme vraie),
alors c’est le Bloc1 qui est exécuté, sinon c’est le Bloc2 (s’il existe) qui est exécuté.

Exemple

    #include <iostream.h>

    int main (void)
    {
         unsigned int e;
       cout << "Entrez un nombre entier positif non nul : ";
       cin >> e;
       if (e % 2 = = 0)
              cout <<" nombre pair !\n";
       else
             cout <<" nombre impair !\n";

        return 0 ;
    }


Exercice Coder un programme ayant cet effet : afficher si une lettre de l’alphabet saisie
est une voyelle ou une consonne. Si l’utilisateur entre autre chose qu’une lettre
minuscule ou majuscule alors afficher un message signalant le problème de saisie.




Langage C/C++                            Page 5
   Le choix multiple

switch (<Expression>)
{
   case <Valeur1> : <Instructions>
     break;
        . . .

     case <Valeurn> : <Instructions>
     break;
default : <Instructions>

Sémantique
L’expression est évaluée. Sa valeur est comparée aux différentes valeurs successives
associées aux cas. Lorsqu’il y a égalité, les instructions associées sont exécutées. Si la
dernière instruction est un break, on exécute l’instruction qui suit le switch sinon on
exécute les instructions associées aux cas suivant. Lorsqu’aucune égalité n’est détectée,
on exécute les instructions associées à default.

Exemple

    #include <iostream.h>
    int main ()
    {
    char c;
    cout << "Le langage C++ vous semble facile à apprendre (O/N) ?";
    cin >> c;
    switch(c) {
         case ‘o’ :       ;
         case ‘O’ :       cout << "Bravo !\n";
                          break;
         case ‘n’ :       ;
         case ‘N’ :       cout <<" Courage !\n";
                          break;
         default :        cout <<"Erreur de saisie \n";
       }
    return 0;
    }

Exercice Coder un programme ayant cet effet : deux nombres entiers sont saisis, puis
est affichée leur somme, différence ou produit, selon le choix de l'utilisateur.




Langage C/C++                           Page 6
ITERATIONS

FORME GENERALE

while(<Expression Booléenne :P>){

        // bloc
}

// non P


Tant Que <Condition> Faire <Instructions>
Sémantique
1. : la condition est évaluée.
2. : Si sa valeur est non nulle (vrai), le bloc est exécuté puis on revient à l’étape 1.
     Si l’expression est nulle (fausse), on passe à l’instruction qui suit le bloc.

Exemple

#include <iostream.h>
int main (void)
{
     int Nombre, Somme = 0;
     cout <<"Entrez un nombre entier : ";
     cin >> Nombre;
     while (Nombre !=0){
           Somme +=Nombre; //Somme=Somme+Nombre
           cout <<"Entrez u nombre entier : ";
           cin >> Nombre;
     }
     if (somme == 0)
           cout <<"\n Suite vide ";
     else
           cout <<"\Somme = " <<Somme << ’\n’;
return 0;
}

Exemple d'exécution
Entrez un nombre entier : 1
Entrez un nombre entier : 2
Entrez un nombre entier : 3
Entrez un nombre entier : 4
Entrez un nombre entier : 0

Somme = 10


Exercice Coder un programme ayant cet effet : demander à l'utilisateur de saisir un
nombre pair. Chaque fois que la saisie n'est pas un nombre pair un message indique
l'erreur de saisie et demande de recommencer.




Langage C/C++                             Page 7
ITERATION REPETER

   Faire <Instructions> TantQue <Condition>
    do
    {
        // bloc
    }
    while(<Expression Booléenne:P>);
    // non P

Sémantique
1. Le bloc est exécuté.
2. La condition est évaluée.
   Si sa valeur est non nulle (vrai), on revient à l’étape 1.
   Si l’expression est nulle (fausse), on passe à l’instruction qui suit le bloc.

Exemple

#include <iostream.h>
const int seuil=100;
int main (void)
{ int nombre,cardinal=0,somme = 0;
do
     {
     cout <<"\n Entrez un nombre entier : ";
     cin >> nombre;
     somme+=nombre;
     cardinal+=1;
     }
while (somme < = seuil);

cout <<"\n Cardinal de la suite : "<<cardinal;

return 0;
}
Exemple d'exécution
Entrez un nombre entier : 50
Entrez un nombre entier : 25
Entrez un nombre entier : 5
Entrez un nombre entier : 32


Cardinal de la suite : 4




Langage C/C++                              Page 8
BOUCLE POUR

Pour <Variable>variant de <Expression>à <Expression> par pas de <Expression>


                     Syntaxe                                Sémantique

for (<E1>; <E2>; <E3>)                        <E1>;           // initialisation
    {                                         while (<E2>){    //test d’arrêt
    <Instructions>
    }                                           <Instructions>
                                                <E3>;    //progression   itération
où <E1>; <E2>; <E3> sont des
expressions                                     }


Exemple 1 :
On additionne
un nombre donné de valeurs

#include <iostream.h>
int main (void)
{
int nombre, maximum, ind, somme =0;
cout << "Nombre d’éléments :";
cin >> maximum;
for (ind = 1; ind <= maximum; ind += 1)
           {
                cout<<"Entrez un nombre entier : ";
                cin >> nombre;
                somme += nombre;
        }
cout << "\n Somme = "<<somme;
return 0;
}

Exemple d'exécution
Nombre maximum d’éléments à
  lire : 4
Entrez un nombre entier : 1
Entrez un nombre entier : 2
Entrez un nombre entier : 3
Entrez un nombre entier : 4

Somme = 10




Langage C/C++                        Page 9
Exemple 2 :
exemple 1, en s’arrêtant à l'apparition de la valeur 0

 #include <iostream.h>
 int main (void)
 {
 int nombre = -1, maximum, ind, somme =0;
 cout << "Nombre maximum d’éléments à lire : ";
 cin >> maximum;

 for(ind = 1;(nombre !=0)&&(ind <= maximum);ind+= 1)
        {
 cout << "Entrez un nombre entier : ";
 cin >> nombre;
 somme += nombre;
         }
 cout << "\n Somme = " <<somme;

 return 0;
 }


 Exemple d'exécution
 Nombre maximum
 d’éléments à lire : 4
 Entrez un nombre entier : 1
 Entrez un nombre entier : 2
 Entrez un nombre entier : 0

 Somme = 3




 Exercice Coder un programme ayant cet effet : afficher les N premières valeurs de la
 fonction xi. x est un nombre réel saisi. N est une constante.

 Exercice Coder un programme ayant cet effet : calculer la somme de deux entiers en
 utilisant pour seules opérations arithmétiques : +1. Les deux entiers sont saisis.




 Langage C/C++                         Page 10
LES TABLEAUX

But
Gérer N données de même type ordonnées par rang.
Exemple : en calcul scientifique, un vecteur ou une matrice seront représentés par un tableau.
Remarque
En C un tableau n’est pas un constructeur de type. Il permet simplement de réserver un
espace mémoire de N éléments de même type.
Syntaxe
 Déclaration :
   <Type> <Identificateur> [<Nombre d’élements>] … [<Nombre d’élements>];

    Exemple : int Vecteur [10];
    //Déclaration d’un tableau nommé Vecteur de 10 éléments de type entier.
    // Les rangs sont numérotés de 0 à 9.

   Utilisation :
    <Identificateur> [ <Expression] … [ <Expression];

    Exemple : Vecteur[8]= Vecteur[6] + Vecteur[7];

Exemple :
Stocker Max éléments pour en calculer la moyenne

#include <iostream.h>
const int Max =5 ; // constante Max
int main (void)
{
  int ind, somme = 0, nombre;
  int elements [Max];
for (ind = 0; ind <Max; ind += 1)
{
     cout << "Entrez un nombre entier: ";
     cin >> nombre;
     elements[ind] = nombre;
}
for (ind =0; ind <Max; ind += 1)
{
  somme += elements[ind];
}
cout<<"\n Moyenne = "<< somme/Max <<’’\n’’;
return 0;


Entrez un       nombre   entier:    1
Entrez un       nombre   entier:    0
Entrez un       nombre   entier:    2
Entrez un       nombre   entier:    5
Entrez un       nombre   entier:    2
Moyenne =       2



Exercice Coder un programme ayant cet effet : saisir deux vecteurs de dimension N
puis les comparer. N est une constante.

Langage C/C++                                 Page 11
Déclaration des variables et réservation de Mémoire

La mémoire de l’ordinateur est une suite de cases de même taille numérotées de 0 à M.
Ces numéros (ou indice) constituent les adresses des cases.
La déclaration d’une variable permet au compilateur de déterminer, à partir de son type,
la place mémoire nécessaire pour contenir les valeurs associées à cette variable.
Les variables déclarées consécutivement sont généralement placées consécutivement
en mémoire.


int i;
char Lettres[6];
int k=1;

Mémoire statique             Contenu             Adresses

                                                     0
                                                     1
                                                     2
                i               ?                    3
                Lettres[0]
                Lettres[1]
                Lettres[2]
                Lettres[3]
                Lettres[4]
                Lettres[5]
                K               1



                                                     M-2
                                                     M-1
                                                     M




Attention aux erreurs de manipulation dans les indices de tableaux. Par exemple
Lettres[6]=’z’; place une valeur dans l'espace mémoire destiné initialement à K.




Langage C/C++                          Page 12
LES FONCTIONS

Syntaxe de déclaration d’une fonction
         <Type> <Identificateur> (<Paramètres>)
                         <Bloc>

Exemple
#include<iostream.h>

int addition (int, int);
//est retournée : somme des 2 arguments
int soustraction (int, int);
//est retournée : différence des 2 arguments

   int main (void)
   {
   int nb1,nb2;
   char choix;
   cout <<"Entrez un premier nombre :";
   cin>>nb1;
   cout <<"Entrez un deuxième nombre : ";
   cin>>nb2;
   cout <<"\n 1 : addition";
   cout <<"\n 2 : soustraction\n";
   cout <<"Votre choix ? ";
   cin >> choix;
   switch (choix)
       {
      case '1' : cout << addition (nb1,nb2);
                         break;
   case '2' : cout << soustraction (nb1,nb2);
                         break;
   default : cout << "erreur de saisie\n";
      }
   return 0;
   }

   int addition (int x, int y)                  {return (x+y);}

   int soustraction (int x, int y)


Exemple d'exécution
Entrez un premier nombre : 3
Entrez un deuxième nombre : 9
1. addition
2.soustraction
Votre choix : 1
Resultat =12


L’instruction return
return (<Expression>) permet le retour à la fonction appelante, avec un éventuel résultat.
Le type de l'expression retournée est compatible avec celui de la fonction.
Il peut y avoir autant de return que nécessaire.
Le type void permet de préciser que la fonction ne renvoie aucun résultat.



Langage C/C++                                   Page 13
Passage des paramètres dans les fonctions
Par valeur

#include <iostream.h>                                    i avant appel : 2
                                                         u avant affectation : 2
void Fonction (int u)                                    u après affectation : 5
   {
                                                         i après l’appel : 2
    cout<<"u avant affectation : \n"<<u;
    u = 5;
    cout<<"u après affectation : "<<u;
    }

int main (void)
    {
     int i = 2;
     cout <<"i avant appel : \n"<< i;
     Fonction (i);
     cout <<"i après l’appel : " <<i;

return 0;
    }

Exercice Coder un programme ayant cet effet : écrire une fonction mini qui retourne la
plus petite valeur de deux entiers donnés. Utiliser cette fonction dans un programme qui
affiche le minimum de trois entiers saisis.



Par référence
Lorsque le type du paramètre est suivi d’un &, le paramètre est un nom alternatif pour la
variable de la fonction appelante. Toute modification du paramètre est une modification
de la variable de la fonction appelante.
#include <iostream.h>                            i avant appel : 2
                                                 u avant affectation : 2
void Fonction (int& u)                           u après affectation : 5
   {                                             i après l’appel : 5
    cout<<"u avant affectation :"<<u;
    cout <<"\n";                                 Un nouveau type a été introduit en C++ : le type
    u = 5;                                       référence.
    cout<<"u après affectation : "<<u;           Si T est un type, T& est le type référence vers T.
    cout <<"\n";                                 Une valeur de type référence est une adresse.
    }                                            La différence entre pointeur et référence réside
                                                 dans leur utilisation.
int main (void)                                  La différence principale entre pointeur et référence
{                                                est que toute opération appliquée sur une référence
int i = 2;                                       agit sur l’objet référencé et non pas sur l’adresse.
cout <<"i avant appel : << i <<"\n";
     Fonction (i);
cout <<"i après l’appel :" <<i<<"\n";

return 0;
}




Langage C/C++                          Page 14
TRANSMISSION DES ARGUMENTS DANS UNE FONCTION

TRANSMISSION PAR VALEUR                                         void f (int p);
Considérons une fonction f, et p un paramètre
de la fonction f. L’argument correspondant au                   f(a);
 paramètre p s’appelle a.

Transmission par valeur de l’argument a :
la valeur de a n’est pas modifiée par la fonction f

Corps de f : copie locale de a (appel du constructeur par copie : clônage de a)
              …
destruction de la copie locale (appel du destructeur)


#include <iostream.h>                                    i avant appel : 2
                                                         u avant affectation : 2
void Fonction (int u)                                    u après affectation : 5
   {
                                                         i après l’appel : 2
    cout<<"u avant affectation : \n"<<u;
    u = 5;
    cout<<"u après affectation : "<<u;
    }                                                    Transmission par valeur

int main (void)
    {
     int i = 2;
     cout <<"i avant appel : \n"<< i;
     Fonction (i);
     cout <<"i après l’appel : " <<i;
return 0;
    }




Langage C/C++                           Page 15
PAR REFERENCE
Syntaxe : le type du paramètre est suivi d’un &
        void f (int& p);

        f (a);

Transmission par référence de l’argument a :
la valeur de a peut-être modifiée par la fonction f


#include <iostream.h>                                 i avant appel : 2
                                                      u avant affectation : 2
void Fonction (int& u)                                u après affectation : 5
   {                                                  i après l’appel : 5
 cout<<"u avant affectation : \n"<<u;
    u = 5;                                            Transmission par référence
 cout<<"u après affectation : "<<u;                   Un nouveau type a été introduit en C++ : le type
    }                                                 référence.
                                                      Si T est un type, T& est le type référence vers T.
int main (void)                                       Une valeur de type référence est une adresse.
    {                                                 La différence entre pointeur et référence réside
     int i = 2;                                       dans leur utilisation.
     cout <<"i avant appel : \n"<< i;                 La différence principale entre pointeur et référence
     Fonction (i);                                    est que toute opération appliquée sur une référence
     cout <<"i après l’appel : " <<i;                 agit sur l’objet référencé et non pas sur l’adresse.
return 0;
    }


TRANSFORMATION

Lorsque le coût de l’appel du constructeur par copie et de l’appel du destructeur
est important la transmission par valeur est transformée par une transmission
par référence.

Exemple : void f (const string& ch); ===> clônage de la référence
Le qualificateur const
précise que la valeur de ch passée par référence ne doit être modifiée.
Dans ce cas, toute tentative de modification de ch est rejetée par le compilateur.


Exercice Coder une fonction ayant cet effet : retourner le nombre de dizaine d'un
nombre entier positif donné. Coder une fonction main pour tester l'efficacité de la fonction
du calcul des dizaines.


Exercice Coder une fonction ayant cet effet : échanger les valeurs de deux caractères
donnés. Coder une fonction main pour tester l'efficacité de la fonction d'échange.




Langage C/C++                            Page 16
Les tableaux comme paramètre

# include <iostream.h>                                                             Exécution

const int Max = 10
                                                          Entrez un nombre entier : 1
int LectureDesNombres(int Vecteur [ ], const int);        Entrez un nombre entier : 1
int SommeDesNombres (const int Vecteur [ ], const int);   Entrez un nombre entier : 1
                                                          Entrez un nombre entier : 1
int main ( )                                              Entrez un nombre entier : 1
{                                                         Entrez un nombre entier : 0
   int NbElem, Somme;
   int Elements [Max];    // Pas plus de Max nombres
   NbElem= LecturesDesNombres (Elements, Max);            Somme = 5
   Somme = SommeDesNombres (Elements, NbElem);
   cout << "\n Somme = " << Somme;
return 0;
}

int LectureDesNombres(int Vecteur [ ], const int Lg)      Nous verrons qu’un tableau en C++
{                                                         peut être assimilé à un pointeur.
    int i, nombre = -1;                                   Pour l’instant notons qu’en C++
                                                          lorsqu’une fonction comprend un
     for (i = 0; (i<Lg)&&(nombre != 0); i+= 1)            paramètre     de     type     tableau,
       { cout << "Entrez un nombre entier : ";            l’argument     correspondant       est
         cin>> nombre;                                    toujours transmis par référence.
         vecteur[i] = nombre;
       }
     return (i); // cardinal de la suite
}

int SommeDesNombres (const int Vecteur[],const int Lg)
{
    int i, somme = 0;
    for (i = 0; i<Lg; i += 1)
        somme += Vecteur [i];
    return (somme);
}




Langage C/C++                          Page 17
Surcharge des fonctions en C++


Définition
Elle signifie que plusieurs fonctions peuvent porter le même nom si le compilateur est
capable de faire la différence entre celles-ci à partir des paramètres.
Le nom et les paramètres forment la signature de la fonction.

 #include <iostream.h>
 int add (int i, int j)
 {
 return (i+j);
 }

 float add (float a, float b = 1)
 {
 return (a + b);
 }

 int main (void)
 {
 int x,y;
 float u, v;

 cout <<"Entrez la valeur de x et de y : ";
 cin >> x >> y;

 cout << "Entrez la valeur de u et de v : ";
 cin >> u >> v;

 cout << "x +y en entier : " <<add (x,y)<<"\n";
 cout << "u +v en réel :" <<add (u,v)<<"\n";
 cout << "x + défaut en réel : " <<add (u) <<"\n";
 return 0;
 }




Langage C/C++                         Page 18
Durée de vie des variables globales et locales

 Variable globales
Une variable globale est une variable définie avant toute déclaration de fonction. Une
telle variable est accessible depuis toutes les fonctions. Une telle variable a une durée de
vie aussi longue que dure l’exécution du programme.

 Variable locales
Une variable locale est une variable définie à l’intérieur d’un bloc (entre accolades). Une
telle variable n’est accessible que dans le bloc dans lequel elle est déclarée. Sa durée de
vie est celle du bloc : elle est créée (la place mémoire est réservée) lorsque commence
l’exécution du bloc et est détruite (la place mémoire est libérée) lorsque l’exécution du
bloc se termine.
On peut rendre une telle variable permanente en rajoutant static devant la déclaration.


Exemple

   int LectureDesNombres (int Vecteur[], const int Lg =10)
   {
   int i, nombre;
   for (i = 0; (i<Lg)&&(nombre !=0); i+= 1)
       {
      cout << "Entrez un nombre entier :";
      cin >> nombre;
      Vecteur [i] = nombre;
       }
   return (i);        // cardinal de la suite
   }

i et nombre sont des variables locales créées à l’entrée et détruites à la sortie du bloc.




Langage C/C++                            Page 19
Définir de nouveaux types de données

#include <string.h>

struct personne
{   string nom;
    string prenom;
};

void Editer (const personne indiv)
{ cout <<"\n Nom : " <<indiv.nom;
  cout <<"\n Prénom : " <<indiv.prenom;
  cout <<"\n Age : "<<indiv.age;
}

int main (void)
{   personne Celebre;
    Célèbre.nom="Einstein";
    Célèbre.prenom="Albert";
    Editer(Célèbre);
return 0;
}

En C : Les Structures

Elles permettent de définir des nouveaux types d’objets composés à partir de types
définis précédemment.
Par exemple, une personne peut être décrite par son nom, son adresse, …


ATTENTION : cet exemple n'applique pas la méthode objet.




Langage C/C++                       Page 20
Pointeurs et création dynamique d’objets

 Création et destruction dynamique d’objets
Généralement les objets, et en particulier les variables, sont soit permanents et globaux
au programme, soit locaux à la fonction dans laquelle ils ont été déclarés et ne durent
que le temps de l’exécution de cette fonction.

   #include <iostream.h>
   int main (void)
   {
   int *PointeurSurEntier;
   PointeurSurEntier = new int;
   // allocation d'un espace pour stocker un entier
   cout << "Entrez une valeur entière : ";
   cin >> * PointeurSurEntier;
   cout << "Valeur saisie : "<<*PointeurSurEntier;
   delete PointeurSurEntier;
     // L’espace réservé est libéré
   return 0;
   }

Il est quelquefois important pour le programmeur de pouvoir créer un objet (new),
lorsqu’il en a besoin et de détruire (delete) cet objet lorsqu’il n’est plus utilisé
indépendamment de toute autre considération.

 Un mécanisme de désignation : les pointeurs
Créer un objet n’est pas suffisant, il faut pouvoir le désigner. Dans l’exemple précédent,
la notation int* PointeurSurEntier permet de déclarer une variable identifiée par
PointeurSurEntier. Cette variable, d'un type particulier, est un pointeur, c’est-à-dire que
sa valeur permet de repérer (par son adresse) un objet qui est un entier (int).
En fait le pointeur contient l'adresse de la première case mémoire ou se trouve l’objet.

La syntaxe de déclaration d’un pointeur :
<Type> * <Identificateur>;

Opérations sur les pointeurs
Affectation                              Pointeur1 = Pointeur2
                                         Pointeur = & <Identificateur>;
                                         Pointeur = new <Type>;

Désignation de l’objet pointé            *Pointeur

Désignation d’un champ de l’objet        (*Pointeur).NomDuChamp
                                         Pointeur->NomDuChamp

Destruction de l' objet pointé           delete Pointeur;

Exercice Coder un programme ayant cet effet : saisir deux valeurs pointées de type
entier et afficher la somme des deux valeurs.

Exercice Coder un programme ayant cet effet : saisir trois valeurs pointées dans un
tableau de trois pointeurs. Ordonner le tableau par valeurs croissantes des entiers.
Langage C/C++                            Page 21
 Pointeurs et Tableaux
On peut allouer dynamiquement des tableaux. C’est à dire réserver N emplacements
mémoires en mettant un pointeur sur le premier emplacement. Les emplacements
peuvent être désignés par la notation traditionnelle des tableaux Pointeur [Index] ou par
notation *(Pointeur + Index)

Exemple 1

   # include <iostream.h>
   int main (void)
   {
   int *TableauNEntiers;
   int N;
   cout << "Combien d’entiers : ";
   cin >> N;
   TableauNEntiers = new int [N];
   // Allocation de l'espace pour le tableau
   cout <<"Entrez une valeur entière en position 5 :";
   cin >> TableauNEntiers[5];
   cout << "Valeur entrée : " << TableauNEntiers [5];
   delete [ ] TableauNEntiers;
   // L’espace alloué est libéré
   return 0;

Exemple 2

   # include <iostream.h>
   int main (void)
   {
   int * TableauNEntiers;
   int N;
   cout << "Combien d’entiers : ";
   cin >> N;
   TableauNEntiers = new int [N];
   // Allocation de l'espace pour le tableau
   cout <<"Entrez une valeur entière en position 5 :";
   cin >> *( TableauNEntiers + 5);
   cout << "Valeur entrée : " <<*( TableauNEntiers + 5);
   delete [ ] TableauNEntiers;
   // L’espace réservé est libéré
   return 0;
   }




Exercice Coder une fonction de saisie permettant de saisir dans un tableau une suite
d'entiers. Le tableau est dynamique. Le nombre d'entiers à saisir est donné par
l'utilisateur.
Coder une fonction main ayant cet effet : afficher la plus petite valeur présente dans un
tableau d'entiers. On utilise la fonction de saisie. On développe une fonction mini
retournant la valeur minimale d'une suite.



Langage C/C++                           Page 22
Les pointeurs et le passage de paramètres en C

Comme pour la plupart des langages, le langage C ne connaît qu’un seul mode de
passage de paramètres : le passage par valeur (recopie).
La valeur passée comme argument peut être :
 soit une variable statique ou une valeur (transmission par valeurs),
 soit l’adresse de la variable qui peut-être récupérée dans un pointeur par la fonction
   appelée.

Pour les tableaux, il s’agit toujours du passage de l’adresse ce qui explique les 2
notations possible : Pt [i] ou *(Pt + i).

Modifier une variable par son adresse
#include <iostream.h>

void Fonction (int *u)
     {
     cout <<"*u avant affectation : "<<*u<<’’\n";
      *u = 5;
     cout <<"*u après affectation : "<<*u<<’’\n";
     }

int main (void)
     {
      int i = 2;
      cout <<"i avant appel : "<<i<<"\n";                         i avant appel : 2
      Fonction (&i);                                              *u avant affecttion : 2
      cout <<"i après l’appel : "<<i<<"\n";                       *u après affectation : 5
return 0;                                                         i après l’appel : 5
}




Langage C/C++                          Page 23
Et si la variable est un pointeur ?

#include <iostream.h>

void Fonction (int *u)
      {
cout <<"Valeur pointée *u avant affectation : "<<*u<<"\n";
      *u = 5;
      cout <<"*u après affectation :"<<*u<<"\n";
     }

int main ()
     {
      int *Pt = new int;
      *Pt = 2;
      cout << "Valeur pointée Pt             avant appel : "<<*Pt<<"\n";
      Fonction (Pt);
      cout <<"*Pt après l’appel              : "<<*Pt<<"\n";
     delete Pt;
return 0;
}

*Pt avant appel : 2
Valeur pointée *u avant affectation : 2
*u après affectation : 5
*Pt après l’appel : 5

Et si on passait l’adresse d’une variable pointeur ?

#include <iostream.h>

void Fonction (int **u)
      {
      cout <<"Valeur pointée **u avant affectation : "<<**u<<"\n";
      **u = 5;
      cout <<" **u après affectation : "<<**u<<"\n";
     }

int main (void)
{
      int *Pt = new int;
      *Pt = 2;
      cout <<"Valeur pointée *Pt avant appel : " <<"Pt<<"\n";
      Fonction (&Pt);
      cout <<"*Pt après l’appel : "<<*Pt<<"\n";
     delete Pt;
return 0;
}

Valeur pointée *Pt avant appel : 2
Valeur pointée **u avant affectation : 2
**u après affectation : 5
*Pt après l’appel : 5




Langage C/C++                              Page 24

								
To top