Discussion :

[Gugelhupf]

Bonsoir,

Au lieu d'utiliser une méthode qui ne retourne rien (void), je souhaiterais créer une méthode qui retourne l'objet en cours.

Voici un exemple en Java :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Test{
   private val;
 
   public Test(){ 
      val = 0; 
   }
 
   public int getVal(){
      return val;
   }
 
   public Test ajoute(int a){
      val += a;
      return this;
   }
}
 
/* DANS LE MAIN */
 
void main(String[] args){
   Test obj1 = new Test(); // obj1.getVal() = 0
   Test obj2 = obj1.ajoute(1).ajoute(2); // obj1.getVal() et obj2.getVal() = 3
   obj1.ajoute(997);
   // obj1.getVal() et obj2.getVal() = 1000
}

Je souhaiterais donc recréer l'exemple du dessus en C++ sans avoir à utiliser la surcharge des opérateurs (operator).

Voici ma classe C++ :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
class Test
{
public:
    Test(int a = 0);
    int getVal();
    Test& ajouter(int a);
 
private:
    int val;  
};

La définition de mes méthodes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
Test::Test(int a) : val(a)
{}
 
int Test::getVal()
{
   return val;
}
 
Test& Test::ajoute(int a)
{
    val += a;
    return *this;
}

L'exemple avec la méthode ajoute() que j'ai choisis est simple (démonstration), cela aurait pu être une méthode beaucoup plus complexe, l'idée est juste de retourner l'objet en cours une fois avoir travaillé dans la méthode.
Je souhaiterais vous demander si la syntaxe de ma classe et de la définition de mes méthodes respectent les normes du C++[/COLOR].


Je vous remercie

[gbdivers]

Oui, c'est la syntaxe que l'on retrouve dans beaucoup d'opérateurs ou pour les techniques de function chaining
Bien sur, d'un point de vue syntaxique, c'est probablement les opérateurs + ou << qui correspondent le plus

[Gugelhupf]

Oui, je souhaiterais faire du function chaining.
Donc si je comprends bien ma syntaxe C++ est juste.

Je vous remercie pour votre confirmation, je mets le sujet en résolu

[Ekleog]

Boost intègre aussi une solution plus élégante à utiliser, qui triche avec les operator : (implémentation personnelle non tirée de boost)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Test;
class TestAdder {
  Test * t_;
public:
  TestAdder(Test * t) : t_(t) { }
  TestAdder & operator () (int i);
};
class Test {
  std::vector<int> v_;
  friend class TestAdder;
 
public:
  TestAdder ajouter;
 
  Test() : ajouter(this) { }
 
  int first() { return v_.size() == 0 ? -1 : v_[0]; } // Juste pour faire joli
};
TestAdder & TestAdder::operator () (int i) {
  t_->v_.push_back(i);
  return *this;
}
// Utilisation :
Test t;
t.ajouter(1)(2)(5)(42)(1337);
std::cout << t.first() << std::endl; // 1

Et pour bien se former les cours et tutoriels pour apprendre C++ : https://cpp.developpez.com/cours/