Pouvez-vous chaîner des méthodes en retournant un pointeur sur leur objet?

Question

Mon but est de permettre l'enchaînement des méthodes telles que:

class Foo; 
Foo f; 
f.setX(12).setY(90); 

Est-il possible pour les méthodes de Foo pour retourner un pointeur vers leur instance, permettant un tel enchaînement?

Answer 1

Pour cette syntaxe spécifique que vous auriez à retourner une référence

class Foo { 
public: 

    Foo& SetX(int x) { 
    /* whatever */ 
    return *this; 
    } 

    Foo& SetY(int y) { 
    /* whatever */ 
    return *this; 
    } 
}; 

post-scriptum Ou vous pouvez renvoyer une copie (Foo au lieu de Foo&). Il n'y a aucun moyen de dire ce dont vous avez besoin sans plus de détails, mais à en juger par le nom de la fonction (Set...) que vous avez utilisé dans votre exemple, vous avez probablement besoin d'un type de retour de référence.

Answer 2

Oui c'est possible. Un exemple de comon est la surcharge de l'opérateur, comme operator + =().

Par exemple, si vous avez une classe appelée ComplexNumber, et que vous voulez faire quelque chose comme a + b =, alors vous pouvez

ComplexNumber& operator+=(ComplexNumber& other){ 
    //add here 
    return *this; 
} 

Dans votre cas, vous pouvez utiliser.

Foo& setX(int x){ 
//yada yada yada 
return *this; 
} 

Answer 3

Eh bien, vous pouvez retourner un objet de sa propre fonction pour les fonctions de la chaîne ainsi:

#include <iostream> 
class foo 
{ 
    public: 
     foo() {num = 0;} 
     // Returning a `foo` creates a new copy of the object each time... 
     // So returning a `foo&` returns a *reference* to this, and operates on 
     // the *same* object each time. 
     foo& Add(int n) 
     { 
      num += n; 
      std::cout << num << std::endl; 
      // If you actually DO need a pointer, 
      // change the return type and do not dereference `this` 
      return *this; 
     } 
    private: 
     int num; 
}; 

int main() 
{ 
    foo f; 
    f.Add(10).Add(5).Add(3); 
    return 0; 
} 

qui délivre en sortie:

$ ./a.out 
10 
15 
18 

Answer 4

Un autre exemple est le Named Parameter Idiom.

Answer 5

#include <iostream> 

using namespace::std; 

class Print 
{ 
    public: 
     Print * hello(); 
     Print * goodbye(); 
     Print * newLine(); 
}; 

Print * Print::hello() 
{ 
    cout << "Hello"; 
    return this; 
} 
Print * Print::goodbye() 
{ 
    cout << "Goodbye"; 
    return this; 
} 
Print * Print::newLine() 
{ 
    cout << endl; 
    return this; 
} 

int main (void) 
{ 
    Print print; 
    print.hello()->newLine()->goodbye()->newLine(); 

    return 0; 
} 

Sortie:

Hello 
    Goodbye