C++ : fonctions et opérateurs

Enseignement Informatique

LAL

Fonctions
- Passage d'arguments
- Surcharge
Surcharge d'opérateurs

Passage d'arguments

Les arguments peuvent être passés à une fonction sous trois formes :

Par valeur :
ne permet pas de modifier la variable car la fonction travaille sur une copie de la variable d'origine et non sur la variable elle-même ;
à éviter absolument avec un type complexe comme une classe car faire une copie de classe n'est pas anodin
Par adresse :
permet de pallier la limite du passage par valeur mais lourd d'un point de vue syntaxique
Par référence :
permet de pallier la limite du passage par valeur sans la lourdeur syntaxique ;
pour plus de clarté, on rajoute le mot clé "const" si la variable n'est pas modifiée dans la fonction (utile pour les classes)

Passage par valeur

Passage par valeur :

Copie de a

 void fonction( int a )
 {
   a = 4;   // a vaut 4
 }      

 // Appel de la fonction 
 int b = 3;
 fonction( b );

 std::cout << "b = " << b << std::endl;

Passage par valeur

Passage par valeur :

b n'est pas changé par l'appel de fonction()

 void fonction( int a )
 {
   a = 4;   // a vaut 4
 }      

 // Appel de la fonction 
 int b = 3;
 fonction( b );

 std::cout << "b = " << b << std::endl;

Passage par adresse

Passage par adresse :

 void fonction( int* pa )
 {
   *pa = 4;   // a vaut 4
 }      
 
 // Appel de la fonction 
 int b = 3;
 fonction( &b );
 std::cout << "b = " << b << std::endl;

Passage par adresse

Passage par adresse :

b est modifié par l'appel de fonction()

 void fonction( int* pa )
 {
   *pa = 4;   // a vaut 4
 }      
 
 // Appel de la fonction 
 int b = 3;
 fonction( &b );
 
 std::cout << "b = " << b << std::endl;

Passage par référence (C++)

Passage par référence :

Pas de copie de a

 void fonction( int& a )
 {
   a = 4;   // a vaut 4
 }      
 
 // Appel de la fonction 
 int b = 3;
 fonction( b );
 std::cout << "b = " << b << std::endl;

Passage par référence (C++)

Passage par référence :

b est modifié par l'appel de fonction()

 void fonction( int& a )
 {
   a = 4;   // a vaut 4
 }      
 
 // Appel de la fonction 
 int b = 3;
 fonction( b );
 
 std::cout << "b = " << b << std::endl;

Fonction : surcharge de sélection

La surcharge de sélection consiste à implanter

plusieurs méthodes
- de même nom
- dans une même classe
mais dont la liste des arguments diffère

Fonction : surcharge de sélection

vecteur.h


class Vecteur
{
  protected:
    int m_x, m_y;
  public:
    Vecteur() {m_x = m_y = 0;}
    Vecteur(int x, int y) {m_x = x; m_y = y;}
    
    void deplace (int x, int y);
    void deplace (const Vecteur& v);
};

Fonction : surcharge de sélection

vecteur.cpp


void Vecteur::deplace (int x, int y)
{
  m_x += x; 
  m_y += y;
}

void Vecteur::deplace (const Vecteur& v)
{
  m_x += v.m_x;
  m_y += v.m_y;
}

Fonction : surcharge de sélection

main.cpp


int main()
{
  Vecteur v1(3, 5), v2(6, 7);

  v1.deplace(6,7);

  v1.deplace(v2)

  return (0);
}

Surcharge d'opérateurs

Permet de redéfinir les opérateurs pour toute classe

Si Δ est un opérateur unaire, Δn peut s'interpréter comme n.operator Δ()
Ex : n++ s'interprète comme n.operator++()
Si Δ est un opérateur binaire, n Δ m peut s'interpréter comme n.operator Δ(m)
Ex : n + m s'interprète comme n.operator+( m )
La plupart des opérateurs peuvent être redéfinis pour n'importe quelle classe
Cas particulier : le compilateur génère un opérateur d'affectation ("=") par défaut; il est souvent nécessaire de le redéfinir.

Surcharge d'opérateurs : exemple

vecteur.h


class Vecteur
{
  protected:
    int m_x, m_y;
  public:
    Vecteur() {m_x = m_y = 0;}
    Vecteur(int x, int y) {m_x = x; m_y = y;}
    
    bool operator== (const Vecteur& v);
    Vecteur& operator= (const Vecteur& v);
    Vecteur& operator+ (const Vecteur& v);
    
    friend std::ostream& operator<< (std::ostream& os, const Vector& v);
};

Surcharge d'opérateurs : exemple

vecteur.cpp

 #include "vecteur.h"
 
 bool Vecteur::operator== (const Vecteur& v)
 {
   return (m_x == v.m_x && m_y == v.m_y);
 }
 
 Vecteur& Vecteur::operator= (const Vecteur& v)
 {
   m_x = v.m_x; m_y = v.m_y;
   return *this; // this contient l'adresse de l'objet lui-même
 }
 
 Vecteur& Vecteur::operator+ (const Vecteur& v)
 {
   Vecteur vv(m_x + v.m_x, m_y + v.m_y);
   return vv;
 }

Surcharge d'opérateurs : exemple

vecteur.cpp (suite)

 …
 
 std::ostream& operator<< (std::ostream& os, const Vector& v)
 {
   os << "Abscisse  : " << v.m_x << std::endl;
   os << "Ordonnée : " << v.m_y << std::endl;
   return (os);
 }

Surcharge d'opérateurs : exemple (suite)

main.cpp

 #include "vecteur.h"
 
 int main()
 {
   Vecteur v1(3, 5), v2(6, 8), v3, v4;
   v3 = v1 + v2;  // opérateur = et opérateur +
   v4 = v3;       // opérateur = 
   if (v3 == v4)  // opérateur ==
     std::cout << "Vecteurs identiques" << std::endl;
     
   std::cout << v4;  // Affichage à l'écran
   
   ofstream f("fichier.txt");
   f << v4;          // Affichage dans un fichier
   f.close();
   return (0);
 }

Surcharge d'opérateurs

Opérateurs pouvant être redéfinis :

      +	    -	    *	    /	    %	    =	    !

      +=    -=	  *=	  /=	  %=	  ++	  --

      <	    >	    <=	  >=	  ==	  !=	  &&

      ||    &	    |	    ^	    <<	  >>

      []	  new	  delete

Questions ?