Discussion :

[vandamme]

J'ai un pb tres simple, je veux tranformer un const vector<T> en un vector<T*>.
Voici un extrait de mon code qui le fait :

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
    template<typename T>
    struct ToPtr : public std::unary_function<T, T*>
    {
        T* operator()(const T& value)
        {
            return const_cast<T*>(&value);
        }            
    };
 
template<typename T>
    void MyClass::order(const vector<T>& in,
                        vector<T*>& out) const
    {
 
            out.reserve(in.size());
            std::transform(in.begin(),
                               in.end(),
                               std::back_inserter(out),
                               ToPtr<T>());
}

Ce code marche tres bien mais ce qui me gene c'est le const_cast dans le foncteur. Est - ce qu'il existe une meilleure conception pour convertir un const vector<T> en vector<T*> ?

[JolyLoic]

Tu as un vector<T> const, donc une variable à partir de laquelle tu promets de ne pas modifier le contenu du vecteur. Tu veux obtenir un vector<T*>, qui permet donc de modifier les T contenue dans le premier vecteur.

Il me semble donc normal que tu aies besoin d'un const_cast, puisque tu souhaites ne pas permettre la modification d'objets constants.

Ton code est moralement équivalent à :

Code :

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

1
2
int const i = 3;
int *j = &i;

La vrai question est pourquoi tu souhaites faire ça...

[vandamme]

Simplement parce que T est un tres gros type et que je veux trier les elements du vecteur. Donc je passe par un vecteur de T* qui sera beaucoup plus rapide a trier qu'un vecteur de T .
Mais si tu as une autre solution, je suis preneur.

[koala01]

Simplement parce que T est un tres gros type et que je veux trier les elements du vecteur. Donc je passe par un vecteur de T* qui sera beaucoup plus rapide a trier qu'un vecteur de T .
Mais si tu as une autre solution, je suis preneur.

Qu'est ce qui te fait penser que le T* sera plus rapide à trier que le T&

Si tu veux trier les ardresses, peut etre, mais autrement, je n'en suis pas sur du tout

[Laurent Gomila]

Qu'est ce qui te fait penser que le T* sera plus rapide à trier que le T&

Les nombreuses recopies induites par le tri.

Mais si tu as une autre solution, je suis preneur.

Transforme en vector<const T*>, tu n'auras pas besoin de casser le const.

[koala01]

Les nombreuses recopies induites par le tri.

Ah oui, je n'y avais pas pensé, à celles là

[vandamme]

Les nombreuses recopies induites par le tri.


Transforme en vector<const T*>, tu n'auras pas besoin de casser le const.

OK. j'essaierai cette solution. En fait je pensais que const vector<T*> etait equivalent a vector<const T*>.

Par contre une autre idee me vient pour le tri.
Est ce qu'en utilisant une list au lieu d'un vector, et en particulier sa fonction membre sort, je peux eviter les recopies lors du tri ?