Le pointeur this en C++

En C++, chaque fonction membre de classe (méthode) reçoit implicitement un paramètre spécial appelé pointeur this. Le pointeur this représente l’adresse de l’objet sur lequel la méthode est appelée. Autrement dit, à l’intérieur d’une méthode de classe, this permet d’accéder à l’objet actuellement manipulé.

1. Qu’est-ce que le pointeur this ?

Le pointeur this est un pointeur implicite transmis automatiquement à chaque méthode d’instance. Chaque fonction membre non statique peut accéder à l’adresse de l’objet sur lequel elle agit via ce pointeur.

#include <iostream>
using namespace std;

class Book {
private:
    string title;

public:
    Book(string t) {
        this->title = t; // utilisation de this
    }

    void Show() {
        cout << "Livre : " << this->title << endl;
    }
};

int main() {
    Book b("Apprendre le C++");
    b.Show();
}

Ici, this->title accède au membre title de l’objet courant. Écrire simplement title = t; donnerait le même résultat, mais this est utile lorsque le nom du paramètre entre en conflit avec celui d’un membre.

2. Conflit entre le nom d’un paramètre et celui d’un membre

Dans l’exemple suivant, les paramètres du constructeur portent le même nom que les membres de la classe. Dans ce cas, il est obligatoire d’utiliser this pour lever l’ambiguïté.

class Book {
private:
    string title;
    double price;

public:
    Book(string title, double price) {
        this->title = title; // sans "this", on affecterait le paramètre à lui-même
        this->price = price;
    }

    void Show() const {
        cout << "Livre : " << title << " | Prix : " << price << " €" << endl;
    }
};

int main() {
    Book b("C++ Moderne", 120.5);
    b.Show();
}

L’expression this->title fait référence au membre title de la classe. Sans this, le compilateur ne saurait pas quel identifiant utiliser.

3. Adresse mémoire du pointeur this

Chaque objet possède une adresse this différente, car chaque instance est stockée à un emplacement mémoire distinct.

#include <iostream>
using namespace std;

class Book {
private:
    string title;
public:
    Book(string t) : title(t) {}

    void PrintAddress() const {
        cout << "Adresse de l’objet (this) : " << this << endl;
    }
};

int main() {
    Book b1("C++ Primer");
    Book b2("Effective C++");

    b1.PrintAddress();
    b2.PrintAddress();
}

La sortie sera différente pour chaque objet, car this contient l’adresse unique de chaque instance.

4. Chaînage de méthodes (Method Chaining)

Le pointeur this peut être retourné par une méthode pour permettre le chaînage d’appels. Ainsi, plusieurs méthodes peuvent être appelées en une seule instruction.

#include <iostream>
#include <string>
using namespace std;

class Book {
private:
    string title;
    double price;
    int pageCount;

public:
    Book() : title(""), price(0), pageCount(0) {}

    Book* SetTitle(string t) {
        this->title = t;
        return this; // retourne sa propre adresse
    }

    Book* SetPrice(double p) {
        this->price = p;
        return this;
    }

    Book* SetPageCount(int c) {
        this->pageCount = c;
        return this;
    }

    void Show() const {
        cout << title << " (" << pageCount << " pages) - " 
             << price << " €" << endl;
    }
};

int main() {
    Book b;
    b.SetTitle("Programmation orientée objet en C++")
     ->SetPrice(149.90)
     ->SetPageCount(580)
     ->Show();
}

Cette technique est appelée chaînage de méthodes et est souvent utilisée dans les modèles de conception Builder ou Fluent Interface.

5. Utilisation de this dans la surcharge d’opérateurs

Le pointeur this est fréquemment utilisé lors de la surcharge d’opérateurs. Par exemple, pour additionner deux objets Book en fonction de leur prix :

#include <iostream>
#include <string>
using namespace std;

class Book {
private:
    string title;
    double price;

public:
    Book(string t, double p) : title(t), price(p) {}

    // Surcharge de l’opérateur (+)
    Book operator+(const Book &other) const {
        double totalPrice = this->price + other.price;
        return Book("Pack : " + this->title + " & " + other.title, totalPrice);
    }

    void Show() const {
        cout << title << " - " << price << " €" << endl;
    }
};

int main() {
    Book b1("C++ Primer", 180.0);
    Book b2("C++ Moderne efficace", 220.0);

    Book combo = b1 + b2;
    combo.Show();
}

Ici, this->price représente le prix de l’opérande de gauche. Cela est pratique lorsqu’il faut combiner ou comparer plusieurs objets.

6. Utilisation de this dans le constructeur

Dans un constructeur, this peut être utilisé pour référencer l’adresse de l’objet avant sa complète initialisation. Cela est souvent utile pour le débogage ou la journalisation.

class Book {
public:
    Book() {
        cout << "Création d’un nouvel objet Book... Adresse : " << this << endl;
    }
};

Cela est particulièrement utile dans des structures complexes (par ex. Book → Author → Publisher) pour suivre le cycle de vie d’un objet à l’exécution.

7. this ne peut pas être utilisé dans les fonctions statiques

Les fonctions statiques appartiennent à la classe elle-même, pas à un objet spécifique. Par conséquent, le pointeur this n’existe pas dans les fonctions statiques.

class Book {
public:
    static void Info() {
        // cout << this; // ERREUR ! "this" n’est pas accessible dans une méthode statique
        cout << "Ceci est une fonction statique." << endl;
    }
};

8. TL;DR

Articles connexes