#include <algorithm>#include <iostream>#include <vector>using namespace std;int main() {   // Create a vector object that contains 10 elements.   vector<int> v;   for (int i = 0; i < 10; ++i) {      v.push_back(i);   }   // Count the number of even numbers in the vector by    // using the for_each function and a lambda.   int evenCount = 0;   for_each(v.begin(), v.end(),[&evenCount] (int n) {      cout << n;      if (n % 2 == 0) {         cout << " is even " << endl;         ++evenCount;      } else {         cout << " is odd " << endl;      }   });   // Print the count of even numbers to the console.   cout << "There are " << evenCount         << " even numbers in the vector." << endl;}

#include <algorithm>#include <iostream>#include <vector>using namespace std;class FunctorClass{public:    // The required constructor for this example.    explicit FunctorClass(int& evenCount)         : m_evenCount(evenCount)    {    }    // The function-call operator prints whether the number is    // even or odd. If the number is even, this method updates    // the counter.    void operator()(int n) const    {        cout << n;        if (n % 2 == 0) {            cout << " is even " << endl;            ++m_evenCount;        } else {            cout << " is odd " << endl;        }    }private:    // Default assignment operator to silence warning C4512.    FunctorClass& operator=(const FunctorClass&);    int& m_evenCount; // the number of even variables in the vector.};int main() {    // Create a vector object that contains 10 elements.    vector<int> v;    for (int i = 0; i < 10; ++i) {        v.push_back(i);    }    // Count the number of even numbers in the vector by     // using the for_each function and a function object.    int evenCount = 0;    for_each(v.begin(), v.end(), FunctorClass(evenCount));    // Print the count of even numbers to the console.    cout << "There are " << evenCount         << " even numbers in the vector." << endl;}

#include <cstdint>#include <chrono>#include <iostream>#include <string>#include <thread>#include <vector>#include <algorithm>#if USE_BOOST#include <boost/function.hpp>#include <boost/bind.hpp>#endifclass FunctorClass{public:    // The required constructor for this example.    explicit FunctorClass(uint64_t& evenCount)    : m_evenCount(evenCount)    {    }        // The function-call operator prints whether the number is    // even or odd. If the number is even, this method updates    // the counter.    void operator()(int n) const    {         m_evenCount += n;    }    private:    // Default assignment operator to silence warning C4512.    FunctorClass& operator=(const FunctorClass&);        uint64_t& m_evenCount; // the number of even variables in the vector.};class timer{public:    typedef std::chrono::high_resolution_clock clock;    typedef clock::time_point                  time_point;    typedef clock::duration                    duration;    public:    timer()    {        reset();    }        void reset()    {        _starttime = clock::now();    }        duration elapsed() const    {        return clock::now() - _starttime;    }protected:    time_point _starttime;};bool test_timer(){    using std::chrono::milliseconds;    typedef timer::duration duration;        const milliseconds sleep_time(500);        timer t;    std::this_thread::sleep_for(sleep_time);    duration recorded = t.elapsed();        // make sure the clock and this_thread::sleep_for is precise within one millisecond (or at least in agreement as to    // how inaccurate they are)    return (recorded - milliseconds(1) < sleep_time)    && (recorded + milliseconds(1) > sleep_time);}template <typename T>void volatile_write(const T& x){    volatile T* p = new T;    *p = x;    delete p;}template <typename Function>void run_test(const std::string& name, Function func){    std::cout << name;    timer t;    volatile_write(func());    timer::duration duration = t.elapsed();    std::cout << ‘\t‘ << duration.count() << std::endl;}template <typename Function>void do_test_loop(Function func, const uint64_t upper_limit = 100000000ULL){    uint64_t i;    for (i = 0; i < upper_limit; ++i)        func(i);    if(i == upper_limit)    {        std::cout<<i;    }}uint64_t test_accumulate_lambda(){    uint64_t x = 0;    auto accumulator = [&x] (uint64_t i) { x += i; };    do_test_loop(accumulator);    return x;}void test_accumulate_bind_function(uint64_t& x, uint64_t i){    x += i;}uint64_t test_accumulate_bind(){    namespace arg = std::placeholders;        uint64_t x = 0;    std::function<void (uint64_t)> accumulator = std::bind(&test_accumulate_bind_function, std::ref(x), arg::_1);    do_test_loop(accumulator);    return x;}uint64_t test_accumulate_bound_lambda(){    uint64_t x = 0;    std::function<void (uint64_t)> accumulator = [&x] (uint64_t i) { x += i; };    do_test_loop(accumulator);    return x;}uint64_t test_accumulate_class_function(){    uint64_t x = 0;    do_test_loop(FunctorClass(x));   // for_each(v.begin(), v.end(), FunctorClass(x));    return x;}uint64_t test_accumulate_bind_auto(){    namespace arg = std::placeholders;        uint64_t x = 0;    auto accumulator = std::bind(&test_accumulate_bind_function, std::ref(x), arg::_1);    do_test_loop(accumulator);    return x;}#if USE_BOOSTuint64_t test_accumulate_boost_bind(){    uint64_t x = 0;        boost::function<void (uint64_t)> accumulator = boost::bind(&test_accumulate_bind_function, boost::ref(x), _1);    do_test_loop(accumulator);    return x;}uint64_t test_accumulate_boost_bound_lambda(){    uint64_t x = 0;    boost::function<void (uint64_t)> accumulator = [&x] (uint64_t i) { x += i; };    do_test_loop(accumulator);    return x;}#endifint main(){    if (!test_timer())    {        std::cout << "Failed timer test." << std::endl;        return -1;    }        run_test("Accumulate (lambda)            ", &test_accumulate_lambda);    run_test("Accumulate (bind)              ", &test_accumulate_bind);    run_test("Accumulate (bound lambda)      ", &test_accumulate_bound_lambda);    run_test("Accumulate (Function Object)    ", &test_accumulate_class_function);    run_test("Accumulate (bind auto)    ", &test_accumulate_bind_auto);#if USE_BOOST    run_test("Accumulate (boost bind)        ", &test_accumulate_boost_bind);    run_test("Accumulate (boost bound lambda)", &test_accumulate_bound_lambda);#endif}