C++程序设计（第4版）读书笔记

C++程序设计（第4版）读书笔记_类型与声明

字符类型

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main()
 6 {
 7     cout << '0' + 2 << endl;
 8     cout << static_cast<char>('0' + 2) << endl;
 9     
10     return 0;
11 }

运行结果：

注意类型转换

再谈auto

1、在使用auto自动推断变量类型时，没有必要采用列表初始化“{}”的方式，而是直接用“=”就好了

2、在较小的作用域中建议优先使用auto

 1 template<class T> void f1(vector<T> & arg)
 2 {
 3     for (vector<T>::iterator p = arg.begin(); p != arg.end(); ++p) {
 4         * p =7;
 5     }
 6   
 7     for (auto p = arg.begin(); p != arg.end(); ++p) {
 8         * p =7;
 9     }   
10 }

很明显，第二种方法要好，第一书写要少，第二如果把vector改为了list，第二种方法也能适配

再谈列表初始化

以vector来举例

vector<int> v1 {99}; //v1包含1个元素，该元素值为99
vector<int> v2 （99）; //v2包含99个元素，每个元素都取默认值0

vector<string> v1 {"hello"}; //v1含有1个元素，该元素值为"hello"
vector<string> v2 ("hello"); //错误：vector的任何构造函数都不接受字符串字面值常量作为参数

因此，除非有充分的理由，否则最好使用{}初始化

下面再给出一些例子：

1 int x4 {}; //x4被赋值为0
2 double d4 {}; //d4被赋值为0.0
3 char buf[1024] {}; //对于任意i，buf[i]的值为0
4 char * p {}; //p被赋值为nullptr
5 int * p {new int{10}}; //* p的值变为10
6 char * q {new char[1024] {}}; //对于任意i，q[i]的值变为0
7 vector<int> v4 {}; //v4被赋值为一个空向量
8 string s4 {}; //s4被赋值为""

decltype

1、decltype意义

有时我们希望从表达式的类型推断出要定义的变量类型，但是不想用该表达式的值初始化变量（如果要初始化就用auto了）。为了满足这一需求，C++11新标准引入了decltype类型说明符，它的作用是选择并返回操作数的数据类型，在此过程中，编译器分析表达式并得到它的类型，却不实际计算表达式的值。

2、decltype用法

（1）基本用法

 1 int getSize();
 2 
 3 int main(void)
 4 {
 5     int tempA = 2;
 6     
 7     /*1.dclTempA为int*/
 8     decltype(tempA) dclTempA;
 9     /*2.dclTempB为int，对于getSize根本没有定义，但是程序依旧正常，因为decltype只做分析，并不调用getSize，*/
10     decltype(getSize()) dclTempB;
11 
12     return 0;
13 }

（2）与const结合

    double tempA = 3.0;
    const double ctempA = 5.0;
    const double ctempB = 6.0；
    const double *const cptrTempA = &ctempA;
    
    /*1.dclTempA推断为const double（保留顶层const，此处与auto不同）*/
    decltype(ctempA) dclTempA = 4.1;
    /*2.dclTempA为const double，不能对其赋值，编译不过*/
    dclTempA = 5;
    /*3.dclTempB推断为const double * const*/
    decltype(cptrTempA) dclTempB = &ctempA;
    /*4.输出为4（32位计算机）和5*/
    cout<<sizeof(dclTempB)<<"    "<<*dclTempB<<endl;
    /*5.保留顶层const，不能修改指针指向的对象，编译不过*/
    dclTempB = &ctempB;
    /*6.保留底层const，不能修改指针指向的对象的值，编译不过*/
    *dclTempB = 7.0;

（3）与引用结合

    int tempA = 0, &refTempA = tempA;

    /*1.dclTempA为引用，绑定到tempA*/
    decltype(refTempA) dclTempA = tempA;
    /*2.dclTempB为引用，必须绑定到变量，编译不过*/
    decltype(refTempA) dclTempB = 0;
    /*3.dclTempC为引用，必须初始化，编译不过*/
    decltype(refTempA) dclTempC;
    /*4.双层括号表示引用，dclTempD为引用，绑定到tempA*/
    decltype((tempA)) dclTempD = tempA;
    
    const int ctempA = 1, &crefTempA = ctempA;
    
    /*5.dclTempE为常量引用，可以绑定到普通变量tempA*/
    decltype(crefTempA) dclTempE = tempA;
    /*6.dclTempF为常量引用，可以绑定到常量ctempA*/
    decltype(crefTempA) dclTempF = ctempA;
    /*7.dclTempG为常量引用，绑定到一个临时变量*/
    decltype(crefTempA) dclTempG = 0;
    /*8.dclTempH为常量引用，必须初始化，编译不过*/
    decltype(crefTempA) dclTempH;
    /*9.双层括号表示引用,dclTempI为常量引用，可以绑定到普通变量tempA*/
    decltype((ctempA))  dclTempI = tempA;

（4）与指针结合

    int tempA = 2;
    int *ptrTempA = &tempA;
    /*1.常规使用dclTempA为一个int *的指针*/
    decltype(ptrTempA) dclTempA;
    /*2.需要特别注意，表达式内容为解引用操作，dclTempB为一个引用，引用必须初始化，故编译不过*/
    decltype(*ptrTempA) dclTempB;

3、decltype总结

decltype和auto都可以用来推断类型，但是二者有几处明显的差异：

（1）auto忽略顶层const，decltype保留顶层const；

（2）对引用操作，auto推断出原有类型，decltype推断出引用；

（3）对解引用操作，auto推断出原有类型，decltype推断出引用；

（4）auto推断时会实际执行，decltype不会执行，只做分析。

ps：关于auto和decltype，后续再详细补充

本文部分参考自：

http://www.cnblogs.com/cauchy007/p/4966485.html