c++模板实现 linq

// ConsoleApplication32.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
using namespace std;
#include <vector>
#include <iterator>
#include <iostream>
template<typename TIterator>
struct from_range
{
// range接口的成员类型
// 其含义为C++容器所包含数据的值类型
using value_type = typename std::iterator_traits<TIterator>::value_type;

// from_range内含三个指向数据的迭代器
// 当前迭代器，其次迭代器，末尾迭代器
TIterator current, upcoming, end;
// from_range的构造器
// 当前迭代器指向容器的开头
// 其次迭代器指向容器的开头
// 末尾迭代器指向容器的末尾
from_range(TIterator begin, TIterator end)
: current(begin), upcoming(begin), end(end) {}

// range接口的成员方法
// 重载>>操作符，该操作符接收一个build对象作为右操作符
// 该操作符将自身传给builder对象的build方法，通过调用该方法实现对range的转换
template<typename TRangeBuilder>
decltype(auto) operator >> (TRangeBuilder builder) const { return builder.build(*this); }
// front方法，返回当前迭代器所指向的数据，即当前数据
decltype(auto) front() const { return *current; }
// next方法，当前数据不存在则返回false，若存在则准备当前数据并返回true
// 具体实现为
// 1. 若其次迭代器与末尾迭代器的值相等，则其次迭代器已经指向容器末尾
//    判断当前数据不存在，返回false
// 2. 若其次迭代器与末尾迭代器的值不等，则其次迭代器尚未指向容器末尾
//    将其次迭代器的值赋予当前迭代器，递增其次迭代器，令其指向下一个数据
//    判断当前数据存在，返回true
bool next() { return upcoming == end ? false : (current = upcoming++, true); }
};

template<typename TRange, typename TPredicate>
struct where_range
{
// range接口的成员类型
// 其含义为转换源range所包含数据的值类型
using value_type = typename TRange::value_type;

// where_range内含两个数据成员
// 转换源range，谓词（过滤条件）
TRange range;
TPredicate predicate;
// where_range的构造器
where_range(TRange range, TPredicate predicate)
: range(range), predicate(predicate) {}

// range接口的成员方法
// 重载>>操作符，该操作符接收一个build对象作为右操作符
// 该操作符将自身传给builder对象的build方法，通过调用该方法实现对range的转换
template<typename TRangeBuilder>
decltype(auto) operator >> (TRangeBuilder builder) const { return builder.build(*this); }
// front方法，返回转换源range的当前数据
decltype(auto) front() const { return range.front(); }
// next方法，当前数据不存在则返回false，若存在则准备当前数据并返回true
// 具体实现为
// 扫描数据源range直至找到符合过滤条件的下一个数据
// 若该数据存在，则当前数据存在，返回true
// 否则当前数据不存在，返回false
bool next() {
while (range.next())
if (predicate(range.front()))
return true;
return false;
}
};

template<typename TPredicate>
struct where_builder
{
// where_builder只包含一个成员：谓词（过滤条件）
TPredicate predicate;
// where_builder的构造器
where_builder(TPredicate predicate) : predicate(predicate) {}

// builder接口的成员方法
// build方法，生成并返回where_range对象
template<typename TRange>
auto build(TRange range) {
return where_range<TRange, TPredicate>(range, predicate);
}
};

struct to_vector_builder
{
// builder接口的成员方法
// build方法，生成并返回C++容器
// 具体实现为
// 扫描数据源range
// 将扫描所得到的数据依次插入到C++容器中
template<typename TRange>
auto build(TRange range) {
std::vector<TRange::value_type> result;
while (range.next())
result.push_back(range.front());
return result;
}
};

// LINQ操作符from，将C++容器转换成from_range对象
template<typename TContainer>
auto from(TContainer const& container)
{
return from_range<decltype(std::begin(container))>(std::begin(container), std::end(container));
}
// LINQ操作符where，生成并返回where_builder对象
template<typename TPredicate>
auto where(TPredicate predicate) { return where_builder<TPredicate>(predicate); }
// LINQ操作符to_vector，生成并返回to_vector_builder对象
auto to_vector() { return to_vector_builder(); }

class Person
{
public:

Person()
{

}
Person(int k)
{
this->k = k;
}
~Person()
{

}
public:
int k;
public:
static int m;
private:
int k1;

protected:
int k2;
};

class  HeiPerson :virtual public Person
{
public:
HeiPerson():Person(2)
{

}
};
class  HuangPerson :virtual public Person
{
public:
HuangPerson() :Person(2)
{

}
};

class waiPerson :public HeiPerson,public HuangPerson
{
public:
waiPerson():Person(14)
{
//    cout << HeiPerson::k;
}

};
int Person::m = 10;

int main()
{
HeiPerson h;
waiPerson w;
vector<int> ivec;
ivec.push_back(1);
ivec.push_back(2);
ivec.push_back(3);
ivec.push_back(4);

vector<int>::iterator int_ite;

for (int_ite = ivec.begin(); int_ite != ivec.end(); int_ite++)
cout << "ivec: " << *int_ite << endl;
/*cout << w.HeiPerson::k <<"3"<< endl;*/
//cout << "w.k=" <<w.k <<"w.m"<<w.Person::m<< endl;
//cout << w.m;

int a[] = { 1, 2, 3, 4 };
// 找出数组a中所有的偶数，将结果存放到一个vector对象中
auto v = from(a) >> where([](int n) {return n % 2 == 0; }) >> to_vector();
for (int i : v) std::cout << i << std::endl;

system("pause");
return 0;
}