Cast, un vecteur de string vers un vecteur d'objets

Salut,

J'aimerais passer en paramètre d'une fonction un vecteur de string et faire forcer son type pour qu'il soit un vecteur d'objets, mais ça n'a pas marché.
J'ai cherché dans la FAQ et sur le net des exemples pareils mais je n'ai pas trouvé.
pourriez vous m'aider?

Voilà la fonction :
Code:

1 2 3 4 5 6 7 main() { .... vector<string> vect1; //idem pr vect2 et vect3 TTT(vect1,vect2, vect3); ... }
et voilà la classe contenant la fonction :
Code:

1 2 3 4 class AA { TTT(vector<UU>,vector<UU>,vector<UU>); }
avec UU est un objet de classe UU.

Merci d'avance.

si j'ai bien compris tu veux passé d'un vecteur de string à un vecteur généric ?

c'est possible mais je peux savoir pourquoi tu veux faire ça, ça ma l'air plus de la bidouille qu'une vrai nécessité ?

Non c'est pas de la bidouille. je vous explique pourquoi, j'ai tout d'abord crée un vecteur de string, où chaque case représente un label. Le problème est que je veux ajouter dans chaque case d'autres informations au label, donc je dois créer un vecteur d'objets de classe UU comme c'est indiqué; Donc au lieu de créer des objets UU pour chaque élément du vecteur et de faire passer en paramètre un vecteur de UU, pouurquoi ne pas passer un vecteur de string? et grâce au casting, C++ se charge de la conversion du String vers UU.
Qu'est ce que vous en pensez?

oui mais c'ets parce que il existe un cast de string vers UU que ce cast est automatique entre vector<string> et vector<UU>.

Utilise std::transform ou planifie mieux ton design qui m'a l'air plus que bancal.

Salut,

ça va me prendre du temps, et je dois vite continuer à programmer, je vais créer des objets UU et je vais faire passer des vecteur de UU.

Merci quand même pour votre réponse.

comme le dit joel, std::transform semble encore la moins pire approche et ne prendra pas plus de temps à coder qu'un cast bancal qui risque d'avoir des effets imprévus.

Salut,

De manière générale, j'aurais déjà tendance à... encapsuler les chaines de caractères d'une part et les conteneurs d'autre part.

Comprend moi bien:

Il n'est pas impossible que tu utilise "quelque part" des chaines de caractères "telles quelles".

Mais, tu va les utiliser "ailleurs" pour créer tes objet de type UU.

Tu auras donc, normalement, un constructeur pour UU qui... prend, entre autres, une chaine de caractères, et qui servira de moyen de conversion (implicite) de ta chaine de caractères en un objet de type UU.

Il vaut mieux éviter les mutateur pour ton type UU, car on peut estimer que, si tu modifie cette chaine de caractères, tu te retrouve avec... un objet différent :P

Et donc, l"idéal serait, selon moi, de créer... ta propre classe qui agira comme un conteneur d'objets de type UU.

Cette classe manipulera en interne éventuellement un vecteur d'objets de type UU, mais pourrait tout à fait, selon le cas, tout aussi bien manipuler une liste, une pile, une file ou, pourquoi pas, un set ou une map d'objets ;)

Après tout, les services 'on demanderait à cette classe supplémentaire seraient, par exemple:

de permettre de créer un ensemble d'objet au départ d'un "range" de chaines de caractères
de savoir si un objet identifié par une chaine de caractères particulière existe
de pouvoir rajouter un objet en lui passant uniquement une chaine de caractères
de pouvoir accéder au "premier" objet, sous forme constante et éventuellement sous forme non constante
de pouvoir accéder au "dernier" objet, sous forme constante et éventuellement sous forme non constante
de pouvoir, éventuellement, supprimer un objet particulier sur base de la chaine de caractères qui le défini
de pouvoir, éventuellement récupérer un itérateur sur l'objet identifié par une chaine de caractère donnée
de pouvoir, éventuellement, trier les objets sur base des chaines de caractères qui les définissent
de pouvoir, éventuellement, savoir le nombre total d'objets présents dans la collection
Le tout, en cachant à l'utilisateur le fait que les objets sont représentés dans un vecteur.

Tu aurais donc une classe UU proche de
Code:

1 2 3 4 5 6 7 8 9 class UU { public: UU(std::string const & n ):n_(n){} /* l'accesseur peut s'avérer utile... ou non */ std::string const & getN() const{return n_;} private: std::string n_; };
et la classe qui gère les objets de type UU serait proche de
Code:

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 class Conteneur { /* pour la facilité */ std::vector<UU> vector; public: /* pour te permettre, en cas de besoin, de changer de type * de conteneur, sans devoir modifier chaque endroit du code * qui essaye d'accéder aux éléments (bien que la re compilation * soit nécessaire :-P) */ typedef vector::const_iterator const_iterator; /* éventuellement */ typedef vector::iterator iterator; /* le constructeur qui permet d'avoir une collection vide */ Conteneur(){} /* et celui qui permet d'avoir une collection "déjà remplie" */ template <typename iter> Conteneur(iter b, iter e):items_(b,e){} /* les fonctions qui permettent d'accéder au début de la collection * et à sa fin * * En version constante */ const_iterator begin() const{return items_.begin();} const_iterator end() const{return items_.end();} /* Et éventuellement en version non constante */ iterator begin() {return items_.begin();} iterator end() {return items_.end();} /* la fonction qui permet, éventuellement, de rajouter un objet à * la collection */ void add(std::string const & n) { /* selon le cas, il faudra veiller ou non à l'unicité ;) */ items_.push_back(UU(n)); } /* la fonction qui permet, éventuellement, de retrouver l'objet * identifié par une chaine de caractères */ /* sous sa forme constante */ const_iterator find(std::string const & n ) const { /* je ne vais pas tout faire pour toi ;) */ } /* et, éventuellement sous sa forme non constante */ iterator find(std::string const & n ) { /* je ne vais pas tout faire pour toi ;) */ } /* la fonction permettant éventuellement de savoir si un objet * existe */ bool exists(std::string const & n) const { return find(n)!=items_.end(); } /* éventuellement, la fonction permettant de trier les objets */ void sort() { /* à toi de jouer */ } /* et, éventuellement, la fonction permettant de savoir combien * d'objets se trouvent dans la collection */ size_t size() const{return items_.size();} private: /* sans oublier... le membre "qui va bien" */ vector items_; };
Le tout serait, par exemple, utilisé sous la forme de
Code:

1 2 3 4 5 6 7 8 int main() { std::vector<std::string> tab; /* remplissage du vecteur de cahaines de caractères */ Conteneur objects(tab.begin(), tab.end()); /* utilisation de objects */ return 0; }

Encore merci koala01,
Une explication très détaillée, Je peut avoir plus :)
Merci beaucoup.