c++98可变数量参数
#include<cstdio> #include<cstdarg> double SumOfFloat(int count, ...) { va_list ap; double sum=0; va_start(ap,count); for(int i=0;i<count;i++) sum+=va_arg(ap,double); va_end(ap); return sum; } int main() { printf("%f\n",SumOfFloat(3,1.2f,3.4,5.6)); return 0; }
可变函数模版
#include<iostream> #include<stdexcept> using namespace std; void Print(const char *s) { while(*s){ if(*s==‘%‘&&*++s!=‘%‘) throw runtime_error{"missing arguments"}; cout<<*s++; } } template<typename T,typename...Args> void Print(const char*s,T value,Args...args) { while(*s) { if(*s==‘%‘&&*++s!=‘%‘) { cout<<value; return Print(++s,args...); } cout<<*s++; } throw runtime_error{"extra arguments provided to Print"}; } int main() { Print("hello %s\n",string("world")); return 0; }
变长模版类
#include<iostream> using namespace std; template<long...nums> struct Multiply; template<long first,long ...last> struct Multiply<first,last ...> { static const long val=first*Multiply<last...>::val; }; template<> struct Multiply<> { static const long val=1; }; int main() { cout<<Multiply<2,3,4,5>::val<<endl; cout<<Multiply<22,44,66,88,9>::val<<endl; return 0; }
在并行编程、多线程编程中，对于共享资源的访问，需要通过添加互斥锁的方法来保证正确性。在POSIX标准下，pthread库，我们用lock方法来实现，如下：
pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER; void* func(void*) { long long i; for(i=0;i<10000000;i++) { pthread_mutex_lock(&m); total+=i; pthread_mutex_unlock(&m); } }
而在c++11中，我们通过定义的原子类型即可很方便地实现。c++11定义很多原子数据类型，比如：atomic_bool,atomic_char,atomic_int等等。
//total定义为原子类型,c++11中不需要为原子类型声明互斥锁 atomic_llong total{0}; void func(int) { for(long long i=0;i<100000;i++) total+=i; }
太复杂，主要是硬件平台下内存读写顺序一致性.在c++11中，实现了很多内存顺序的细节，比如顺序一致、松散、release-require、release-consume四种顺序模型。
本节省略…….
在良好的编程习惯中，声明一个变量时，同时初始化，在以前的习惯里，如果声明指针，一般初始化为0或NULL。
其中NULL为宏定义，在stddef.h中可见细节，一般被定义为0或(void*)常量。
在c++11中，定义了一个指针空值类型的常量：nullptr,大小和void*一致。另有nullptr_t常量。
在c++中声明自定义类，编译器会自动生成默认函数：构造函数、拷贝构造函数、拷贝赋值函数、移动构造函数、移动拷贝函数、析构函数。
还会自动生成默认操作符：operator，，operator&，operator&&，operator*，operator->,operaotr->*,operator new,operator delete.
在以前的c++编程规则中，如果我们指定带参数的构造函数，则需要重写不带参数，即默认构造函数。
class TwoCstor { //提供了带参数的构造函数，则必须自行提供不带参数的版本 public: TwoCstor(){}; TwoCstor(int i):data(i){}; private: int data; }在C++11中，通过default关键字来实现这个目标。如下：
class TwoCstor2 { //提供了带参数的构造函数，再指示编译器提供默认版本 public: TwoCstor2()=default; TwoCstor2(int i):data(i){}; private: int data; }
在实现Singleton模式中，我们需要将拷贝构造函数设为私有，在c++11中则更简单，直接利用deleted关键字，指示编译器不生成函数的默认版本。
#include<type_traits> #include<iostream> using namespace std; class NoCopyCstor { public: NoCopyCstor()=default; //通过使用"=delete"有效阻止用户错用拷贝构造函数 NoCopyCstor(const NoCopyCstor &)=delete; }; int main() { NoCopyCstor a; NoCopyCstor b(a);//无法通过编译 }
lambda函数的语法定义如下：
[capture](parameters) mutable –>return-type {statement}
使用lambda函数作为stable_sort函数的调用对象。
int main() { vector<string> strVec{"hello","wo","panzg1","at3","binary_function"}; stable_sort(strVec.begin(),strVec.end(), [](const string &a,const string &b){return a.size()<b.size();}); for(auto e : strVec) cout<<e<<endl; }code…各种各样的lambda函数
捕获列表的常见几种形式：
- [var] 值传递捕获var
- [=]值传递方式捕获所有父作用域的变量，包括this
- [&var]引用传递捕获var
- [&]引用传递捕获所有父作用域的变量，包括this
- [this] 值传递方式捕获当前this指针
值传递、引用传递可以混用，比如[=,&a,b]等等。
仿函数，functor，函数对象，就i是重定义了成员函数operator()的一种自定义类型对象。比如在下面的例子中，test不是一样函数，而是一个对象。仿函数广泛地被用在STL中，在c++11中lambda也要被广泛使用。
#include<iostream> class _functor { public: int operator()(int x,int y) {return x+y;} }; int main() { _functor test; int x=3,y=4; std::cout<<test(3,4); }事实上，仿函数是编译器实现lambda的一种方式，在现阶段，通常编译器会把lambda函数转化为一个仿函数对象。
关于lambda和STL的联系，它使得STL的算法使用更加方便，比如for_each，其原型是：
UnaryProc for_each(InputIterator beg,InputIterator end,UnaryProc op)
for_each算法第三个参数是一个单个参数的“函数”，即一个函数指针、仿函数或者lambda函数。
函数指针方法的缺陷是：往往定义在别的地方，阅读代码不方便；如果不进行inline优化，性能就比lambda函数差很多。而且函数指针的应用范围小很多，相比函数指针、仿函数，lambda函数往往是最佳的选择。
注：在c++98中，STL帮助我们定义了很多仿函数可直接使用。
原文：http://www.cnblogs.com/panweishadow/p/3694883.html
