2014年10月 – 酸菜鱼

C++:简单计算器与排序

两个小程序

包含两个小程序,一个对数字进行计算的(也可以对其他可用类型),第二个是排序的.

计算的小程序

// Example program #include #include #include using namespace std;

//加减乘除运算.

int main() { /* template struct plus { T operator() (const T& x, const T& y) const {return x+y;} typedef T first_argument_type; typedef T second_argument_type; typedef T result_type; };

例如:上面是plus的原型,可以看出其中重载了加法运算.(其他的类似) 更多可以参考:http://www.cplusplus.com/reference/functional/plus/ [应查看c++ 11的示例] */ plus age; minus gre; multiplies nums; divides ds; negate ne; modulus modu; /////////////////////////////// cout << "add:" << age(10,20) << endl; cout << "minus:" << gre(100,50) << endl; cout << "mulitplies:" << nums(50,100) << endl; cout << "divides:" << ds(100,2) << endl; cout << "negate:" << ne(100) << endl; cout << "modulus:" << modu(100,10) << endl; return 0; }

逆序排序

下面的程序其实使用了上面程序中的匿名negate对象(negate会倒置传入的值).

negate原型如下:

template struct negate { T operator() (const T& x) const {return -x;} typedef T argument_type; typedef T result_type; }; //更多可参考:http://www.cplusplus.com/reference/functional/negate/
程序如下:

// Example program #include #include #include #include using namespace std;

//逆序排列vector中的元素

int main() { vector vec={5,20,70,6,100,658,50,3,1558,1,85217,0}; sort(vec.begin(),vec.end(),greater()); for_each(vec.begin(),vec.end(),[](const int &is){cout << is << " " ;}); cout << endl; return 0; }

C++:可调用对象与function

一点东西

题目也可以是函数表(用于存储指向可调用对象的”指针”).

//普通函数 int add(int i,int j){ return i+j; } //lambda,其产生一个未命名的函数对象类. auto mod = [](const int &i,const int &j){ return i+j; } //函数对象类. struct divide{ int operator()(int denominator,int divisor) { return denominator / divisor; } };
上面这些可调用对象,虽然类型不同,但是共享同一种调用形式:
int(int,int)
可以定义一个函数表,用于存储指向这些可调用对象的”指针”.当程序需要执行某个特定的操作时,
从表中查找该调用的函数.

在C++中,函数表很容易通过map来实现.

简单意思就是将与int(int,int)一样的类型,放入一个map中,将其的操作作为map的主键.

形如:

map["+"]=add;//add是一个函数指针. map["-"]=minus;//同add的含义一样. map["*"]=.. 以此类推..

代码实现

下面的代码可以运行,推荐一个在线运行的网址:CPP.SH

// Example program #include #include #include

 #include
 using namespace std;
/*
 //普通函数
 int add(int i,int j){ return i+j; }
 //lambda,其产生一个未命名的函数对象类.
 auto mod = [](const int &i,const int &j){ return i+j; }
 //函数对象类.
 struct divide{
 int operator()(int denominator,int divisor)
 {
 return denominator / divisor;
 }
 };
上面这些可调用对象,虽然类型不同,但是共享同一种调用形式:
 int(int,int)
可以定义一个函数表,用于存储指向这些可调用对象的"指针".当程序需要执行某个特定的操作时,
 从表中查找该调用的函数.
在C++中,函数表很容易通过map来实现.
*/
 int add(int i,int j){
 return i+j;
 }
struct divide{
 int operator()(int denominator,int divisor)
 {
 return denominator / divisor;
 }
 };
int main()
 {
 auto mod = [](const int &i,const int &j){ return i+j; };
 map binops;
 binops.insert({"+",add});
 //但是我们不能将mod或者divide存入binops.因为mod不是一个函数指针.
 //问题在于mod是个lambda表达式,而每个lambda有它自己的类类型,该类型与存储在binops中的值得类型不匹配.
 //解决办法如下:
 //使用一个名为function的新的标准库类型解决上述问题.
 /*function f1 = add;//函数指针
 function f2 = divide();//函数对象类的对象.
 function f3 = [](int i,int j){ return i * j ; }; //lambda
 cout << f1(4,2) << endl;
 cout << f2(4,2) << endl;
 cout << f3(4,2) << endl;*/ 
 //使用function类型我们可以重新定义map.
 map> binops2={
 {"+",add},    //函数指针.
 {"-",std::minus()},  //标准库函数对象
 {"/",divide()},   //用户定义的函数对象.
 {"*",[](int i,int j){ return i * j ;}}, //未命名的lambda
 {"%",mod} //命名了的lambda对象
 };
 cout << "10+5=" << binops2["+"](10,5) << endl;//调用add(10,5)
 cout << "10-5=" << binops2["-"](10,5) << endl;//调用minus
 cout << "10/5=" << binops2["/"](10,5) << endl;//调用divide
 cout << "10*5=" << binops2["*"](10,5) << endl;//调用lambda
 cout << "10%5=" << binops2["%"](10,5) << endl;//调用lambda
 /*
 我们不能(直接)将重载函数的名字存入function类型的对象中: 
 int add(int i,int j){return i+j;}
 Sales_data add(const Sales_data&,const Sales_data&); 
 map> binops3;
 binops3.insert({"+",add}); //错误:哪个add?
 解决上述二义性的问题是存储函数指针而非函数的名字:
 int (*fp)(int,int) =add;    //指针所指的add是接受两个int的版本.
 binops3.insert({"+",fp});   //正确:fp指向一个正确的add版本
 同样,也可以用lambda来消除二义性:
 //正确:使用lambda来指定我们希望使用的add版本
 binops3.insert({"+",[](int a,int b){return add(a,b);}});
 */