Conversion d'un conteneur de type X en un conteneur de type Y.

Version imprimable

Salut!

J'ai codé 3 classes pour gérer des pointeurs intelligent, la 1ère est équivalente à std::shared_ptr, la seconde à std::unique_ptr et la troisième à std::weak_ptr à part qu'elle est aussi utilisable pour les pointeurs uniques.

J'en ai profité pour rajouté un constructeur qui prend aussi un pointeur, et pas qu'un new.

Ce qui donne quelque chose comme ceci :
Code:

1 2 3 odfaeg::UniquePointer<int> ptr = odfaeg::make_unique<int>(5); odfaeg::WeakPointer tmpptr = ptr;
Bref, la classe WeakPtr sert juste pour l'utilisation temporaire des pointeurs intelligents, donc, l'objet n'est que temporairement propriétaire du pointeur, si le vrai propriétaire est détruit alors le pointeur temporaire devient invalide et une exception est lancée au cas ou on essayerais de l'utiliser.

Tandis que les 2 autres classes servent dans les contextes suivants :

UniquePointer sert à donner la propriété unique du pointeur à un objet et est utilisé dans la plupart des cas.
SharedPointer sert à donner la propriété à plusieurs objets, ce cas, je ne l'utilise que si plusieurs thread utilisent la même ressources et si je ne veux bloquer le programme et attendre que tout les threads aient fini d'utiliser la ressource avant de la libérer.

En plus de cela, UniquePointer et SharedPointer peuvent devenir propriétaire d'un pointeur nu, ils prennent alors la responsabilité de le détruire si par exemple le pointeur doit être alloué autrement que via make_unique ou bien make_shared.

Pour les pointeurs statiques, ceux-ci sont détruit tout à la fin de l'exécution du programme, car, ces classes contiennent un singleton pour tout les pointeurs de même type qui se charge de libérer tout ce qui doit être libéré à la fin du programme. (C'est le deleter et il me sert aussi bien pour les ressources interne c'est à dire celle allouer sur le tas que pour les ressources externes c'est à dire, celles chargée à partir d'une fonction de chargement.)

Bref ceci fonctionne bien (j'ai testé) même dans un contexte multi-thread.

Maintenant, ce que je veux, c'est faire la même chose avec les containers de la STL.

Pour simplifier la syntaxe j'ai fais un bon nombre de usings :
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 template <class H> using SharedVectorPointer = SmartContainerPointer<std::vector<SharedPointer<H>>>; template <class H, class T> using SharedMapPointerK = SmartContainerPointer<std::map<SharedPointer<H>, T>>; template <class H, class T> using SharedMapPointerV = SmartContainerPointer<std::map<H, SharedPointer<T>>>; template <class H, class T> using SharedMapPointer = SmartContainerPointer<std::map<SharedPointer<H>, SharedPointer<T>>>; template <class H> using UniqueVectorPointer = SmartContainerPointer<std::vector<UniquePointer<H>>>; template <class H, class T> using UniqueMapPointerK = SmartContainerPointer<std::map<UniquePointer<H>, T>>; template <class H, class T> using UniqueMapPointerV = SmartContainerPointer<std::map<H, UniquePointer<T>>>; template <class H, class T> using UniqueMapPointer = SmartContainerPointer<std::map<UniquePointer<H>, UniquePointer<T>>>; template <class H> using WeakVectorPointer = SmartContainerPointer<std::vector<WeakPointer<H>>>; template <class H, class T> using WeakMapPointerK = SmartContainerPointer<std::map<WeakPointer<H>, T>>; template <class H, class T> using WeakMapPointerV = SmartContainerPointer<std::map<H, WeakPointer<T>>>; template <class H, class T> using WeakMapPointer = SmartContainerPointer<std::map<WeakPointer<H>, WeakPointer<T>>>;
Ce que je voudrais c'est pouvoir convertir un std::vector de SharedPointer ou bien de UniquePointer en un vector de WeakPointer pour une utilisation temporaire du vecteur de pointeurs.

J'ai alors essayé de faire ceci :
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 template <template <typename> class C, class H> class SmartContainerPointer<C<WeakPointer<H>>> : public C<WeakPointer<H>> { public : SmartContainerPointer<C<WeakPointer<H>>> (const SmartContainerPointer<C<SharedPointer<H>>>& scp) { typename SmartContainerPointer<C<SharedPointer<H>>>::iterator it; for (it = scp.begin(); it != scp.end(); it++) { push_back(WeakPointer<H>(*it)); } } SmartContainerPointer<C<WeakPointer<H>>> (const SmartContainerPointer<C<UniquePointer<H>>>& scp) { typename SmartContainerPointer<C<UniquePointer<H>>>::iterator it; for (it = scp.begin(); it != scp.end(); it++) { push_back(WeakPointer<H>(*it)); } } SmartContainerPointer<C<WeakPointer<H>>>& operator=(const SmartContainerPointer<C<SharedPointer<H>>>& scp) { typename SmartContainerPointer<C<SharedPointer<H>>>::iterator it; for (it = scp.begin(); it != scp.end(); it++) { push_back(WeakPointer<H>(*it)); } return *this; } SmartContainerPointer<C<WeakPointer<H>>>& operator=(const SmartContainerPointer<C<UniquePointer<H>>>& scp) { typename SmartContainerPointer<C<UniquePointer<H>>>::iterator it; for (it = scp.begin(); it != scp.end(); it++) { push_back(WeakPointer<H>(*it)); } return *this; } };
Mais, cela ne fonctionne pas, ce code-ci
Code:

1 2 3 odfaeg::SharedVectorPointer<int> svp; odfaeg::WeakVectorPointer<int> wvp = svp;
Me renvoie à cette erreur là.
Code:

1 2 /home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|5|error: conversion from ‘odfaeg::SharedVectorPointer<int> {aka odfaeg::SmartContainerPointer<std::vector<odfaeg::SharedPointer<int>, std::allocator<odfaeg::SharedPointer<int> > > >}’ to non-scalar type ‘odfaeg::WeakVectorPointer<int> {aka odfaeg::SmartContainerPointer<std::vector<odfaeg::WeakPointer<int>, std::allocator<odfaeg::WeakPointer<int> > > >}’ requested|
N'y a t'il pas moyen de redéfinir l'opérateur= pour convertir un contenaire de type X en un contenaire de type Y ?

J'ai pas envie de recoder la STL pour devoir faire cela. (Malgré mon côté pervers de réinventer la roue pour apprendre.)

Sinon, obligation de passer par un fonction libre pour effectuer la conversion.

l'opérateur = de std::vector affecte t'il le std::vector ou bien chaque élément du vecteur séparément ?

Si c'est la 1ère réponse y a t'il moyen de changer le code de cette classe et de recompiler la STL ?

Merci d'avance pour vos réponse.

04/10/2014, 10h38
Ehonn

Bonjour

Après t'être interrogé sur la nécessité d'une telle opération, fait une fonction libre.
04/10/2014, 10h55
Invité

Re,
j'ai vu qu'il y avait moyen d'utiliser son propre type d'allocator pour tenter une conversion de std::allocator<Derived> en std::allocator<Base>, mais, je n'ai trouvé aucun tutoriel la dessus. (Et ça m'a l'air un peu compliqué à faire)

Le plus simple il me semble ça serait d'utiliser une fonction libre.

Ha voila j'ai trouvé!

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
 
template <typename... T>
class SmartContainerPointer {
 
};
template <template <typename...> class C, class... T>
class SmartContainerPointer<C<T...>> : public C<T...> {
 
};
template <class T>
class SmartContainerPointer<std::vector<WeakPointer<T>>> : public std::vector<WeakPointer<T>> {
    public :
    SmartContainerPointer<std::vector<WeakPointer<T>>> () {
 
    }
    SmartContainerPointer<std::vector<WeakPointer<T>>> (const SmartContainerPointer<std::vector<SharedPointer<T>>>& svp) {
         for(unsigned int i = 0; i < svp.size(); i++) {
            WeakPointer<T> wp(svp[i]);
            std::vector<WeakPointer<T>>::push_back(wp);
         }
    }
    SmartContainerPointer<std::vector<WeakPointer<T>>>& operator= (const SmartContainerPointer<std::vector<SharedPointer<T>>>& svp) {
         for(unsigned int i = 0; i < svp.size(); i++) {
            WeakPointer<T> wp(svp[i]);
            std::vector<WeakPointer<T>>::push_back(wp);
         }
         return *this;
    }
};
template <class H>
using SharedVectorPointer = SmartContainerPointer<std::vector<SharedPointer<H>>>;
template <class H, class T>
using SharedMapPointerK = SmartContainerPointer<std::map<SharedPointer<H>, T>>;
template <class H, class T>
using SharedMapPointerV = SmartContainerPointer<std::map<H, SharedPointer<T>>>;
template <class H, class T>
using SharedMapPointer = SmartContainerPointer<std::map<SharedPointer<H>, SharedPointer<T>>>;
template <class H>
using UniqueVectorPointer = SmartContainerPointer<std::vector<UniquePointer<H>>>;
template <class H, class T>
using UniqueMapPointerK = SmartContainerPointer<std::map<UniquePointer<H>, T>>;
template <class H, class T>
using UniqueMapPointerV = SmartContainerPointer<std::map<H, UniquePointer<T>>>;
template <class H, class T>
using UniqueMapPointer = SmartContainerPointer<std::map<UniquePointer<H>, UniquePointer<T>>>;
template <class H>
using WeakVectorPointer = SmartContainerPointer<std::vector<WeakPointer<H>>>;
template <class H, class T>
using WeakMapPointerK = SmartContainerPointer<std::map<WeakPointer<H>, T>>;
template <class H, class T>
using WeakMapPointerV = SmartContainerPointer<std::map<H, WeakPointer<T>>>;
template <class H, class T>
using WeakMapPointer = SmartContainerPointer<std::map<WeakPointer<H>, WeakPointer<T>>>;

Il ne me reste plus qu'à faire la même chose pour tout.

04/10/2014, 12h24
jo_link_noir
allocator_traits::rebind_alloc (ou Alloc::template rebind<U>::other dans son ancienne forme).

Et simplement ceci :
Code:

1 2 3 vector<odfaeg::SharedPointer> svp; vector<odfaeg::WeakPointer> wvp(svp.begin(), svp.end());

Finalement il y a plus simple avec std::copy :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
template <class T>
class SmartContainerPointer<std::vector<WeakPointer<T>>> : public std::vector<WeakPointer<T>> {
    public :
    SmartContainerPointer<std::vector<WeakPointer<T>>> () {
 
    }
    SmartContainerPointer<std::vector<WeakPointer<T>>> (const SmartContainerPointer<std::vector<SharedPointer<T>>>& svp) {
         std::copy(svp.begin(), svp.end(),std::vector<WeakPointer<T>>::begin());
    }
    SmartContainerPointer<std::vector<WeakPointer<T>>>& operator= (const SmartContainerPointer<std::vector<SharedPointer<T>>>& svp) {
         std::copy(svp.begin(), svp.end(),std::vector<WeakPointer<T>>::begin());
         return *this;
    }
    SmartContainerPointer<std::vector<WeakPointer<T>>> (const SmartContainerPointer<std::vector<UniquePointer<T>>>& svp) {
         std::copy(svp.begin(), svp.end(),std::vector<WeakPointer<T>>::begin());
    }
    SmartContainerPointer<std::vector<WeakPointer<T>>>& operator= (const SmartContainerPointer<std::vector<UniquePointer<T>>>& svp) {
         std::copy(svp.begin(), svp.end(),std::vector<WeakPointer<T>>::begin());
         return *this;
    }
};

08/10/2014, 19h53
ternel

Et tu appelles ca simple? Curieux, j'aurais pas utilisé ce mot là.

Bonjour,

Citation:

Envoyé par Lolilolight

Finalement il y a plus simple avec std::copy :

Pourquoi ne pas utiliser des typedefs pour simplifier le code ? (à noter qu'il y a peut-être une ligne à ajouté vu qu'on est dans un template).

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
 
template <class T>
class SmartContainerPointer<std::vector<WeakPointer<T>>> : public std::vector<WeakPointer<T>> {
 
    typedef std::vector<WeakPointer<T>> Container;
typedef SmartContainerPointer<std::vector<SharedPointer<T>>> SharedContainer;
typedef SmartContainerPointer<std::vector<UniquePointer<T>>> UniqueContainer;
 
public :
    SmartContainerPointer<Container> () {
 
    }
    SmartContainerPointer<Container>  (const SharedContainer &  svp) {
         std::copy(svp.begin(), svp.end(),Container::begin());
    }
     SmartContainerPointer<Container>&  operator= (const SharedContainer &  svp) {
         std::copy(svp.begin(), svp.end(),Container::begin());
         return *this;
    }
    SmartContainerPointer<Container>  (const UniqueContainer &  svp) {
         std::copy(svp.begin(), svp.end(),Container::begin());
    }
     SmartContainerPointer<Container>&  operator= (const UniqueContainer &  svp) {
         std::copy(svp.begin(), svp.end(),Container::begin());
         return *this;
    }
};

Je trouve que c'est déjà un peu plus lisible.
Après, je ne suis pas du tout sur que std::copy va accepter de copier des "UniquePtr (qui devrait logiquement être non-copiable).

Salut, ça ne copie pas le std::UniquePointer, ça le passe juste au constructeur (ou bien à l'opérateur d'affectation) de WeakPointer qui n'est rien d'autre qu'un pointeur temporaire qui permet de déréférencer le pointeur ou bien de l'utiliser.

PS :

Par contre je suis obligé de faire ceci sinon ça crash :

Code:

1
2
3
4
5
 
 SmartContainerPointer<std::vector<WeakPointer<T>>> (const SmartContainerPointer<std::vector<UniquePointer<T>>>& svp) {
         std::vector<WeakPointer<T>>::resize(svp.size(), WeakPointer<T>());
         std::copy(svp.begin(), svp.end(),std::vector<WeakPointer<T>>::begin());
    }

N'y a t'il pas une version de std::copy qui fait un move, pas une copie ?

J'ai essayer quelque chose de ce genre mais ça ne fonctionne pas :

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
 
||=== Build: Debug in ODFAEG (compiler: GNU GCC Compiler) ===|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h||In instantiation of ‘odfaeg::SmartContainerPointer<std::vector<odfaeg::WeakPointer<T>, std::allocator<odfaeg::WeakPointer<T> > > >::SmartContainerPointer(const odfaeg::SmartContainerPointer<std::vector<odfaeg::UniquePointer<R, odfaeg::DefaultDeleter<R> >, std::allocator<odfaeg::UniquePointer<R, odfaeg::DefaultDeleter<R> > > > >&) [with T = odfaeg::BoundingVolume]’:|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/../Graphics/../Physics/boundingVolume.h|39|required from here|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|558|error: no matching function for call to ‘odfaeg::SmartContainerPointer<std::vector<odfaeg::WeakPointer<odfaeg::BoundingVolume>, std::allocator<odfaeg::WeakPointer<odfaeg::BoundingVolume> > > >::to_vector(const odfaeg::SmartContainerPointer<std::vector<odfaeg::UniquePointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> >, std::allocator<odfaeg::UniquePointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> > > > >&)’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|558|note: candidates are:|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|568|note: std::vector<odfaeg::WeakPointer<T> > odfaeg::SmartContainerPointer<std::vector<odfaeg::WeakPointer<T>, std::allocator<odfaeg::WeakPointer<T> > > >::to_vector(std::vector<odfaeg::UniquePointer<R> >&&) [with T = odfaeg::BoundingVolume]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|568|note:   no known conversion for argument 1 from ‘const odfaeg::SmartContainerPointer<std::vector<odfaeg::UniquePointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> >, std::allocator<odfaeg::UniquePointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> > > > >’ to ‘std::vector<odfaeg::UniquePointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> >, std::allocator<odfaeg::UniquePointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> > > >&&’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|572|note: std::vector<odfaeg::WeakPointer<T> > odfaeg::SmartContainerPointer<std::vector<odfaeg::WeakPointer<T>, std::allocator<odfaeg::WeakPointer<T> > > >::to_vector(std::vector<odfaeg::SharedPointer<R> >&&) [with T = odfaeg::BoundingVolume]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|572|note:   no known conversion for argument 1 from ‘const odfaeg::SmartContainerPointer<std::vector<odfaeg::UniquePointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> >, std::allocator<odfaeg::UniquePointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> > > > >’ to ‘std::vector<odfaeg::SharedPointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> >, std::allocator<odfaeg::SharedPointer<odfaeg::BoundingVolume, odfaeg::DefaultDeleter<odfaeg::BoundingVolume> > > >&&’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h||In instantiation of ‘void odfaeg::ResourceManager<R, I>::deleteAll(odfaeg::ResourceManagerBase::TYPE) [with R = void; I = std::basic_string<char>]’:|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|639|required from ‘odfaeg::ResourceManager<R, I>::~ResourceManager() [with R = void; I = std::basic_string<char>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/singleton.h|23|required from ‘odfaeg::ResourceManager<void> odfaeg::Singleton<odfaeg::ResourceManager<void> >::m_i’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/singleton.h|21|required from ‘static T& odfaeg::Singleton<T>::Instance() [with T = odfaeg::ResourceManager<void>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|434|required from here|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|629|warning: deleting ‘void*’ is undefined|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h||In instantiation of ‘odfaeg::ResourceManager<R, I>::Resource::Resource(std::string, R*, odfaeg::ResourceManagerBase::TYPE) [with R = odfaeg::BoundingVolume; I = std::basic_string<char>; std::string = std::basic_string<char>]’:|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|551|required from ‘void odfaeg::ResourceManager<R, I>::insertResource(const string&, R*, odfaeg::ResourceManagerBase::TYPE) [with R = odfaeg::BoundingVolume; I = std::basic_string<char>; std::string = std::basic_string<char>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|348|required from ‘const unsigned int& odfaeg::ResourceManager<R, I>::make_resource(R*, odfaeg::ResourceManagerBase::TYPE) [with R = odfaeg::BoundingVolume; I = std::basic_string<char>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|287|required from ‘odfaeg::UniquePointer<R, Deleter>::UniquePointer(odfaeg::UniquePointer<D>&&) [with D = odfaeg::BoundingBox; R = odfaeg::BoundingVolume; Deleter = odfaeg::DefaultDeleter<odfaeg::BoundingVolume>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/../Graphics/../Physics/boundingBox.h|155|required from here|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|236|warning: ‘odfaeg::ResourceManager<odfaeg::BoundingVolume, std::basic_string<char> >::Resource::path’ will be initialized after [-Wreorder]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|235|warning:   ‘odfaeg::BoundingVolume* odfaeg::ResourceManager<odfaeg::BoundingVolume, std::basic_string<char> >::Resource::resource’ [-Wreorder]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|207|warning:   when initialized here [-Wreorder]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h||In instantiation of ‘odfaeg::ResourceManager<R, I>::Resource::Resource(std::string, R*, odfaeg::ResourceManagerBase::TYPE) [with R = odfaeg::BoundingBox; I = std::basic_string<char>; std::string = std::basic_string<char>]’:|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|551|required from ‘void odfaeg::ResourceManager<R, I>::insertResource(const string&, R*, odfaeg::ResourceManagerBase::TYPE) [with R = odfaeg::BoundingBox; I = std::basic_string<char>; std::string = std::basic_string<char>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|348|required from ‘const unsigned int& odfaeg::ResourceManager<R, I>::make_resource(R*, odfaeg::ResourceManagerBase::TYPE) [with R = odfaeg::BoundingBox; I = std::basic_string<char>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|276|required from ‘odfaeg::UniquePointer<R, Deleter>::UniquePointer(R*) [with R = odfaeg::BoundingBox; Deleter = odfaeg::DefaultDeleter<odfaeg::BoundingBox>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|516|required from ‘odfaeg::UniquePointer<R> odfaeg::make_unique(A&& ...) [with T = odfaeg::BoundingBox; A = {odfaeg::BoundingBox&}; Alloc = odfaeg::DefaultAllocator<odfaeg::BoundingBox>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/../Graphics/../Physics/boundingBox.h|155|required from here|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|236|warning: ‘odfaeg::ResourceManager<odfaeg::BoundingBox, std::basic_string<char> >::Resource::path’ will be initialized after [-Wreorder]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|235|warning:   ‘odfaeg::BoundingBox* odfaeg::ResourceManager<odfaeg::BoundingBox, std::basic_string<char> >::Resource::resource’ [-Wreorder]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|207|warning:   when initialized here [-Wreorder]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h||In instantiation of ‘odfaeg::ResourceManager<R, I>::Resource::Resource(std::string, R*, odfaeg::ResourceManagerBase::TYPE) [with R = odfaeg::BoundingPolyhedron; I = std::basic_string<char>; std::string = std::basic_string<char>]’:|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|551|required from ‘void odfaeg::ResourceManager<R, I>::insertResource(const string&, R*, odfaeg::ResourceManagerBase::TYPE) [with R = odfaeg::BoundingPolyhedron; I = std::basic_string<char>; std::string = std::basic_string<char>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|348|required from ‘const unsigned int& odfaeg::ResourceManager<R, I>::make_resource(R*, odfaeg::ResourceManagerBase::TYPE) [with R = odfaeg::BoundingPolyhedron; I = std::basic_string<char>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|276|required from ‘odfaeg::UniquePointer<R, Deleter>::UniquePointer(R*) [with R = odfaeg::BoundingPolyhedron; Deleter = odfaeg::DefaultDeleter<odfaeg::BoundingPolyhedron>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/resourceCache.h|516|required from ‘odfaeg::UniquePointer<R> odfaeg::make_unique(A&& ...) [with T = odfaeg::BoundingPolyhedron; A = {odfaeg::BoundingPolyhedron&}; Alloc = odfaeg::DefaultAllocator<odfaeg::BoundingPolyhedron>]’|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/../Graphics/2D/../../Core/../Graphics/../Physics/boundingPolyhedron.h|55|required from here|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|236|warning: ‘odfaeg::ResourceManager<odfaeg::BoundingPolyhedron, std::basic_string<char> >::Resource::path’ will be initialized after [-Wreorder]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|235|warning:   ‘odfaeg::BoundingPolyhedron* odfaeg::ResourceManager<odfaeg::BoundingPolyhedron, std::basic_string<char> >::Resource::resource’ [-Wreorder]|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/ResourceManager.h|207|warning:   when initialized here [-Wreorder]|
||=== Build failed: 1 error(s), 50 warning(s) (0 minute(s), 4 second(s)) ===|

09/10/2014, 19h11
jo_link_noir

std::back_inserter
std::vector::assign (ou constructeur)
std::move_iterator

Et un simple truc comme ça ça fait pas l'affaire ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct A {};
struct B { B& operator=(const A& _src) { return *this; } B(const A& _src) { *this = _src; } };
 
template< class Src, class Dst >
void Convert(const vector<Src>& _in, vector<Dst>* _out)
{
  assert(_out);
  _out.clear();
  _out.reserve(_int.size());
  for (size_t i = 0, t = _in.size(); i < t; ++i)
    _out.push_back(_in[i]);
}
 
vector<A> vec;
vector<B>  vecB;
Convert(vec, &vecB);

sinon les méthodes de jo semblent idéales