函子在传递给 std::for_each 时可以保留值吗？

Question

根据这个问题的第一个答案，下面的函子应该能够在之后保留一个值被传递给 foreach （我无法让示例中的 struct Accumulator 进行编译，因此构建了一个类）。

class Accumulator
{
    public:
        Accumulator(): counter(0){}
        int counter;
        void operator()(const Card & c) { counter += i; }
};

示例用法（按照示例）

// Using a functor
Accumulator acc;
std::for_each(_cards.begin(), _cards.end(), acc);
// according to the example - acc.counter contains the sum of all
// elements of the deque 

std::cout << acc.counter << std::endl;

_cards 被实现为 std::deque。无论 _cards 持续多久，for_each 完成后 acc.counter 都为零。然而，当我在调试器中单步执行时，我可以看到计数器递增，那么这与按值传递 acc 有关吗？

Answer 1

这只是此处询问。

原因是（正如您所猜测的）std::for_each 复制其函子并调用它。但是，它也会返回它，因此如上面链接的答案中所述，请使用 for_each 的返回值。

也就是说，您只需要使用 std ::accumulate：

int counter = std::accumulate(_cards.begin(), _cards.end(), 0);

函子和 for_each 在这里不正确。

---

对于您的用法（计算一些，忽略其他），您可能需要提供自己的函子并使用 count_if：

// unary_function lives in <functional>
struct is_face_up : std::unary_function<const Card&, const bool>
{
    const bool operator()(const card& pC) const
    {
        return pC.isFaceUp(); // obviously I'm guessing
    }
};

int faceUp = std::count_if(_cards.begin(), _cards.end(), is_face_up());
int faceDown = 52 - faceUp;

使用 C++0x lambda 来娱乐（只是因为）：

int faceUp = std::count_if(_cards.begin(), _cards.end(),
                            [](const Card& pC){ return pC.isFaceUp(); });

更好。

Answer 2

是的，它肯定与按值传递的 acc 相关。

按如下方式修改您的累加器：

class Accumulator
{
    public:
        Accumulator(): counter(new int(0)){}
        boost::shared_ptr<int> counter;
        void operator()(int i) { *counter += i; }

        int value() { return *counter; }
};

Answer 3

这是因为 std::for_each() 在内部创建函子的副本（因为它可以传递临时对象）。因此，它在内部确实对副本而不是您提供的对象进行求和。

好消息是 std::for_each() 返回函子的副本作为结果，以便您可以从那里访问它。

注意：您还可以使用其他标准算法。就像 std::accumulate() 一样。
但是假设这只是一个简化的示例，并且您需要使用 for_each() 来实现比示例稍微复杂的操作，有几种技术可以允许您访问累加器对象。

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

class Card{ public: int i;};
class Accumulator
{
    public:
        Accumulator(): counter(0){}
        int counter;
        void operator()(const Card & c) { counter += c.i; }
};


int main()
{
    std::vector<Card>   cards;

    Accumulator a = std::for_each(cards.begin(), cards.end(), Accumulator());

    std::cout << a.counter << std::endl;

}

或者，您可以更改累加器以增加当前范围内使用的引用。

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

class Card{ public: int i;};
class Accumulator
{
        int&  counter;
    public:
        // Pass a reference to constructor.
        // Copy construction will pass this correctly into the internal object used by for_each
        Accumulator(int& counterRef): counter(counterRef){}
        void operator()(const Card & c) { counter += c.i; }
};


int main()
{
    std::vector<Card>   cards;

    int counter = 0;  // Count stored here.

    std::for_each(cards.begin(), cards.end(), Accumulator(counter));

    std::cout << counter << std::endl;

}