Discussion :

[Takahani]

Bonjour,

Avant toutes choses, autant préciser que je n'y connais pas grand chose en prog et que ce que j souhaite est surement tordu ou irréalisable mais bon, j'y crois

Alors voila je souhaiterais avoir une méthode template dans une classe qui me renvoie une valeur d'un certain type, ce type étant définie par un attribut interne de la classe (un entier qui prend plusieurs valeurs ...)
Un peu de code sera sûrement plus parlant (j'espère )

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
50
51
52
53
 
// en réalité ces définitions sont ailleurs, je les rajoute ici pour compréhension
#define VTK_DOUBLE 1
#define VTK_FLOAT 2
#define VTK_INT 3
 
class MaClasseA
{
    MaClasseA(void );
    template <typename T> T GetData(const int index);
    void *ptr;
    int type;
}
 
void MaClasseA::MaClasseA(void)
{
// ImageData est une instance de la classe vtkImageData de la librairie VTK et cette méthode renvoie un pointeur de type void * qui pointe vers un grand tableau 1D. 
// Le souci est que je ne peux pas savoir à l'avance de quel type seront les données, cela dépend des images. 
// Les données sont chargées ailleurs et j'ai simplifié le code pour compréhension, en tout cas j'ai accès à l'instance ImageData depuis le constructeur de cette classe.
    ptr=ImageData->GetDataPointer(); 
 
    // renvoi VTK_DOUBLE ou VTK_FLOAT ou autres
    type=ImageData->GetScalarType();
}
 
template <typename T> T MaClasseA::GetData(const int index)
{
   switch (type)
   {
        case VTK_DOUBLE :
            return static_cast<double *>(ptr)[index];
            break;
 
        case VTK_FLOAT :
            return static_cast<float *>(ptr)[index];
            break;
 
        default :
            break;
    }
}
 
class MaClasseB : public MaClasseA
{
    MaClasseB();
    void MaMethodeAuPif(void);
}
 
void MaClasseB::MaClasseB(void){;}
void MaClasseB::MaMethodeAuPif(void)
{
    cout<<"Valeur du voxel 150 "<<GetData(50)<<endl;
}

Tout le problème se situe sur cette dernière méthode qui ne fonctionne pas dans l'état (dommage !). Et je ne veux pas avoir à faire ce qui suit sans quoi l'intérêt de la méthode template est plus que limité !

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
 
void MaClasseB::MaMethodeAuPif(void)
{
    switch (InstanceClasseA->GetType())
   {
        case VTK_DOUBLE :
            cout<<"Valeur du voxel 150 "<<GetData<double>(50)<<endl;
            break;
 
        case VTK_FLOAT :
            cout<<"Valeur du voxel 150 "<<GetData<float>(50)<<endl;
            break;
 
        default :
            break;
    }
}

Est ce qu'il existe un moyen de récupérer ma valeur avec une seule fonction, sans passer par le switch case ? Ca serait pas mal car je vais avoir énormément de méthodes du type MaMethodeAuPif dans différentes classes qui héritent de MaClasseA, et je voudrais éviter le switch avec les 15 types à chaque fois ...

La solution du pb ne doit pas être très loin de cette section de la FAQ C++, mais je ne vois pas comment faire.
http://cpp.developpez.com/faq/cpp/?p...TES_parametres

Voila merci d'avance et redites si c'est incompréhensible ou autres
Bonne soirée et merci pour votre forum riche en information
Simon

[yan]

Bonjour et bienvenue sur le forum.
Les templates sont interprétées pendant la compilation.
Donc si le type est connu pendant la compilation ça doit être possible sinon non.
Ne serait il pas plus correcte que ce soit ta class qui soit template??

[NiamorH]

A mon avis, c'est ta classe qui devrait etre template, et tu devrais instancier une classe pour chaque image récupérée.

[yan]

A mon avis, c'est ta classe qui devrait etre template, et tu devrais instancier une classe pour chaque image récupérée.

+1
Cela va surtout dépendre de ta vision des choses. Peut être les deux te correspondrais?

• template : code indépendant du type de l'image ou autre et reutilisable
• polymorphisme : utilisation dynamique pendant l'exécution grâce à une interface bien pensée et suffisante

Mais y aura toujours un switch ou autre quelque part

[Alp]

Dans tous les cas, les templates ne feront pas le boulot à ta place si ça se décide à l'exécution.

[loufoque]

Tu veux peut-être quelque chose dans le genre de boost.variant ou boost.any ?

[yan]

Tu veux peut-être quelque chose dans le genre de boost.variant ou boost.any ?

as tu regardé ca?

[Corebreaker]

Voilà peut-etre que ça peut t'aider

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
typedef enum
{
   VTK_DOUBLE= 1,
   VTK_FLOAT,
   VTK_INT
} tType;
 
class Data
{
public:
   virtual ~Data()
   {
   }
 
   virtual Data &operator(int idx) = 0;
   virtual void print(ostream &o) = 0;
};
 
template<typename T>
class TypedData : public Data
{
   T *base;
   int i;
 
public:
   TypedData(void *b)
   : base((T *)b), i(0)
   {
   }
 
   Data &operator()(int idx)
   {
      i= idx;
 
      return *this;
   }
 
   void print(ostream &o)
   {
      o << base[i];
   }
};
 
ostream &operator<<(ostream &o, const Data &d)
{
   d.print(o);
 
   return o;
}
 
class MaClasseA
{
    MaClasseA(void );
    Data &GetData();
    Data &GetData(int i);
    void *ptr;
    tType type;
}
 
 
void MaClasseA::MaClasseA(void)
{
// ImageData est une instance de la classe vtkImageData de la librairie VTK et cette méthode renvoie un pointeur de type void * qui pointe vers un grand tableau 1D. 
// Le souci est que je ne peux pas savoir à l'avance de quel type seront les données, cela dépend des images. 
// Les données sont chargées ailleurs et j'ai simplifié le code pour compréhension, en tout cas j'ai accès à l'instance ImageData depuis le constructeur de cette classe.
    ptr=ImageData->GetDataPointer(); 
 
    // renvoi VTK_DOUBLE ou VTK_FLOAT ou autres
    type=ImageData->GetScalarType();
}
 
Data &MaClasseA::GetData()
{
   switch (type)
   {
        case VTK_DOUBLE :
            return *new TypedData<double>(ptr);
            break;
 
        case VTK_FLOAT :
            return *new TypedData<float>(ptr);
            break;
 
        default :
            break;
    }
}
 
Data &MaClasseA::GetData(int i)
{
   return GetData()(i);
}
 
 
class MaClasseB : public MaClasseA
{
    MaClasseB();
    void MaMethodeAuPif(void);
}
 
void MaClasseB::MaClasseB(void){;}
void MaClasseB::MaMethodeAuPif(void)
{
    cout<<"Valeur du voxel 150 "<<GetData(50)<<endl;
    cout<<"Valeur du voxel 160 "<<GetData(60)<<endl;
 
// ou alors:
   Data &d= GetData();
 
   cout<<"Valeur du voxel 150 "<< d(50) <<endl;
   cout<<"Valeur du voxel 160 "<< d(60) <<endl;
}

J'ai pas compilé, mais ca devrait, et l'idée y est.

[NiamorH]

Evidemment ce qu'il veut faire n'est pas envisageable.
Mais je pense que le type de données est lié à l'image et qu'il ne change pas durant toute la vie de celle-ci.
S'il instancie une classe par image, il peut sauver le type de données en tant que parametre template (ou seulement le numéro VK via un parametre template non type et il retrouve le bon type par une classe de trait).

Ensuite il peut se servir d'une fonction à polymorphisme statique pour l'affichage afin d'éviter les redondances.

[Alp]

Si la nature de l'image de change pas, c'est tout a fait jouable oui.

[reptils]

et avec type_info?