c++11強化知識點

初始化列表（std::initializer_list）

• c++11提供了std::initializer_list，將使得類對象的初始化也能夠和普通數組或者POD數據同樣使用初始化列表的方式。只要爲類對象提供初始化列表構造函數便可。
• std::initializer_list也能夠做爲函數的參數使用。
• 初始化列表std::initializer_list相關示例代碼以下。

#include <iostream>
#include <initializer_list>
#include <vector>

using namespace std;

class InitClass {
public:
    InitClass(initializer_list<int> list) {
        for (int l : list)
            initializer_list_.emplace_back(l);
    }

    void PrintInit() {
        for (int l : initializer_list_)
            cout << l << endl;
    }

    void Print(initializer_list<int> list) {
        for (int l : list)
            cout << l << endl;
    }

private:
    vector<int> initializer_list_;
};

struct A {
    double a;
    int b;
};
struct B {
    B(int a, double b): a_(a), b_(b) {}
private:
    int a_;
    double b_;
};


int main()
{
    // 使用初始化列表初始化類對象
    InitClass i = {1, 2, 3, 4, 5};
    i.PrintInit();
    cout << endl;
    // 初始化列表作函數參數
    i.Print({1, 2, 3});
    // 使用初始化列表初始化POD數據
    vector<int> v = {1, 2, 3, 4};
    A a {1.1, 1};
    B b {2, 2.2};
    
    return 0;
}

變長參數模板（typename... Args）

• c++11提供了變長參數模板，堪比黑魔法。能夠實現任意類型、任意個數的變長參數模板類和函數。
• 可使用經典的遞歸模板函數的方式去取出變長參數模板函數中的參數，示例代碼以下。

#include <iostream>
template<typename T>
void printf(T value) {
    std::cout << value << std::endl;
}
template<typename T, typename... Args>
void printf(T value, Args... args) {
    std::cout << value << std::endl;
    printf(args...);
}
int main() {
    printf(1, 2, "123", 1.1);
    return 0;
}

• c++14提供了更簡便的方法，可使用初始化列表展開變長參數，示例代碼以下。

// 編譯這個代碼須要開啓 -std=c++14
#include <iostream>
template<typename T, typename... Args>
auto print(T value, Args... args) {
    std::cout << value << std::endl;
    return std::initializer_list<T>{([&] {
        std::cout << args << std::endl;
    }(), value)...};
}
int main() {
    print(1, 2.1, "123");
    return 0;
}

強類型枚舉（enum class）

• c++11提供了類型安全的枚舉類enum class。枚舉類中定義的枚舉值不可以被隱式轉換爲整數，也不能與整數直接比較，更不能與不一樣的枚舉類型的枚舉值比較。
• 枚舉類定義的枚舉值能夠定義相同的值。
• 枚舉類中能夠本身定義枚舉值的類型，默認是int。
• 能夠經過重載<<運算符來實現直接打印枚舉類的值。
• 能夠定義模板轉換函數來方便將枚舉類的枚舉值與基本數據類型（如int）直接進行比較。
• 全部示例代碼以下。

#include <iostream>
enum class new_enum : unsigned int {
    value1,
    value2,
    value3 = 888,
    value4 = 888
};

template<typename T>
std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e) {
    return stream << static_cast<typename std::underlying_type<T>::type>(e);
}

template<typename T>
auto to_underlying_type(const T& e) {
    return static_cast<typename std::underlying_type<T>::type>(e);
}

int main() {
    if (new_enum::value3 == new_enum::value4 && 888 == to_underlying_type(new_enum::value3))
    {
         std::cout << new_enum::value3 << std::endl;
    }
    return 0;
}

函數對象包裝器（std::function）

• c++11提供了能夠定義任意可調用類型的函數對象包裝器（std::function），這是對函數對象的一種類型安全的包裝。
• 利用std::function和c++11提供的更強大的using語法以及Lambda函數，咱們能夠更方便的實現類對象中的簡單的回調函數。示例代碼以下。

#include <iostream>
#include <memory>

class A {
public:
    using CallBack = std::function<void()>;

    void SetCallBack(CallBack cb) { call_back_ = cb; }
    void CallCallBack() {
        if (call_back_)
        {
            call_back_();
        }
        
    }

private:
    CallBack call_back_ = nullptr;
};

class B {
public:
    B() {
        a = std::make_shared<A>();
        a->SetCallBack([](){
            std::cout << "call A cb in B" << std::endl;
        });
        a->CallCallBack();
    }

private:
    std::shared_ptr<A> a = nullptr;
};

int main() {
    B b;
}

• 若是回調函數很複雜，不適合用Lambda函數實現，也能夠經過std::bind來將回調函數綁定到類的成員函數上。

智能指針初始化（make_unique）

• 爲了簡化c++的指針管理，c++11擴展了標準庫，推出了智能指針——std::shared_ptr/std::unique_ptr/std::weak_ptr。智能指針使用引用計數的方式來實現自動釋放資源，使得c++語言更具現代性。
• 標準庫提供了std::make_shared來初始化一個std::shared_ptr，避免了咱們使用new來初始化std::shared_ptr。可是因爲「被標準委員會忘記了」，標準庫卻沒有提供make_unique的方法來給咱們初始化一個std::unique_ptr（好在c++14提供了）。爲此咱們能夠本身實現一個make_unique，代碼以下。

#include <memory>

template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args ) {
    return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );
}

int main() {
    std::unique_ptr<int> p = make_unique<int>(1);
    return 0;
}