Ajouter plusieurs valeurs d'un vecteur

J'ai un vecteur d'entiers que je veux ajouter plusieurs valeurs trop mais trop grand nombre de valeurs à ajouter à l'aide de beaucoup de push_backs. Existe t'il une méthode d'ajout de plusieurs valeurs à la fin d'un vecteur. Quelque chose le long des lignes de ce:

std::vector<int> values
values += {3, 9, 2, 5, 8, etc};

J'ai trouvé que boost a quelque chose comme cela, mais je ne voudrais pas avoir à inclure coup de pouce.

#include <boost/assign/std/vector.hpp>

using namespace boost::assign;

{
    std::vector<int> myElements;
    myElements += 1,2,3,4,5;
}

Qui semble être déclaré comme ceci:

template <class V, class A, class V2>
inline list_inserter<assign_detail::call_push_back<std::vector<V,A> >, V> 
operator+=( std::vector<V, A>& c, V2 v )
{
    return push_back( c )( v );
}

Est-il C++/C++11 façon de le faire, ou, sinon, comment serait-il mis en œuvre?

eh bien... vous pourriez utiliser le boost de code que vous venez de lire et de le reproduire.
En quelque sorte liée est stackoverflow.com/q/14561941/3235496

OriginalL'auteur Eejin | 2014-11-11

addition c++vector

3

Vous pouvez simplement faire un opérateur:
```
template <class T>
std::vector<T>& operator+=(std::vector<T>& lhs, std::initializer_list<T> l)
{
    lhs.insert(std::end(lhs), l);
    return lhs;
}
```
Il y a un problème ennuyeux avec ce que je n'ai jamais vraiment trouvé une bonne solution; si vous mettez cette fonction dans l'espace de noms global et puis vous essayez de l'utiliser dans un espace de noms dans lequel vous avez défini un de complètement différent operator+=, alors cette fonction est caché. Pour contourner cela, vous avez à faire using ::operator+= dans tout espace qui déclare un autre operator+=. Ce n'est trouvé par ADL parce que ce serait seulement vérifier namespace std (et on ne peut pas mettre cela dans namespace std parce que le code de l'utilisateur ne peut pas le faire).
Je suis conscient de cela. J'aurais ajouté un commentaire à ce sujet.
Il n'est pas trop tard!

OriginalL'auteur 0x499602D2

Cela devrait fonctionner:

std::vector<int> values;
values.insert( values.end(), { 1, 2, 3, 4 } );

OriginalL'auteur Slava

Peut-être avec insérer:

values.insert( values.end(),  {3, 9, 2, 5, 8, etc} );

Démo.

OriginalL'auteur Columbo

4

Afin de présenter, autant que possible, des solutions, cela devrait fonctionner:
```
for(const auto x : {11, 12, 13, 14})
    v.push_back(x);
```
Démo.

OriginalL'auteur Tacet

Vous pouvez imiter le coup de pouce boost::assign comportement

template <typename T> 
class vector_adder 
{
public:
    std::vector<T>& v;
    vector_adder(std::vector<T>& v):v(v)
    {  }

    vector_adder& operator,(const T& val)
    {  
       v.push_back(val);
       return *this;
    }
};

template <typename T> 
vector_adder<T> operator+=(std::vector<T>& v,const T& x)
{
    return vector_adder<T>(v),x;
}

Puis,

 std::vector<int> v {1,2,3,4};
 v += 11,12,13,14 ;

^{Voir ici}

OriginalL'auteur P0W

1

Vous pouvez le faire en utilisant l'insert de la fonction membre, en tant que tel:
```
vector<int> v; 
int myarr[] {1, 2, 4, 5, 5, 6, 6, 8}; //brace initialization with c++11

v.insert(v.end(), myarr, myarr+8);
```
Il y avait une réponse précédente qui a omis le milieu argument dans le menu paramètres, mais que l'on n'a pas de travail. Il existe plusieurs formats à suivre pour la méthode d'insertion, qui peut être trouvé ici et l'extrait de code que j'ai écrit pratiquement suit ce format:

vectorName.insert(position de début de la saisie des valeurs, la première valeur à entrer, combien de valeurs d'entrée)

Remarque: notez Que les deux derniers arguments (c'est à dire myarr, myarr+8) utiliser le pointeur de l'arithmétique. myarr est l'adresse en mémoire du premier élément du tableau, et la seconde valeur est l'adresse de la 8ème élément. Vous pouvez lire sur l'arithmétique des pointeurs ici.

Espère que ça aide!

OriginalL'auteur nopenopenope

Vous devez vous connecter pour publier un commentaire.