Discussion :

[bill86]

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 :

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

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 :

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

1
2
3
4
class AA
{
TTT(vector<UU>,vector<UU>,vector<UU>);
}

avec UU est un objet de classe UU.

Merci d'avance.

[Firwen]

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é ?

[bill86]

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?

[Joel F]

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.

[bill86]

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.

[3DArchi]

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.

[koala01]

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

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 :

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

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 :

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
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 :

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

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;
}

[bill86]

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