Ce site est en cours de reconstruction certains liens peuvent ne pas fonctionner ou certaines images peuvent ne pas s'afficher.

stacks

1. Introduction au C++

1.9. Pointeur ou référence

1.9.1. le mot clé this

Le mot clé this représente l'adresse de la classe et est utilisé à l'intérieur d'une des méthodes de la classe.

L'expression *this représente une référence de la classe.

1.9.2. Déclaration, utilisation

Une référence est en quelque sorte un pointeur dont l'adresse est non modifiable mais qui utilise une syntaxe différente de celle du pointeur.

Note 1: on peut déclarer un pointeur sans qu'une adresse lui soit associée, par contre lorsque l'on déclare une référence une variable du type référencé doit être affecté à la référence.

Note 2: attention, l'opérateur & possède une signification particulière pour les pointeurs ou pour les références.

Afficher le code ens/inra/c1_pointeur_reference.cpp

int main() {
  int x = 1;
  
  // ======= pointer =======
  int *ptr_x = &x;
  // or
  // int *ptr_x;
  // ptr_x = &x;  here &x means address of x
  
  // use the pointer syntax to manipulate
  *ptr_x = *ptr_x + 1;
  
  // ======= reference =======
  // ref_x is a reference to an existing variable
  int& ref_x = x;
  ref_x = ref_x + 1;
  
  return 0;
}
 

1.9.3. Utilisation avec des classes

Afficher le code ens/inra/c1_pointeur_reference_objet.cpp

#include <iostream>
#include <string>
using namespace std;
 
class Person {
protected:
  string name;
  int age;
public:
  Person(string n, int a) : name(n), age(a) {
  }
  string get_name() {
    return name;
  }
  int get_age() {
    return age;
  }
};
 
int main() {
  Person john("John", 40);
  
  Person *ptr_p = &john;
  cout << ptr_p->get_name() << " " << ptr_p->get_age() << endl;
  
  Person& ref_p = john;
  cout << ref_p.get_name() << " " << ref_p.get_age() << endl; 
}
 

1.9.4. Problème

Dans l'exemple suivant la fonction function_1 tente de soustraire la valeur maximum d'une classe à la valeur minimum, les instances des classes étant passées par référence. On tente donc d'échanger les références pour que la référence smallest (resp. biggest) pointe sur la valeur minimum (resp. maximum).

Cependant cela ne peut pas fonctionner car l'instruction smallest = const_cast(y); revient à écrire x=y ou en d'autres termes à réaliser l'affectation a1 = a2

Afficher le code ens/inra/c1_reference_problem.cpp

#include <iostream>
using namespace std;
 
/**
 * Definition of class A that stores an integer
 */
class A {
public:
  // value stored
  int value;
  
  /**
   * default constructor
   * initialization of value to -1
   */
  A() {
    value = -1;
  }
  
  /**
   * constructor with value
   * @param v value to store
   */
  A(int v) {
    value = v;
  }
  
  /**
   * print class contents
   */
  friend ostream& operator<<(ostream& out, A& obj) {
    out << obj.value;
    return out;
  }
};
 
// ----------------------------------------------
// function that will produce an error
// we are trying to exchange values
// ----------------------------------------------
int function_1(const A& x, const A& y) {
  // by default lets assume 'x' is the smallest value
  // and 'y' the biggest
  A& smallest = const_cast<A&>(x);
  A& biggest = const_cast<A&>(y);
  
  cout << "> in function:" << endl;
  cout << "smallest = " << smallest << endl;
  cout << "biggest  = " << biggest << endl;
  
  // if it is not the case then exchance 'x' and 'y'
  if (smallest.value > biggest.value) {
    // !!!!! problem here !!!!! 
    // it is equivalent to: x = y
    smallest = const_cast<A&>(y);
     
    biggest = const_cast<A&>(x);
    cout << "> in function after exchange:" << endl;
    cout << "smallest = " << smallest << endl;
    cout << "biggest  = " << biggest << endl;   
  }
  
  return (biggest.value - smallest.value);
}
 
// ----------------------------------------------
// valid function 
// we are trying to exchange values
// ----------------------------------------------
int function_2(const A& x, const A& y) {
  // work on values not references
  int smallest = x.value;
  int biggest  = y.value;
  
  cout << "> in function:" << endl;
  cout << "smallest = " << smallest << endl;
  cout << "biggest  = " << biggest << endl;
  
  if (smallest > biggest) {
    swap(smallest, biggest);
  }
  
  return (biggest - smallest);
}
 
 
// ----------------------------------------------
// main function
// ----------------------------------------------
int main() {
  A a1(7), a2(5);
 
 
  cout << "==== with function_1 ====" << endl;
  cout << "initially :" << endl;
  cout << "a1 = " << a1 << endl;
  cout << "a2 = " << a2 << endl;
  
  int r = function_1(a1, a2);
  cout << "r = " << r << endl;
  
  // !!! a1 is modified after call to function !!!
  cout << "finally :" << endl;
  cout << "a1 = " << a1 << " !!! should be 7" << endl;
  cout << "a2 = " << a2 << endl;
 
  cout << "==== with function_2 ====" << endl;
  A b1(7), b2(5);
  cout << "initially :" << endl;
  cout << "b1 = " << b1 << endl;
  cout << "b2 = " << b2 << endl;
  
  r = function_2(b1, b2);
  cout << "r = " << r << endl;
  
  cout << "finally :" << endl;
  cout << "b1 = " << b1 << endl;
  cout << "b2 = " << b2 << endl;
  
  return 0;
}
 
 
 

Pour pallier à ce problème il faut échanger les valeurs des classes et non leurs références comme dans function_2.