侯捷c++11&14新标準

侯捷c++11&14新标準

文章目錄

• • 侯捷c++11&14新标準
  • • 引言
    • variadic templates
    • Spaces in Template Expressions
    • • nullptr
      • auto
      • 初始化（initializer_list<>）
      • explicit(for ctors taking more than one argument)
      • Range-based for statement
      • 全局函數 begin（） end（）
      • =default =delete
      • Alias Template 化名
      • template template parameter
      • Type Alias, noexcept, override, final
      • • Type Alias
        • noexcept
        • override
        • final
      • decltype
      • Lambdas
      • Variadic Templates
    • 标準庫
    • • Rvalue reference
      • array forward_list
      • Hashtable
      • Hash function
      • tuple

引言

新特性包括語言和标準庫兩個部分

标準庫是以頭檔案的形式呈現（不加.h）

cplusplus.com

variadic templates

Spaces in Template Expressions

nullptr

nullptr代替 0或者NULL

auto

不确定變量類型 讓編譯器自己推

比如：代替疊代器、lambda表達式

初始化（initializer_list<>）

變量的後面直接放大括号

int values[]{1, 2, 3}

initializer_list val {?, ?, ?, …} 用一個array來接收 其實是儲存頭指針

cout << max({ 1, 2, 3 }) << " " << min({string(“a”), string(“b”), string(“c”) }) << endl;

explicit(for ctors taking more than one argument)

2.0之前讓編譯器不要自作主張

#include <iostream>
using namespace std;
 
class A
{
public:
    //這裡用explicit關鍵詞來修飾類構造函數.
    explicit A(int i = 5, int j = 10)
    {
        m_a = i;
        m_b = j;
    }
private:
    int m_a;
    int m_b;
};
 
int main()
{
    A s;
    //這樣直接指派,會被提示錯誤,因為explicit抑制隐式轉換的進行
    s = 10;//這樣會報錯!!!
    //當然顯示轉換還是可以的.
    s = A(20);
 
    system("pause");
    return 0;
}
           

Range-based for statement

for(dec1 : col){
	statement
}
           

全局函數 begin（） end（）

e.g. begin(vector…) 相當于 vector.begin()

=default =delete

=default 表示子類直接繼承父類

=delete 表示子類不寫這個函數

有指針的類就有big three（即預設構造，拷貝構造，析構）

Alias Template 化名

template<typename T>
using Vec = vector<T, MyAllo<T>>;
Vec<int> coll;
等價于
vector<int, MyAllo<int>> coll;
           

template template parameter

template<typename T, template typename Container>

template<typename T, template<typename U> typename Container>
class XCls{
    private:
    	container<T> c;
};
template<typename T>
class test{
    private:
    	T t;
};
template<typename T>
using mlst = list<T, allocator<T>>;// Alias Template 化名

int main(){
    XCls<string, test> myContain;
    // XCls<string, list> mylist; // 錯誤 因為list中有兩個參數
    XCls<string, mlst> mylist;
}
           

Type Alias, noexcept, override, final

Type Alias

using func = void (*)(int, int);
//等價于
typedef void (*func)(int, int);
           

noexcept

void foo() noexcept(true){}// 不抛出異常
// move過程中不抛出異常，讓程式放心。有move的時候程式有限調用move 而不是copy construct
MyString(MyString&& str) noexcept{}
MyString& operator=(MyString&& str) noexcept{}
           

override

幫助編譯器檢查是否為重寫

final

class Base1 final{};// 沒有人能繼承Base1
virtural void f() final{};// 沒有人能重寫f()
           

decltype

獲得變量類型

map<string, float> coll;
decltype(coll)::value_type elem;
// 相當于map<string, float>::value_type elem;

Template<typename T1, typename T2>
auto add(T1 a, T2, b) -> decltype(a + b)
           

Lambdas

[&id]()mutable{++id;}// 才能改變id值

           

int tobefound = 5;
auto lambda1 = [tobefound](int val) {return val == tobefound; };
cout << lambda1(5) << " " << lambda1(10) << endl;

           

屬于inline内聯函數

Variadic Templates

遞歸

void func(){}
template<typename T, typename... Types>
void func(const T& firstArg, const Types& ...args){
    func(args...);
}

           

template<typename... Value> 
class tuple{
public:
    size_t seed = 0;
    tuple(const Value&... args){tuple(seed, args...)}
};

// 特化
template<>
class tuple<>{};

template<typename Head, typename... Tail>
class tuple<Head, Tail...>:private tuple<Tail...>{
    typedef tuple<Tail...> inherited;
protect:
    Head m_head;
public:
    tuple(){};
    tuple(Head v, Tail... vtail):m_head(v), inherited(vtail){}
    // typename Head::type head(){return m_head};
    auto head()->decltype(m_head){return m_head};
    inherited& tail(){return* this;}
}

           

标準庫

Rvalue reference

copy 和 move

insert(cons_iterator _position, const value_type& _x);
insert(cons_iterator _position, const value_type&& _x);
關鍵字 move forward才能完美轉移

           

array forward_list

array數組 int a[10]; int* a = new int [10]

forward_list就是list改成單項清單

Hashtable

Hash function

tuple

tuple<int, float, string> t1(41, 6.3, "nice");
get<0>(t1);  get<1>(t1);  get<2>(t1);
auto t2 = make_tuple(41, 6.3, "nice");
get<1>(t1) = get<>(t2);
t1 = t2;