la façon la plus rapide pour convertir un std::vector pour un autre std::vector

Il n'y a aucun moyen d'éviter la copie, depuis un std::vector<T> est distincte
type de std::vector<U>, et il n'y a aucun moyen pour eux de partager les
de la mémoire. Autre que cela, il dépend de la façon dont les données sont mappées. Si l'
cartographie correspond à une conversion implicite (par exemple, unsigned short à
bool), puis il suffit de créer un nouveau vecteur à l'aide de la fin et de début de
les itérateurs de la vieille va faire l'affaire:

std::vector<bool> newV( oldV.begin(), oldV.end() );

Si la cartographie n'est pas seulement une conversion implicite (et cela inclut
les cas où vous souhaitez vérifier les choses; par exemple, que le unsigned short
ne contenir que 0 ou 1), ensuite cela devient plus compliqué. L'
la solution la plus évidente serait d'utiliser std::transform:

std::vector<TargetType> newV;
newV.reserve( oldV.size() );    // avoids unnecessary reallocations
std::transform( oldV.begin(), oldV.end(),
                std::back_inserter( newV ),
                TranformationObject() );

où TranformationObject est un objet fonctionnel qui ne l'
transformation, par exemple:

struct ToBool : public std::unary_function<unsigned short, bool>
{
    bool operator()( unsigned short original ) const
    {
        if ( original != 0 && original != 1 )
            throw Something();
        return original != 0;
    }
};

(Notez que je suis juste en utilisant cette fonction de transformation comme un exemple.
Si la seule chose qui distingue la transformation de la fonction de
une conversion implicite est de la vérification, il peut être plus rapide pour vérifier
toutes les valeurs de oldV d'abord, à l'aide de std::for_each, et ensuite utiliser
les deux itérateur constructeur ci-dessus).

Selon le coût de défaut de construire le type de cible, il peut être
plus rapide pour créer le nouveau vecteur avec la bonne taille, puis écraser
c':

std::vector<TargetType> newV( oldV.size() );
std::transform( oldV.begin(), oldV.end(),
                newV.begin(),
                TranformationObject() );

Enfin, une autre possibilité serait d'utiliser un
boost::transform_iterator. Quelque chose comme:

std::vector<TargetType> newV(
    boost::make_transform_iterator( oldV.begin(), TranformationObject() ),
    boost::make_transform_iterator( oldV.end(), TranformationObject() ) );

À de nombreux égards, c'est la solution que je préfère, selon la façon dont
boost::transform_iterator a été mis en œuvre, il pourrait également être le
la plus rapide.

OriginalL'auteur James Kanze

Le moyen le plus rapide de le faire est de pas le faire. Par exemple, si vous savez à l'avance que vos articles seulement besoin d'un octet pour le stockage, l'utilisation d'un taille en octets de vecteur pour commencer. Vous trouverez qu'il est difficile de trouver un moyen plus rapide que ça 🙂

Si ce n'est pas possible, alors il suffit d'absorber le coût de la conversion. Même si c'est un peu lent (et c'est pas sûr, voir Nicol est une excellente réponse pour plus de détails), il est toujours nécessaire. Si ce n'était pas le cas, vous serait tout simplement le laisser dans le plus grand type de vecteur.

OriginalL'auteur paxdiablo

Tout d'abord, un avertissement: "ne faites pas ce que je suis sur le point de suggérer. C'est dangereux et ne doit jamais être fait. Cela dit, si vous venez de prendre un tout petit peu plus les performances de N'Importe Quoi...

Tout d'abord, il y a quelques mises en garde. Si vous ne respectez pas les présentes, vous ne pouvez pas faire ceci:

1. Le vecteur doit contenir plaine-vieux-données. Si votre type a des pointeurs, ou utilise un destructeur, ou a besoin d'un opérateur = pour copier correctement ... ne le faites pas.

2. Le sizeof() à la fois vecteur de contenus types doivent être les mêmes. C'est, vector< A > pouvez copier vector< B > que si sizeof(A) == sizeof(B).

Ici est assez stable méthode:

vector< A > a;
vector< B > b;
a.resize( b.size() );
assert( sizeof(vector< A >::value_type) == sizeof(vector< B >::value_type) );
if( b.size() == 0 )
   a.clear();
else
   memcpy( &(*a.begin()), &(*b.begin()), b.size() * sizeof(B) );

Ce qui fait un très rapide, bloc copie de la mémoire contenue dans le vecteur b, directement brisant toutes les données que vous avez dans un vecteur. Il n'a pas d'appel des constructeurs, il ne fait pas de vérification de la sécurité, et c'est beaucoup plus rapide que les autres méthodes présentées ici. Un compilateur optimisant devrait être en mesure de correspondre à la vitesse de la ce en théorie, mais sauf si vous êtes en utilisant une exceptionnellement bonne, il ne va pas (j'ai vérifié avec Visual C++ il y a quelques années, et il n'était même pas proche).

Aussi, compte tenu de ces contraintes, vous pourriez force (via void *) dispose que d'un seul type de vecteur à l'autre et l'échange -- j'ai eu un exemple de code pour cela, mais il a commencé à suinter de l'ectoplasme sur mon écran, donc je l'ai supprimé.

OriginalL'auteur AHelps

#ifdef VECTOR_H_TYPE1
#ifdef VECTOR_H_TYPE2
#ifdef VECTOR_H_CLASS
/* Other methods can be added as needed, provided they likewise carry out the same operations on both */

#include <vector>

using namespace std;

class VECTOR_H_CLASS {
public:
        vector<VECTOR_H_TYPE1> *firstVec;
        vector<VECTOR_H_TYPE2> *secondVec;

        VECTOR_H_CLASS(vector<VECTOR_H_TYPE1> &v1, vector<VECTOR_H_TYPE2> &v2) { firstVec = &v1; secondVec = &v2; }
        ~VECTOR_H_CLASS() {}

        void init() { //Use this to copy a full vector into an empty (or garbage) vector to equalize them
                secondVec->clear();
                for(vector<VECTOR_H_TYPE1>::iterator it = firstVec->begin(); it != firstVec->end(); it++) secondVec->push_back((VECTOR_H_TYPE2)*it);
        }

        void push_back(void *value) {
                firstVec->push_back((VECTOR_H_TYPE1)value);
                secondVec->push_back((VECTOR_H_TYPE2)value);
        }

        void pop_back() {
                firstVec->pop_back();
                secondVec->pop_back();
        }

        void clear() {
                firstVec->clear();
                secondVec->clear();
        }
};
#undef VECTOR_H_CLASS
#endif
#undef VECTOR_H_TYPE2
#endif
#undef VECTOR_H_TYPE1
#endif

OriginalL'auteur Jerry Miller