C++ Primier读后感 之 第三章 C++数据类型

第三章：

1. 文字常量也存储在内存中的某个位置，但是我们无法访问它的地址。

 

2. 整形文字常量

20     正常写法被认为是十进制整形文字常量

024     以0开头的被认为是八进制整形文字常量

0x16      以 0x 或 0X 开头的被认为是十六进制的整形文件常量

 

3. 整形文字常量类型

20     默认情况是int型

20l(20L)     long型

20u(20U)     unsigned int型

20ul(20Ul)(20uL)(20U     unsigned long型

 

4. 浮点型文字常量

31.4     普通十进制写法

3.14e1(3.14E1)     科学计数写法

 

5. 浮点型文字常量类型

3.14     默认是double型

3.14f(3.14F)     float型

3.14l(3.14L)     long double型

注意：f L F L 只能用在十进制表示的浮点型文字常量上。

 

6. 布尔型文字常量只有两个：true和false

 

7. 字符型文字常量

 ‘A’     单引号方式，此方式只能表示可打印的字符

 ‘/101’     转义方式，此方法可以表示所有字符

65     ASCII方式，此方式可以表示所有字符

说明：转义方式的格式是 ‘/000’,000表示三个8进制数。

0101 = 65 = ‘A’     所以’/101’表示字符’A’

0041 = 33 = ‘!’     所有’/41’表示字符’!’

 

8. 字符型文字常量的类型

‘A’     char型

L’A’     wchar_t型

 

9. 字符串常量

“/t/101/n”     退格A换行

“/t/1801/n”     退格+字符’/001’+”801” +换行(/自动截取连续三位数字，遇到不满足8进制的字符自动截断，并在前面补0)

“1111/

22222/

3333333”      “111222223333333”(加入’/’，可以把多行字符串常量连在一起)

“1111” “2222”  “11112222”     在程序中相邻的两个字符串常量，程序自动将它们连在一起

L”1111”     宽字符组成的字符串

 

10. 下面语句等义

int number = 1024;

int number(1024);

int number = number;     语句合法但是不明智

int number = int();     number被初始化为0

double dval = double();     dval被初始化为0.0

 

11. 常量

const double pi;     错误，必须初始化

const double pi = 3.14;     正确

double pii = 3.14;  double * p = π     错误，const指针才能指向常量

const * p = π     正确

const * p = &pii;     正确，尽管pii不是常量，但是通过p来修改pii还是不允许的。

说明：指向常量的指针能指向常量和非常量，指向非常指针只能指向非常量。

 

12. 引用

double & ref;     错误，引用定义后必须马上初始化

double pi; double & ref = pi;     正确

double pi; const double & ref = pi;     正确

double pi = 1024; int & ref = pi;     错误，非常引用无法引用不同类型的对象

double & ref = 1024;     错误，非常引用不能引用文字常量

double pi = 1024; const int & ref = pi;     正确，常引用可以引用不用类型对象

const double & ref = 1024;     正确，常引用可以引用文件常量

说明：常引用可以引用不同类型的对象和文字常量。编译器对它进行的处理时如下，

double pi = 1024; 

int temp = pi; 

const int & ref = temp;

编译器先建立一个同类型的临时对象，并用原始对象初始化，这里必须保证原始对象类型和临时对象之间存在隐试转换条件。然后常引用引用生成的那个临时对象。这里我们可以看出，其实如果改变ref的值，原始对象pi的值并没有随之改变。这和引用的定义不相符，但是由于ref是const类型，所以不存在这个可能。同理，文字常量的引用也是存在一个临时对象。

 

13. 枚举

Emun Forms{Input, Append, Output};     定义一个枚举类型，默认情况下Input = 0,Append = 1,Output = 2

Emun Forms{Input = 3, Append, Output};     定义一个枚举类型，Input = 3,Append = 4,Output = 5

Forms fom = 3;     错误，不能用3直接赋值

Forms fom = Input;     正确

Cout << Input;     输出为3，无法打印枚举的名字，除非进行特殊的处理

Int m = 2 * Input;     m = 6，枚举可以参与算术运行，在此时它被提升为int型

 

14. 一维数组

int size = 2; int array[size];     错误，一维数组的维数在定义的时候必须是一个在编译时刻能够计算出来的值，这意味着只有整形文字常量和整形const对象才能作为维数。

Const int size = 2; int array[size];     正确

Int array[2];     正确

Int x, y, z; int * p[] = {&x, &y, &z};     正确，p是一个数组，数组由int*组成

Int x, y, z; int &ref = {x, y, z};     错误，无法定义个由引用组成的数组

Int x, y, z; Int mm[] = {x, y, z}; int * & ref = mm;     错误，ref是一个普通指针的引用，而mm的类型是 int * const，即常指针。

Int x, y, z; Int mm[] = {x, y, z}; const int * & ref = mm;     错误，ref是一个指向常量的指针的引用，而mm是一个常指针。

Int x, y, z; Int mm[] = {x, y, z}; int * const & ref = mm;     正确，ref是一个引用，它引用一个常指针。

存在引用指针，不存在指针的引用。

int *p; int * & ref = p;     ref是一个int型指针的引用

int m; int & ref = m; int & * p = &ref;     p是一个指针，它指向一个引用，这个语句是不允许的。

 

15. 多维数组

Int ia[2][3] = {1};     定义了一个2行3列的二维数组，第一个元素初值为1，其余的元素初值为0。

Ia[1,2] = 3;     正确，1,2是一个逗号表达式，其值为2，所有等价于ia[2] = 3; 此句语法正确，但语意错误。

 

16. vector

Vector<int> ivec;     定义个含有0个元素的容器

Vector<int> ivec; ivec[0] = 1;     错误，ivec中一个元素都没有，无法索引

Vector<int> ivec(10);     定义一个含有10个int型元素的容器，元素的初始值为0

Vector<int> ivec(10); ivec[0] = 1;     将容器中的第一个元素的值赋为1

Vector<int> ivec; ivec.push_back(10);     在容器中插入一个值为10的元素，此时容器中有1个元素

Vector<int> ivec(10); ivec.push_back(10);     在容器末尾插入一个值为10的元素，此时容器中有11个元素

Vector<int> ivec(10, 2);     定义一个含有10个int型元素的容器，元素的初始值为2

Int ia[6] = {1}; vector<int> ivec(ia, ia + 3);     定义一个容器，其中包含ia, ia+1, ia+2, ia+3这三个元素。

Vector<int> ivec; vector<int> ivecc(ivec);     用一个容器初始化另外一个容器。

Vector<int> ivec; vector<int> ivecc; ivecc = ivec;     将一个容器赋值给另外一个容器

 

17. 复数类型

Complex<double> purei(0, 7);     定义个纯虚数：0 + 7i

Complex<float> real_num(3);     定义个实数：3 + 0i

Complex<long double> zero;     0 + 0i

说明：复数对象只有double,float,long double这几种类型。

 

18. typedef

Typedef char * CString; extern const CString cstr;     这里cstr的类型是 char * const 即常指针。

#define char * CString; extern const CString cstr;     这里cstr的类型是 const char * 即指向常量的指针。

说明：typedef不是宏替换。第一句中，const和CString都是修饰cstr的，所以cstr是个const类型的字符指针，即常指针。而第二句话中，CString是一个宏名，编译器会自动展开为 extern const char * cstr; 很明显，这里的cstr是一个指向常量的普通指针。

 

19. pair类型

Pair<string, string> author(“James”, “Joyce”);     定义了一个pair对象author

Pair<string, string> author(“James”, “Joyce”);

if(author.first == “James”)  author.second = “Joyce”; 

定义了一个pair对象，并且通过first和second来访问它的成员。