Discussion :

[alpidor]

Bonjour,

Je suis dans une situation de ce genre:

Code :

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

1
2
3
4
5
6
7
8
9
class Base()
{
};
 
template <class type> class MyClass : public Base
{
public:
    type value;
};

J'ai egalement un vecteur de type

Code :

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

std::vector<Base*> myVector;

Comment avoir access, le plus simplement, a l'attribut value quand j'accede le vecteur par indexation par ex. myVector[5]


Merci

[Laurent Gomila]

C'est une question assez récurrente.

Plusieurs réponses :
- D'un point de vue purement syntaxique, un transtypage est nécessaire (voir dynamic_cast / static_cast dans la FAQ)
- D'un point de vue un peu plus philosophique, ça relève très souvent d'une erreur de conception. En l'occurence, si tu stockes des Base* c'est que tu veux manipuler des Base*. Si tu veux accéder aux propriétés particulières de chacun de tes objets, il ne faut pas les mettre dans le même panier.

[alpidor]

Bonjour,
Justement, je voulais eviter les dynamic_cast / static_cast.

J'ai des parametres qui sont de type differents et je voulais obtenir leur valeur a un moment done.

Le vecteur de la classe de base me convenait parce que je ne peux pas declarer un vecteur non-type et parce que je veux acceder mes parametres par indexation.

Malheureusement, il semble qu'il n'y a pas de solution facile.

Merci,

[Laurent Gomila]

Il y a un problème dans ta conception. Une fois stocké dans le tableau de Base*, tu ne peux accéder aux données de la classe dérivée que via les fonctions virtuelles ou un transtypage. Or toi tu ne veux ni l'un ni l'autre, j'en déduis que l'utilisation d'un seul conteneur pour stocker tous tes objets n'est pas adaptée.

L'utilisation d'un conteneur "foutoir" en C++ est généralement une mauvaise idée. Il ne faut jamais mélanger des objets que l'on ne souhaite pas utiliser de la même manière.

[JolyLoic]

J'ai des parametres qui sont de type differents et je voulais obtenir leur valeur a un moment done.

Sans même parler de stockage, la question est : Que vas-tu faire des valeurs, qui sont toutes de type différent ? Soit tu leur appliques un traitement uniforme (genre les mettre dans un flux avec <<, qui marche pour tous les types) et tu peux ajouter dans Base une fonction qui fait ce travail, soit tu leur applique un traitement spécifique, et dans ce cas là, il te faudra bien à un moment où à un autre différencier en fonction du type, et donc le faire au moment du dynamic_cast me semble opportun.

[Alp]

(Bientôt 10000 messages Laurent. Bravo. A croire que tu n'as pas de vie )

Pour appuyer ce qu'a dit Laurent, je rajouterais que si tu veux aller dans la direction foutoir, tu dois te débrouiller pour avoir des méthodes virtuelles dans Base et les implémenter dans tes classes dérivées de façon à ce que chacune des classes dérivées agisse comme tu le souhaites. Pourquoi ce n'est pas bon ? Car à priori tu ne dois pas agir en connaissant le type réel de ton Base*. Dans ton cas, c'est pourtant ce que tu veux faire. Et cela va à l'encontre de la notion de polymorphisme. Si tu n'arrives même pas à faire ce que j'ai dit quelques lignes au-dessus, c'est vraiment que ta conception est intégralement à revoir. Cependant, la revoir même si tu arrives à bricoler quelque chose qui marche serait un avantage pour l'évolution de ton code, et probablement pour les performances. L'héritage, ça coute, surtout si tu veux stocker beaucoup de ces objets.

Comment réorganiser ton code ? Explique nous brièvement le cas concret dans lequel tu as ce problème et nous pourront t'aiguiller, si tu ne trouves pas tout seul.

[alpidor]

Bonjour a tous,

J'ai une application client (java) serveur(c++) et je dois configurer des objets (e.g. cameras). Les parametres de configuration des objets sont de types differents ex. bool, int etc.

Supposons que je feux controler le zoom de la camera : j'envoie "15 24" : ce qui veut dire set le 15em parametre (ZOOM) a la valeur 24 : ou bien "14 0" ce qui veut dire mets le ZOOM off

En c++ j'ai defini les classes mentionnees dans mon premier message :

classe Base
{
Set(std::istringstream is) = 0;
};

template <class type> class Param : public Base
{
public:
void Set(std::istringstream is)
{ is >> value; }


type value;
}

et je definis mes parametres:

.....
Param<bool> focusOnOf;
Param<unsigned int> focus;
Param<bool> zoomOnOf; // 14em parametre
Param<unsigned int> zoom; // 15em parametre
Param<std::string> imageSaveFile;
...

Par un moyen quelconque, je complete un vecteur

std::vector<Base*> paramsVect;

Ex:
paramsVect.push_back(&focusOnOf);
paramsVect.push_back(&focus);
paramsVect.push_back(&zoomOnOf);
paramsVect.push_back(&zoom);
paramsVect.push_back(&imageSaveFile);

Maintenant, ce qu'il reste a faire est de lire la valeur du type correct stockee dans paramsVect[15] et l'envoyer a la camera

ex:: set_zoom_value(paramsVect[15]->value);
set_zoom_on_off(paramsVect[14]->value);

J'espere que j'ai ete assez explicite

Merci

[Laurent Gomila]

En fait ici il suffirait que tu stockes une référence vers la variable qui doit être mise à jour, ainsi tout le traitement peut s'effectuer à l'intérieur de la classe via la fonction virtuelle Set.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template <class type> class Param : public Base
{
public :
 
    Param(type& target) : value(target)
    {}
 
    void Set(std::istringstream is)
    { is >> value; }
 
    type& value;
}

[alpidor]

Merci, j'essaye aussitot