首页 > 代码库 > [C++11新特性]第二篇

[C++11新特性]第二篇

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