指向指針的引用

引用本身不是一個對象，所以不能定義指向引用的指針，但指針是對象，所以存在指針的引用。
可以通過從右往左理解為什么p是一個指針的引用，p的左邊是引用符號，因此p是一個引用，其余部分表示p引用的是一個int指針。

int main()
{
    int value1 = 10;
    int *value2 = &value1;
    int *&p = value2;
    *p = 100;
    std::cout << value1 << std::endl;//100
    return 0;
}

頂層const和底層const

頂層const表示指針本身是一個常量，底層const表示指向的對象是一個常量。

int main(void)
{
    int value1 = 10;
    const int *value2 = &value1;//指向const int的指針 底層const
    int* const value3 = &value1;//指向int的常量指針 頂層const

    *value2 = 100;//錯誤，指針指向的是一個常量，const int
    value2 = nullptr;//正確，指針本身可以修改

    *value3 = 100;//正確，指針指向的是int
    value3 = nullptr;//錯誤，指針本身是常量
    return 0;
}

類型別名

有兩種方式可以定義類型別名typedef和using。

typedef int xyint;//xyint是int的類型別名
typedef int *pxyint;//pxyint是int*的類型別名
using xydouble = double;//xydouble是double的類型別名
using pxydouble = double*;//pxydouble是double*的類型別名

int main(void)
{
    xyint value1 = 0;
    xydouble value2 = 3.14;
    pxyint value3 = nullptr;
    pxydouble value4 = nullptr;
    return 0;
}

它們之間的區(qū)別是typedef不能為模板類設(shè)置類型別名。

template <typename T>
typedef std::vector<T> vType;//錯誤


template <typename T>
using vType = std::vector<T>;//正確

類型別名，const，指針

如果類型別名指代的是指針類型，然后用const修飾的時候會產(chǎn)生意想不到的后果，例如下面的const pxyint，實際上指的是指向一個int的常量指針，原因是類型別名不是直接替換的，這個時候應該把pxyint看做一個整體。

typedef int *pxyint;
using pxydouble = double*;

int main(void)
{
    double value1 = 3.14;
    int value2 = 10;

    const pxyint value3 = &value2;//指向int的常量指針 頂層const
    const pxydouble value4 = &value1;//指向double的常量指針 頂層const
    *value3 = 100;//正確
     value3 = nullptr;//錯誤

    *value4 = 100;//正確
    value4  = nullptr;//錯誤
    return 0;
}

pxyint如果是用#define定義的話，const pxyint就是一個底層const了。

#define pxyint int * 

int main(void)
{
    int value1 = 10;
    const pxyint value2 = &value1;//指向const int的指針 底層const

    *value2 = 100;//錯誤
     value2 = nullptr;//正確
    return 0;
}

auto

有時候根本不知道一個表達式的類型，或者很難做到，C++11引入了auto類型說明符，讓編譯器自動去分析表達式的類型，所以auto定義的變量必須要有一個初始值。

int main(void)
{
    int value1 = 10;
    auto value2 = value1 + 100;//value2被推斷為int
    return 0;
}

和類型別名一樣，auto類型為指針類型時用const修飾會得到一個頂層const，而不是底層const。

int main(void)
{
    int value1 = 0,*value2=&value1;
    const auto value3 = value2;//頂層const
    *value3 = 100;//正確
    value3 = nullptr;//錯誤
    return 0;
}

使用auto定義多個變量時，類型必須一樣。

int main(void)
{
    auto value1 = 0, *value2 = &value1;//正確，value1是整形，value2是整形指針
    auto value3 = 0, value4 = 3.14;//錯誤，value3和value4類型不匹配
    return 0;
}

引用類型作為初始值時，auto推斷出來的類型為引用對象的類型，如果希望推斷出來的是一個引用，需要明確指出。

int main(void)
{
    int value1 = 0, &value2 = value1;
    auto value3 = value2;//value3類型為int
    auto &value4 = value1;//value4為一個引用
    return 0;
}

auto會忽略頂層const，保留底層const，如果希望推斷出來的是一個頂層const，需要明確指出。

int main(void)
{
    const int value1 = 0;
    auto value2 = value1;//value2是int類型
    const auto value3 = value1;//value3是const int類型
    return 0;
}

設(shè)置一個類型為auto的引用時，初始值中的頂層const將會保留。

int main(void)
{
    const int value1 = 0;
    auto &value2 = value1;//value2為const int
    return 0;
}

decltype

有時候我們想使用表達式推斷出來的類型，但是不想調(diào)用這個表達式，C++11引入了decltype類型指示符滿足這一要求，它的作用是返回表達式的數(shù)據(jù)類型，但是不會調(diào)用這個表達式。

int main(void)
{
    int value1 = 0;
    decltype(value1) value2 = 100;//value2類型為int
    return 0;
}

和auto不一樣， decltype不會忽略表達式的頂層const和引用。

int main(void)
{
    const int value1 = 0;
    const int &value2 = value1;
    decltype(value1) value3 = 100;//value3類型為const int
    decltype(value2) value4 = value1;//value4為const int的引用
    return 0;
}

如果decltype表達式內(nèi)容是指針的解引用操作，那么結(jié)果會是一個引用。

int main(void)
{
    int *value1 = nullptr;
    decltype(value1) value2;//value2是一個指針
    decltype(*value1) value3;//value3是int的引用
    return 0;
}

decltype表達式如果是雙層括號，那么結(jié)果永遠是引用，必須初始化。

int main(void)
{
    int value1 = 0;
    decltype((value1)) value2;
    return 0;
}

我們還可以利用標準類型轉(zhuǎn)換模板從一個引用獲取非引用類型。

int main()
{
    int value1 = 0;
    int& value2 = value1;
    remove_reference<decltype((value2))>::type value3=100;
    cout <<value3<< endl;
    system("pause");
}