0.可变数量参数，可变函数模版，变长模版类

• 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;
}

1.C++11原子类型

在并行编程、多线程编程中，对于共享资源的访问，需要通过添加互斥锁的方法来保证正确性。在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;
}

2.内存模型,顺序一致性与memory_order

太复杂，主要是硬件平台下内存读写顺序一致性.在c++11中，实现了很多内存顺序的细节，比如顺序一致、松散、release-require、release-consume四种顺序模型。

3.线程局部存储

本节省略…….

4.指针空值

        在良好的编程习惯中，声明一个变量时，同时初始化，在以前的习惯里，如果声明指针，一般初始化为0或NULL。

其中NULL为宏定义，在stddef.h中可见细节，一般被定义为0或(void*)常量。

在c++11中，定义了一个指针空值类型的常量：nullptr,大小和void*一致。另有nullptr_t常量。

5.默认函数的控制

在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);//无法通过编译
}

6.lambda函数

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帮助我们定义了很多仿函数可直接使用。