关键字：for

std::for_each

先贴cppreference中对for_each的概述：

template< class InputIt, class UnaryFunction >　　//此处UnaryFunction为一元函数

UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f );

1) Applies the given function object f to the result of dereferencing every iterator in the range [first, last), in order.　　//in order按顺序

2) Applies the given function object f to the result of dereferencing every iterator in the range [first, last)(not necessarily in order). The algorithm is executed according to policy. This overload does not participate in overload resolution　　//policy政策 //participate参加

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //overload resolution重载决议

unless std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true.//这句话暂时不需要懂，cpp17对for_each又增加了一个重载版本而已

For both overloads, if InputIt is a mutable iterator, f may modify the elements of the range through the dereferenced iterator. If f returns a result, the result is ignored.　　//如果迭代器不是const的，则允许一元函数对解引用的对象进行修改。如果一元函数返回一个值，则返回值被忽略.

function object, to be applied to the result of dereferencing every iterator in the range [first, last)

The signature of the function should be equivalent to the following:

void fun(const Type &a);

The signature does not need to have const &.
The type Type must be such that an object of type InputIt can be dereferenced and then implicitly converted to Type.

for_each返回值为第三个参数，即仿函数。即通过for_each可以获得操作后的对象状态。

贴一段用for_each清零数组的小程序：

#include <iostream>

#include <algorithm>

#include <vector>

using namespace std;

int main()

{

        const int elementSize = 10;
　　　　 vector<int> vec(elementSize, 1);

        for_each(begin(vec), end(vec), [&] (int &i) { i = 0; } );　　//引用捕获方式，将每个值置0

        for(const auto &j : vec)　　//范围for循环打印

                cout << j << " ";

        cout << endl;

        return ;

}

微软社区的一个示例：

// alg_for_each.cpp

// compile with: /EHsc

#include <vector>

#include <algorithm>

#include <iostream>

// The function object multiplies an element by a Factor

template <class Type>

class MultValue

{

private:

   Type Factor;   // The value to multiply by

public:

   // Constructor initializes the value to multiply by

   MultValue ( const Type& _Val ) : Factor ( _Val ) {

   }

   // The function call for the element to be multiplied

   void operator ( ) ( Type& elem ) const　　//重载成可调用对象，要注意当此可调用对象需要传参时，需要额外加一个形参列表，且应该放在 （） 的后面。

   {

      elem *= Factor;

   }

};

// The function object to determine the average

class Average

{

private:

   long num;      // The number of elements

   long sum;      // The sum of the elements

public:

   // Constructor initializes the value to multiply by

   Average ( ) : num (  ) , sum (  )

   {

   }

   // The function call to process the next elment

   void operator ( ) ( int elem ) \

   {

      num++;      // Increment the element count

      sum += elem;   // Add the value to the partial sum

   }

   // return Average

   operator double ( )　　//转换操作符重载

   {

      return  static_cast <double> (sum) /

      static_cast <double> (num);

   }

};


//以下我基于范围for循环重写了一部分

int main( )

{

　　using namespace std;
　　vector<int> vec;
　　vector<int>::iterator iter;

　　int i;
　　for( i = -4; i <= 2; ++i)　　//给数组赋一个初始序列
　　{
　　　　vec.push_back(i);
　　}

　　cout << "The original sequence is (";　　//打印初始序列
　　for(const auto &num : vec)
　　{
　　　　cout << num << " ";
　　}
　　cout << ")." << endl;

　　for_each(vec.begin(), vec.end(), MultValue<int>(-2));　　//将序列中的值依次乘以-2

　　cout << "The mod1 sequence is (";　　//打印mod1序列
　　for(const auto &num : vec)
　　{
　　　　cout << num << " ";
　　}
　　cout << ")." << endl;

　　for_each(vec.begin(), vec.end(), MultValue<int>(5));　　//将序列中的值依次乘以5

　　cout << "The mod2 sequence is (";　　//打印mod2序列

　　for(const auto &num : vec)
　　{
　　　　cout << num << " ";
　　}
　　cout << ")." << endl;

　　double ret = for_each(vec.cbegin(), vec.cend(), Average());　　//求平均值。此处用重载double操作符实现，比较难以理解。可以用如下改法：

　　/*　　Average tmp = for_each(vec.cbegin(), vec.cend(), Average());

　　　　　cout << tmp.xxx << endl;　　//将operator double () 改为 double xxx() { return static_cast<double>(sum) / static_cast<double>(num); }

　　cout << "The average of mod2 is :"　　//打印平均值
　　　　　　<< ret << endl;

　return 0;

}

The original sequence is (-4, -3, -2, -1, 0, 1, 2).

The mod1 sequence is (8, 6, 4, 2, 0, -2, -4).

The mod2 sequence is (40, 30, 20, 10, 0, -10, -20).

The average of mod2 is :10

此处补一下转换操作符重载的知识：

class <类型1>

{
public:

    operator <类型2> () {

    }

};

由此可见：转换操作符重载就是将类型1转换为类型2

#include <iostream>

using namespace std;

class Ratation

{

private:

        long num_;

        long sum_;

public:

        Ratation() : num_(2), sum_(1) {

        }

        operator double ()

        {

                return static_cast <double> (sum_) /

                        static_cast <double> (num_);

        }

};

int main()

{

        Ratation obj;

        double a = 1.2;

        a += Ratation();　　//执行Ratation到double的转换

        cout << a << endl;　　//此处输出1.7，可见Ratation被转换为双精度了。

        return ;

}

参考：http://en.cppreference.com/w/cpp/algorithm/for_each

　　　https://msdn.microsoft.com/zh-cn/library/e5sk9w9k.aspx

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　写于： 2017-03-04　23:08:37

巴特西

关键字：for_each

最新文章

热门文章