Comment ajouter un élément par élément des deux STL vecteurs?

Si vous essayez d'ajouter un vector à l'autre, vous pouvez utiliser quelque chose comme ce qui suit. Ces sont l'un de mes utilitaires bibliothèques--deux operator+= surcharges pour std::vector: on ajoute un élément unique dans la vector, l'autre ajoute un ensemble de vector:

template <typename T>
std::vector<T>& operator+=(std::vector<T>& a, const std::vector<T>& b)
{
    a.insert(a.end(), b.begin(), b.end());
    return a;
}

template <typename T>
std::vector<T>& operator+=(std::vector<T>& aVector, const T& aObject)
{
    aVector.push_back(aObject);
    return aVector;
}

Si vous essayez d'effectuer une sommation (qui est, de créer un nouveau vector contenant la somme des éléments des deux autres vectors), vous pouvez utiliser quelque chose comme ce qui suit:

#include <algorithm>
#include <functional>

template <typename T>
std::vector<T> operator+(const std::vector<T>& a, const std::vector<T>& b)
{
    assert(a.size() == b.size());

    std::vector<T> result;
    result.reserve(a.size());

    std::transform(a.begin(), a.end(), b.begin(), 
                   std::back_inserter(result), std::plus<T>());
    return result;
}

Vous pourrait également mettre en œuvre un operator+= surcharge.

Un exemple concret de Jon Reid réponse:

std::array<double,3> a = {1, 2, 3};
std::array<double,3> b = {4, 5, 6};
std::transform(a.begin( ), a.end( ), b.begin( ), a.begin( ),std::plus<double>( ));
ASSERT_TRUE(a[0] == 5);
ASSERT_TRUE(a[1] == 7);
ASSERT_TRUE(a[2] == 9);

Si votre code est segfaulting alors que c'est d'une justesse question, pas une efficacité de problème.

Pour atteindre le "u[i] = u[i] + v[i] pour tout i", je le ferais, fondamentalement, ce que vous avez fait:

assert(u.size() == v.size()); //will fail with your initialization code, since
                              //your "result" has size 0, not size 10.
                              //perhaps do u.resize(v.size());
for (size_t i = 0; i < u.size(); ++i) {
    u[i] += v[i];
}

Si vous vous souciez vraiment de la performance de votre programme (qui est, vous avez écrit une version de base et c'est tellement lent que votre programme est en défaut, dans une certaine mesure, et vous avez prouvé que c'est le code là où la plupart du temps), alors vous pourriez essayer:

• de commutation sur les lots de l'optimisation de votre compilateur (en fait, j'ai l'habitude de le faire par défaut, même quand il n'y a pas un problème de performance),
• utilisation des itérateurs à la place de l'index (rarement fait beaucoup de différence, mais il est assez facile de comparer les deux),
• de dérouler la boucle un peu (peut faire une peine de différence de vitesse, mais c'est assez sensible pour le cas particulier, et il encourage les erreurs de codage).
• à la recherche à la plate-forme spécifique d'instructions SIMD plutôt que C++. Utilisez ensuite intégré l'assembleur ou le compilateur intrinsèques de ces instructions.

Néanmoins, vous n'avez rien à vous soucier de la performance avant que votre code est correct ;-). "Faire fonctionner, faire droit, rendre rapide" est raisonnable devise, bien souvent, vous n'avez pas besoin d'aller aussi loin que l'étape 3.

std::valarray a en fait exactement le operator+= vous le souhaitez. Avant de remplacer tous vos vecteurs avec valarrays, sachez que ne veut pas forcément dire qu'elle est "plus efficace" que d'une simple boucle - je ne sais pas comment sérieusement les responsables de l'implémentation de prendre valarray. Vous pouvez toujours regarder la source de la mise en œuvre. Aussi, je ne sais pas pourquoi les données multiples arithmétique des fonctionnalités de valarray n'était pas défini dans le cadre de vector, mais il y a généralement une raison.

Le code semble bien, mais mon premier réflexe serait de modifier n'importe quel code est le remplissage de la forme d'un vecteur de valeurs à ajouter aux valeurs de la première vecteur pour prendre en référence à la première vectoriels et ajouter directement plutôt que de créer un nouveau vecteur qui revient. C'est seulement inefficace.

Si vous ne pouvez pas modifier la fonction de cette façon, peut-être vous pouvez le modifier afin qu'il prenne une référence à un vecteur qui il dégage et puis insère les valeurs en sorte que vous ne sont pas la copie de vecteurs autour. Qui peut être coûteux si vous le faites bien.

Un autre pinailler si vous essayez d'obtenir le plus vite possible, vous devriez utiliser la pré-incrémentation avec les itérateurs plutôt que de la post-incrémentation. Le temporaire qui de post-incrémentation crée ne peut pas être optimisé à l'écart lorsque vous traitez avec des opérateurs surchargés plutôt que de types intégrés. Ainsi, vous gardez la création et la destruction temporaire de chaque itération de la boucle. EDIT: Comme il a été souligné dans les commentaires, vous êtes à l'aide d'indices ici plutôt que de les itérateurs (évidemment je n'étais pas assez d'attention), donc ce conseil ne s'applique pas ici. Toutefois, dans le cas où vous sont utilisation des itérateurs, c'est toujours valide.

Autre que cela, si vous essayez d'ajouter tous les éléments de deux vecteurs en collaboration, ce que vous avez est probablement la plus efficace d'une solution que vous allez obtenir. Il existe de meilleures façons si ce que vous êtes inquiète, c'est d'insérer les éléments d'un vecteur dans un autre, mais si vous êtes juste en ajoutant leurs valeurs, ce que vous avez l'air bon. Je m'attends à ce que l'utilisation de tout algorithmes de la STL serait, au mieux, tout aussi rapide et probablement plus lent en raison supplémentaire d'appels de fonction, mais vous auriez probablement à profil pour être sûr.