Comment initialiser std :: vector à partir d'un tableau de style C?

Quelle est la manière la moins chère d'initialiser un std::vector partir d'un tableau de style C?

Exemple: dans la classe suivante, j'ai un vector, mais en raison de restrictions extérieures, les données seront transmises sous forme de tableau de style C:

class Foo {
  std::vector<double> w_;
public:
  void set_data(double* w, int len){
   // how to cheaply initialize the std::vector?
}

De toute évidence, je peux appeler w_.resize()puis boucler sur les éléments, ou appeler std::copy(). Existe-t-il de meilleures méthodes?

N'oubliez pas que vous pouvez traiter les pointeurs comme des itérateurs:

w_.assign(w, w + len);

Vous utilisez le mot initialiser pour que l'on ne sache pas s'il s'agit d'une affectation ponctuelle ou peut se produire plusieurs fois.

Si vous avez juste besoin d'une initialisation unique, vous pouvez la placer dans le constructeur et utiliser le constructeur de vecteur à deux itérateurs:

Foo::Foo(double* w, int len) : w_(w, w + len) { }

Sinon, utilisez assign comme suggéré précédemment:

void set_data(double* w, int len)
{
    w_.assign(w, w + len);
}

Vous pouvez `` apprendre '' automatiquement la taille du tableau:

template<typename T, size_t N>
void set_data(const T (&w)[N]){
    w_.assign(w, w+N);
}

J'espère que vous pouvez changer l'interface en set_data comme ci-dessus. Il accepte toujours un tableau de style C comme premier argument. Il arrive juste de le prendre par référence.

Comment ça fonctionne

[Mise à jour: voir ici pour une discussion plus complète sur l'apprentissage de la taille]

Voici une solution plus générale:

template<typename T, size_t N>
void copy_from_array(vector<T> &target_vector, const T (&source_array)[N]) {
    target_vector.assign(source_array, source_array+N);
}

Cela fonctionne car le tableau est passé en tant que référence à un tableau. En C / C ++, vous ne pouvez pas passer un tableau en tant que fonction, au lieu de cela, il se désintégrera en un pointeur et vous perdrez la taille. Mais en C ++, vous pouvez passer une référence au tableau.

Passer un tableau par référence nécessite que les types correspondent exactement. La taille d'un tableau fait partie de son type. Cela signifie que nous pouvons utiliser le paramètre de modèle N pour connaître la taille pour nous.

Il pourrait être encore plus simple d'avoir cette fonction qui renvoie un vecteur. Avec les optimisations du compilateur appropriées en vigueur, cela devrait être plus rapide qu'il n'y paraît.

template<typename T, size_t N>
vector<T> convert_array_to_vector(const T (&source_array)[N]) {
    return vector<T>(source_array, source_array+N);
}

Eh bien, Pavel était proche, mais il existe même une solution plus simple et élégante pour initialiser un conteneur séquentiel à partir d'un tableau de style ac.

Dans ton cas:

w_ (array, std::end(array))

• array nous obtiendra un pointeur vers le début du tableau (n'a pas attrapé son nom),
• std :: end (array) nous obtiendra un itérateur à la fin du tableau.

La réponse générique rapide:

std::vector<double> vec(carray,carray+carray_size); 

ou question spécifique:

std::vector<double> w_(w,w+len); 

basé sur ci - dessus : n'oubliez pas que vous pouvez traiter les pointeurs comme des itérateurs

std::vector<double>::assignc'est la voie à suivre, car c'est peu de code . Mais comment ça marche, en fait? N'est-il pas redimensionné puis copié? Dans l'implémentation MS de STL, je l'utilise exactement.

J'ai peur qu'il n'y ait pas de moyen plus rapide d'implémenter (ré) initialiser votre std::vector.