Discussion :

[jamesandrew]

Bonjour à tous,

Je souhaite créer une classe nommée class1, qui aurait plusieurs méthodes, disons method0, method1, method2 et mothod3. La method0 va déterminer un entier qui caractérise l'objet de class1 et restera constant.
Dans mon main(), je crée un objet nommé obj1 de class1 et je souhaite afficher les valeurs obj1.method1(), obj1.method2() et obj1.method3() qui sont aussi des entiers. Les méthodes method1, method2 et method3 font toutes appel à method0. Le problème, c'est que method0 est extrêmement couteuse en temps, une fois déterminée, il ne faudrait plus avoir à la recalculer. Comment faites-vous ? Peut-on stocker une variable calculée par une méthode à l'intérieur d'un objet ?

Si je suis pas très clair, on pourrait imaginer un code plutôt bête qui doit afficher 1000 fois obj1.method0() : il n'y a aucun intérêt à ré-exécuter la méthode à chaque fois puisque la valeur retournée est propre à l'objet et reste constante (dans mon cas).

Je commence la programmation orientée objet alors pardonnez-moi si ma question est évidente, j'ai fait des recherches mais n'ai rien trouvé.
Merci de votre aide,
Andrew

[foetus]

Tu transformes ta méthode method0 par, par exemple, init et que tu appelles soit via le constructeur, soit à la main


Fichier .h:

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
27
28
29
30
31
class Class1
{
// Constructor
public:
 
     Class1();
 
 
// Public interface using const_value
public:
 
    void method1();
 
    void method2();
 
    void method3();
 
 
private:
 
    void init();
 
 
// Attributes
private:
 
    int const_value;
 
//  Maybe this is useless
    bool is_initialized;
};

Fichier .cpp:

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
27
28
29
30
31
32
33
34
35
#include "XXX.h"
 
Class1::Class1() : is_initialized(false) {
// Maybe call init or not
}
 
 
void Class1::init() {
//  compute const_value
 
//  ...
 
    is_initialized = true;
}
 
 
void Class1::method1() {
    if (!is_initialized) { return; }
 
//  use const_value
}
 
 
void Class1::method2() {
    if (!is_initialized) { return; }
 
//  use const_value
}
 
 
void Class1::method3() {
    if (!is_initialized) { return; }
 
//  use const_value
}

[jamesandrew]

Ok foetus. Je pensais qu'il y avait déjà quelque chose de prévu pour réaliser ça, mais ton astuce me convient parfaitement Un grand merci

[bacelar]

La method0 va déterminer un entier qui caractérise l'objet de class1 et restera constant.

Ça ressemble pas mal aux conditions d'usage du Design Pattern Factory.

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class Class1
{
// Constructor
protected:
 
     Class1();
 
 
// Public interface using const_value
public:
 
    virtual int method1() = 0;
 
    virtual int method2() = 0;
 
    virtual int method3() = 0;
 
 
};
 
class Class2 : public Class1
{
....
    friend Class1& CreateClass1();
....
};
 
class Class3 : public Class1
{
...
    friend Class1& CreateClass1();
...
};
 
Class1& CreateClass1()
{
    if(method0==toto)
    {
        return Class2();
    }
    else
    {
        return Class3();
    }
}
 
/*code utilisateur*/
 
    Class1& maClasse1 = CreateClass1();

[Bousk]

Un mot-clé : mise en cache.