C++11 让程序更简洁、更优雅

可调用对象

是一个函数指针
是一个具有operator()成员函数的类对象（仿函数）
是一个可被装换为函数指针的类对象
是一个类的成员（函数）指针

void func()

{

}

struct Foo

{

    void operator()(void)

    {

    }

};

struct Bar

{

    using fr_t = void(*)(void);

    static void func(void)

    {

    }

    operator fr_t(void)

    {

        return func;

    }

};

struct A

{

    int a_;

    void mem_func(void)

    {

    }

};

int main()

{

    void(*func_ptr)(void) = &func;            //函数指针

    func_ptr();

    Foo foo;                                                        //仿函数

    foo();    

    Bar bar;

    bar();                                                             //可被转换为函数指针的类的对象

    void(A::*mem_func_ptr)(void) = &A::mem_func;        //类成员函数指针

    int A::*mem_obj_ptr = &A::a_;                                            //类成员指针

    A aa;

    (aa.*mem_func_ptr)();

    aa.*mem_obj_ptr = 123;

    return 0;

}

std::function

std::function是可调用对象的包装器，可以容纳除了类成员（函数）指针之外的所有可调用对象。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟执行它们。

#include <iostream>

#include <functional>

using namespace std;

void func(void)

{

    std::cout << __FUNCTION__ << std::endl;

}

class Foo

{

public:

    static int foo_func(int a)

    {

        std::cout << __FUNCTION__ << std::endl;

        return a;

    }

};

class Bar

{

public:

    void operator()(void)

    {

        std::cout << __FUNCTION__ << std::endl;

    }

};

class A

{

    std::function<void()> callback_;

public:

    A(const std::function<void()>& f):callback_(f)

    {

    }

    void notify(void)

    {

        callback_();

    }

};

void call_when_even(int x, const std::function<void(int)>& f)

{

    if(!(x & 1))

    {

        f(x);

    }

}

void output(int x)

{

    std::cout << x << " ";

}

int main()

{

    std::function<void(void)> fr1 = func;           //普通函数

    fr1();

    std::function<int(int)> fr2 = Foo::foo_func;    //类的静态成员函数

    std::cout << fr2(123) << std::endl;

    Bar bar;                                        //仿函数

    fr1 = bar;

    fr1();

    A aa(bar);

    aa.notify();

    for (size_t i = 0; i < 10; i++)

    {

        call_when_even(i, output);

    }

    std::cout << std::endl;

    return 0;

}

std::bind

std::bind用来将可调用对象与其参数一起进行绑定。绑定后的结果可以使用std::function进行保存，并延迟调用到任何我们需要的时候

将可调用对象与其参数一起绑定成一个仿函数
将多元（参数个数为n,n>1)可调用对象转成一元或者(n-1)元可调用对象，即只绑定部分参数

class B

{

public:

    std::string name_;

    void output(int x, int y)

    {

        std::cout << x << " " << y << std::endl;

    }

};

int main()

{

    B b;

    std::function<void(int,int)> fr = std::bind(&B::output, &b, std::placeholders::_1, std::placeholders::_2);

    fr(1,2);

    std::function<std::string&(void)> fr_s = std::bind(&B::name_, &b);

    fr_s() = "hello";

    std::cout << b.name_ << std::endl;

    return 0;

}

后置返回类型

template <typename T, typename U>

//decltype(t+u) add(T t, U u)                       //C++的返回值是前置语法，返回值定义的时候参数还未定义

//decltype(T()+U()) add(T t, U u)                   //通过构造函数完成推导,如果一个类没有无参构造函数,这个地方就会报错

//decltype( (*(T*)0) + (*(U*)0) ) add(T t, U u)     //OK,但不够优雅

auto add(T t, U u) -> decltype(t+u)

{

    return (t + u);

}

模板别名

typedef std::map<std::string, int> map_s_i;

map_s_i mymap1{std::make_pair("first",1)};

typedef std::map<std::string, std::string> map_s_s;

map_s_s mymap2{ std::make_pair("second","second") };

//需求  固定以std::string最为map的key,它可以映射到不同的类型（如int、long、string等）

//在c++98|C++03, 比较猥琐写法

template<typename T>

struct mymap

{

    typedef std::map<std::string, T> type;

};

mymap<int>::type mymap3;

mymap<double>::type mymap3;

//c++11

template <typename T>

using mymapt = std::map<std::string, T>;

mymapt<int> mymap4;

//这个地方主要用到了using，在c++11中,使用using基本可以替代typedef

using funcType = int(*)(int,int);

template<typename T>

using funcT = int(*)(T,T);

int func_int(int n1,int n2)

{

  return n1+n2;

}

funcT<int> func_i = func_int;

func_i(1,2);

函数模板默认参数

c++11前，只能为类模板提供默认模板参数，c++11后可以为函数模板提供默认参数

template<typename T=std::string,int size = 10>

class myarray

{

private:

    T arr[size];

public:

    void myfunc();

}

class tc

{

public:

    tc() { std::cout << "构造函数" << std::endl; }

    tc(const tc& t) { std::cout << "拷贝构造" << std::endl; }

    int operator()(int v1, int v2)const

    {

        return v1 + v2;

    }

};

template<typename T, typename F = tc>

T test(const T& i, const T& j, F funcpoint = F())

{

    return funcpoint(i, j);

}

template <typename T = int, typename U>

auto func(U val)->decltype(val)

{

    std::cout << typeid(val).name() << std::endl;

    return  val;

}

//在调用函数模板时，若显示指定模板的参数，参数的填充顺序是从右到左

func(123);

// T  <<  std::string  <<  U  <<  123.363

func<std::string>(123.363);

tuple

tuple 构造的tuple对象所保存的是构造实参的拷贝
make_tuple: 构造tuple对象所保存的是构造实参的拷贝
tie: 通过tie构造的tuple对象，保存构造实参的可写引用
forward_as_tuple:通过forward_as_tuple构造的tuple对象，保存构造实参的原始引用,左值使用左值引用，右值使用右值引用

template<class Tuple, std::size_t N>

struct TuplePrinter

{

    static void print(const Tuple& t)

    {

        TuplePrinter<Tuple, N-1>::print(t);

        std::cout << " " << std::get<N-1>(t);

    }

};

template<class Tuple>

struct TuplePrinter<Tuple, 1>

{

    static void print(const Tuple& t)

    {

        std::cout << std::get<0>(t);

    }

};

template<class... Args>

void print(const std::tuple<Args...>& t)

{

    std::cout << "( ";

    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);

    std::cout << " )\n";

}

void show()

{

    std::cout << std::endl;

}

template <class T, class... Args>

void show(const T& t, const Args &... args)

{

    std::cout << t << " ";

    show(args...);

}

int main()

{

    int age = 20;

    float height = 170.6;

    std::string name = "小马";

    std::cout << "----- tuple() -----" << std::endl;

    // tuple构造函数

    std::tuple<std::string, int, float> tp1(name, age, height);

    // 获取元素的值

    print(tp1);

    // 修改元素的值

    std::get<0>(tp1) = "小云";

    std::get<1>(tp1) = 40;

    std::get<2>(tp1) = 16.8;

    // 获取元素的值

    print(tp1);

    // 获取变量的值; 通过结果发现,tuple构造函数构造的对象保存的是构造实参的拷贝

    show("(", name, age, height, ")");

    std::cout << "----- make_tuple -----" << std::endl;

    // 通过make_tuple构造tuple对象

    // auto tp2 = std::make_tuple(name, age, height);

    auto tp2 = std::make_tuple("hello", 1, 2.0);  //等价于上面的

    // 获取元素的值

    print(tp2);

    // 修改元素的值

    std::get<0>(tp2) = "小李";

    std::get<1>(tp2) = 35;

    std::get<2>(tp2) = 18.0;

    // 获取元素的值

    print(tp2);

    // 获取变量的值; 通过结果发现,make_tuple构造的对象保存的也是构造实参的拷贝

    show("(", name, age, height, ")");

    std::cout << "----- tie -----" << std::endl;

    // 通过tie构造tuple对象

    auto tp3 = std::tie(name, age, height);

    // auto tp3 = std::tie("hello", 2, 2);

    // 获取元素的值

    print(tp3);

    // 修改元素的值

    std::get<0>(tp3) = "小李";

    std::get<1>(tp3) = 35;

    std::get<2>(tp3) = 18.0;

    // 获取元素的值

    print(tp3);

    // 获取变量的值; 通过结果发现,成功修改了构造实参

    show("(", name, age, height, ")");

    std::cout << "----- tie parser tuple-----" << std::endl;

    // 通过tie解析tuple对象

    auto tp4 = std::make_tuple("关羽", 30, 1.85);

    tie(name, age, height) = tp4;

    show("(", name, age, height, ")");

    std::cout << "----- forward_as_tuple lvalue-----" << std::endl;

    auto tp5 = forward_as_tuple(name, age, height);

    // 获取元素的值

    print(tp4);

    // 修改元素的值，get得到的是左值引用

    std::get<0>(tp5) = "小王";

    std::get<1>(tp5) = 35;

    std::get<2>(tp5) = 18.0;

    // 获取元素的值

    print(tp4);

    // 获取变量的值; 通过结果发现,成功修改了构造实参

    show("(", name, age, height, ")");

    std::cout << "----- forward_as_tuple rvalue-----" << std::endl;

    auto tp6 = std::forward_as_tuple("小赵", 30, 1.85);

    // 获取元素的值

    print(tp6);

    // 修改元素的值，这是get得到的是一个右值引用，无法修改

    // std::get<0>(tp6) = "小王";

    // std::get<1>(tp6) = 35;

    // std::get<2>(tp6) = 18.0;

    return 0;

}

内容来源于：深入应用C++11 代码优化与工程级应用

巴特西

学习《深入应用c++11》1