utilisation de std::accumulate

Besoin de plus joli solution de l'exemple ci-dessous, mais avec std::accumulate.

#include <algorithm>
#include <vector>
#include <iostream>

class Object
{
public:
    Object( double a, double b ):
        a_( a ),
        b_( b )
    {}

    double GetA() const { return a_; }
    double GetB() const { return b_; }
    //other methods
private:
    double a_;
    double b_;
};

class Calculator
{
public:
    Calculator( double& result ):
        result_( result )
    {}

    void operator() ( const Object& object )
    {
        //some formula
        result_ += object.GetA() * object.GetB();
    }
private:
    double& result_;
};

int main()
{
    std::vector< Object > collection;
    collection.push_back( Object( 1, 2 ) );
    collection.push_back( Object( 3, 4 ) );

    double result = 0.0;
    std::for_each( collection.begin(), collection.end(),
                   Calculator( result ) );

    std::cout << "result = " << result << std::endl;

    return 0;
}

Alors pourquoi ne pas utiliser std::accumulate? Quelle est exactement la question?
Bon, je me demandais qu'est-ce que mon code est manquant 🙂
Acumulate retourne quoi? J'ai pensé qu'il retourne le même type comme un objet, non?
vector<T>::value_type qui dans votre cas sera un double.
pourquoi vector<T>::valie_type est double et n'est l'Objet?

OriginalL'auteur Mykola Golubyev | 2009-03-06

c++stl

faire des changements dans le Calculateur et la fonction principale.

struct Calculator
{
    double operator() ( double result, const Object& obj )
    {
        return result + ( obj.GetA() * obj.GetB());
    }

};

int main()
{
    std::vector< Object > collection;
    collection.push_back( Object( 1, 2 ) );
    collection.push_back( Object( 3, 4 ) );

    double result = std::accumulate( collection.begin(), collection.end(), 0, Calculator() );
    std::cout << "result = " << result << std::endl;

    return 0;
}

en outre, il pourrait être mieux:

double sumABProduct( double result, const Object& obj )
{
    return result + ( obj.GetA() * obj.GetB());
}

double result = std::accumulate( collection.begin(), collection.end(), 0, sumABProduct );

OriginalL'auteur bayda

Mise À Jour 2: Coup De Pouce.Lambda en fait un morceau de gâteau:

//headers
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
using namespace boost::lambda;
//...
cout << accumulate(dv.begin(), dv.end(), 
                   0, 
                   _1 += bind(&strange::value, _2)) //strange defined below
     << endl;

Mise à jour: Cette a été mise sur écoute de moi pendant un moment. Je ne peux pas juste faire de la STL algorithmes de travailler d'une manière décente. Donc, j'ai roulé ma propre:

//include whatever ...
using namespace std;

//custom accumulator that computes a result of the 
//form: result += object.method();
//all other members same as that of std::accumulate
template <class I, class V, class Fn1, class Fn2>
V accumulate2(I first, I last, V val, Fn1 op, Fn2 memfn) {
    for (; first != last; ++first)
        val = op(val, memfn(*first));
    return val;
}

struct strange {
    strange(int a, int b) : _a(a), _b(b) {}
    int value() { return _a + 10 * _b; }
    int _a, _b;
};

int main() {
    std::vector<strange> dv;
    dv.push_back(strange(1, 3));
    dv.push_back(strange(4, 6));
    dv.push_back(strange(20, -11));        
    cout << accumulate2(dv.begin(), dv.end(), 
                        0, std::plus<int>(), 
                        mem_fun_ref(&strange::value)) << endl;
}

Bien sûr, la solution d'origine tient toujours:
Le plus simple est de mettre en œuvre un operator+. Dans ce cas:

double operator+(double v, Object const& x) {
        return v + x.a_;
}

et en faire un ami de Object ou membre (pourquoi on peut préférer l'un sur l'autre):

class Object
{
   //...
  friend double operator+(double v, Object const& x);

et vous êtes fait avec:

 result = accumulate(collection.begin(), collection.end(), 0.0);

Mon heure approche ne fonctionne pas parce que nous avons besoin d'un binary_function.

std::accumulate manuel.

Merci pour le manuel. Mais ton code ne compile pas.
"résultat" n'est pas initialisé.
Je pense que le troisième paramètre à s'accumuler doit être de 0 pas de résultat. le résultat n'a pas encore été défini à ce stade.
À droite sur. Copier collé qui de OPs code 😛
Il ne devrait pas. 0 est un entier (int). Passer 0.0, qui est un double.

OriginalL'auteur dirkgently

ici est un problème ici, je suppose que les arguments sont écrites dans le mauvais ordre devrait être:

result = std::accumulate(collection.begin(), collection.end(), Object(0),Adapt())
where Adapt is defined thus:

struct Adapt { 
    static double mul(Object const &x) { return x.GetA() * x.GetB(); }
    static Object operator()(Object const &x, Object const &y) { 
       return Object(mul(x)+mul(y)) ; } };

dans ce cas de s'accumuler, le résultat est contenu dans un Objet retourné.

Si vous utilisez gnu mode parallèle le foncteur vous donneront des problèmes si la raison et le réel de l'objet référencé par l'itérateur sont différents.

struct Adapt { 
        static double mul(Object const &x) { return x.GetA() * x.GetB(); }
        static double operator()(Object const &x, Object const &y) { 
           return mul(x)+mul(y) ; } };
result = std::accumulate(collection.begin(), collection.end(), 0.0,Adapt())

ne fonctionnera pas avec gnu mode parallèle pour quelque étrange et stupide raison.

OriginalL'auteur Painless Coding

À l'aide de c++0x:

#include <numeric>
#include <vector>
#include <iostream>

class Object
{
  public:
     Object( double a, double b ):
        a_( a ),
        b_( b )
      {}

    double GetA() const { return a_; }
    double GetB() const { return b_; }
    //other methods
  private:
    double a_;
    double b_;
};

int main()
{
    std::vector< Object > collection;
    collection.push_back( Object( 1, 2 ) );
    collection.push_back( Object( 3, 4 ) );
    double result = std::accumulate( collection.begin(), collection.end(), 0,
                                     [] (double result, const Object& obj) 
                                     {
                                       return result + obj.GetA() * obj.GetB();
                                     }
                                   ); 

   std::cout << "result = " << result << std::endl;

   return 0;
}

OriginalL'auteur Andy Sardina Ramos

On pourrait l'espérer, ce sont les devoirs...

struct Adapt { 
    static double mul(Object const &x) { return x.GetA() * x.GetB(); }
    static double operator()(Object const &x, Object const &y) { 
       return mul(x)+mul(y); } };

result = std::accumulate(collection.begin(), collection.end(), Object(0,0),Adapt() );

en supposant que vous n'êtes pas autorisé à toucher la déclaration de l'Objet.

le résultat d'accumuler devrait être 'double' et pas un 'Adapter'

OriginalL'auteur ackb

Vous devez vous connecter pour publier un commentaire.