C++_基础2-复合数据类型

C语言使用术语“派生类型”，C++对类关系使用术语“派生”。所以就改用“复合类型”。

数组

数组是一种数据格式，能够存储多个同类型的值。

数组声明应指出以下三点：

存储在每个元素中的值的类型；

数组名；

数组中的元素数；

通用的声明格式： typeName arrayName[arraysize];

声明中所有的值在编译时都是已知的。arraysize不能是变量，变量的值是在程序运行时设置的。C++可以使用new运算符来避开这种限制；

数组的特性：

可以单独访问数组元素；

方法是使用下标或索引来对元素进行编号；

C++数组从0开始编号；

C++使用带索引的方括号表示法来指定数组元素，称为随机访问；

最后一个元素的索引比数组长度小1；

编译器不会检查数组下标是否有效。本着信任程序员的原则，程序员必须确保下标的有效性。下标无效会引发数组越界，可能会修改破坏数据或代码，后果很严重。

数组的初始化

只有在定义数组时才能使用初始化。

例：int yamcosts[3]={20,30,5};

不能将一个数组赋值给另一个数组；

初始化数组时，提供的值可以少于数组的元素数目；

也可以把数组元素都初始化为零，例：long totals[500]={0};

如果初始化数组中的方括号[]为空，C++编译器将计算元素个数：

例：short things[ ] ={1,5,3,8};

C++11数组初始化方法

可以使用大括号

C++标准模板库（STL）提供了一种数组替代品——模板类vector，而C++新增了模板类array。

======================================

字符串

字符串是存储在内存的连续字节中的一系列字符。C++处理字符串的方式有两种：第一种来自C语言，常被称为C-风格字符串。另一种是基于string类库的方法。

字符串可以存储在char数组中。其实字符串可以解释为以\0结尾的char类型数组。空字符被写作\0，其ASCII码为0，用来标记字符串的结尾。没有以\0结尾的char类型数组不是字符串，只是字符数组而已。

第一种字符串初始化方法：

char dog[8] ={‘b’ , ‘e’, ‘a’, ‘u’, ‘x’, ‘\0’ };

这种方法比较冗长乏味，还有更好的初始化方法，只需使用双引号括起来的字符串即可。这种字符串被称为字符串常量或字符串字面值。

char fish[] = “Bubbles”;

双引号括起来的字符串隐式地包括结尾的空字符。另外各种C++输入工具通过键盘输入，将字符串读入到char数组中，将自动在结尾加上字符。

当然应该确保数组足够大，能够存储字符串中所有字符——包括空字符。

数组的长度比字符串长没有什么坏处，只是会浪费一些空间而已。因为处理字符串的函数根据空字符的位置，而不是数组的长度来处理。

在确定存储字符串所需的最短数组时，别忘了将结尾的空字符计算在内。

字符串常量（使用双引号）和字符常量（使用单引号）不能互换。字符常量（‘S’）是字符串编码的简写表示。在ASCII系统上，‘S’只是83的另一种写法。因此可以：

char shirt_size = ‘S’;

但“S”不是字符常量，它表示的是两个字符（字符S和\0）组成的字符串。“S”实际上表示的是字符串所在的内存地址。

拼接字符串常量

字符串很长，无法放到一行中。C++允许拼接字符串字面值，即将两个用引号括起来的字符串合并为一个。事实上，任何两个由空白（空格，制表，换行符）分隔的字符串常量都将自动拼接成一个。

cout <<”I’d give my right arm to be” ”a great violinist.\n”;

在数组中使用字符串

sizeof运算符指出整个数组的长度，单位是字节。

strlen()函数返回的是存储在数组中的字符串的长度，而不是数组本身的长度。

strlen()只计算可见字符，而不把空字符计算在内。

使用符号常量的好处：修改更加方便，只需在定义符号常量的地方修改即可。

字符串输入

cin有个缺陷，它使用空白（空格、制表符、换行符）来确定字符串的结束位置。这意味着cin在获取字符数组输入时只读取一个单词。读取该单词后，cin将该字符串放到数组中，并自动在结尾添加字符串。

很多程序都依赖字符串输入，因此有必要对该主题做进一步探讨。必须使用cin的高级属性。

每次读取一行字符串输入

需要采用面向行而不是面向单词的输入方法。

iostream中的类提供了一些面向行的类成员函数：getline()和get()[j周1] 。这两个函数都获取一行的输入，直到到达换行符。

区别在于：getline()丢弃换行符，get()将换行符保留在输入序列中。

1、面向行的输入：getline()

getline()读取整行，它使用通过回车输入的换行符来确定输入结尾。

要调用这种方法，可以使用cin.getline()。该函数有两个参数，第一个是用来存储输入行的数组名，第二个参数时要读取的字符数。如果这个参数是20，则该函数最多读取19个字符。

2、面向行的输入：get()

get()不读取换行符，将换行符留在输入队列中。这样连续两次使用get()函数，会导致get()将不能跨过该换行符。

get()有一个变体，使用不带任何参数cin.get()调用可读取下一个字符（即使是换行符）。因此可以用它来处理换行符，为读取下一行输入做准备。

假设用get()将一行读入数组中，如果是换行符，说明已读取了整行。否则，说明该行中还有其他输入。

如何知道停止读取的原因是由于读取了整行，而不是由于数组已填满？

getline()使用起来更简单，get()使得检查错误更简单些。

3、空行和其他问题

getline()和get()读取空行时，将发生什么情况？

下一条输入语句将在前一条getline()或get()结束读取的位置开始读取。但是当前的做法是：当get()读取空行后，将设置失效位。这意味着接下来的输入将被阻断。但可以用一下的命令来恢复 cin.clear();

另一个潜在的问题，输入字符串可能比分配的空间长。则getline()和get()会把余下的字符留在输入队列中，而getline()还会设置失效位，并关闭后面的输入。

后续章节会讨论如何避免这些问题。

混合输入字符串和数字

cout <<”What year was your house built?\n”;

int year;

cin >> year;

cout << “What is its street address?\n”;

char address[80];

cin.getline(address,80);

这个程序有一个问题，没等用户有输入地址的机会。问题在于，当cin读取年份时，将回车键生成的换行符留在了输入队列中。后面的cin.getline()看到换行符后，将认为是一个空行，并将一个空字符串赋值给address。这个问题的解决方法是：在读取地址之前先读取并丢弃换行符。

C++常用指针而不是数组来处理字符串。

======================================

string类简介

ISO/ANSI C++98标准通过添加string类扩展了C++库，因此现在可以用string类型的变量而不是字符数组来存储字符串。

要使用string类，必须在程序中包含头文件string。String类位于名称空间std中，因此必须提供一条using编译指令，或者使用str::string来引用它。String类定义隐藏了字符串的数组性质，让您能够像处理普通变量那样处理字符串。

可以使用cin来将键盘输入存储到string对象中；

可以使用cout来显示string对象；

可以使用数组表示法来访问存储在string对象中的字符；

可以使用C-风格字符串来初始化string对象；

C++11字符串初始化

C++11允许将列表初始化用于C-风格字符串和string对象：

char first_date[ ] = {“Le Chapon Dodu”};

string third_date = {“The Bread Bowl”};

赋值、拼接和附加

使用string类的某些操作比数组简单。可以将一个string对象赋给另一个string对象。

string str1;

string str2 = “panther”;

str1 = str2;

string类简化了字符串合并操作。可以使用运算符+将两个string对象合并起来，还可以用运算符+=将字符串附加到string对象的末尾。

string str3;

str3 =str1 +str2;   //str3由str1和str2相加组成；

str1 += str2;          //str2加到str1末尾构成了str1；

string类的其他操作

string类I/O

使用cin和运算符>>来将输入存储到string对象中。

使用cout和运算符<<来显示string对象。

每次读取一行而不是一个单词时，使用的句法不同。

char charr[20];

对于未初始化的数组内容是未定义的。函数strlen()从数组的第一个元素开始计算，直至遇到空字符为止。对于未初始化的数据，第一个空字符的出现位置是随机的。因此在运行程序的时候，得到的数组长度可能不同。

其它形式的字符串字面值

除了char类型外，还有wchar_t，char16_t，char32_t；

可以创建这些类型的数组和这些类型的字符串字面值；

对于这些类型的字符串字面值，要使用前缀L、u、U表示。

wchar_t  title[ ] = L”Chief Astrogator”;

char16_t name[ ] = u”Felonia Ripova”;

char32_t car[ ] = U”Humber Super Snipe”;

新增一种Raw类型字符串，在原始字符串中，字符表示的就是自己。没有转义。定界符采用的是”+*( 和 )*+”的形式。前缀使用R

==================================

结构简介

       结构是一种比数组更灵活的数据格式。同一结构可以存储多种类型的数据，从而将数据的表示合并到一起。结构也是OOP堡垒的基石。

       结构是用户定义的类型。结构声明定义了这种类型的数据属性。定义了类型后，便可以创建这种类型的变量。

声明结构模板，创建结构变量

关键字struct表明，这些代码定义的是一个结构的布局。

标识符inflatable是这种数据格式的名称。称为结构标记。标记成为新类型的名称。

struct inflatable

{

char name[20];

float volume;

double price;

}

C++中在创建结构类型的变量时，省略了struct关键字。

inflatable hat;

在程序中使用结构

声明的位置：外部声明（可以被其后的任何函数使用）、内部声明只能被声明所属的函数使用。

C++结构初始化

使用列表初始化；

如果大括号内未包含任何东西，各个成员都将被设置为零；

结构可以将string类作为成员吗

其他结构属性

C++使用户定义的类型与内置类型尽可能相似。

结构作为参数传递给函数，函数返回一个结构，使用赋值运算符（=），

结构赋值，这种赋值被称为成员赋值。

C++的结构特性比C更多。但是这些特性更多用于类中，而不是结构中。

结构数组

结构数组本身是个数组，

结构数组的初始化方式：遵循初始化数组的规则，用逗号分隔每个元素的值，并将这些值用花括号括起来。然后用初始化结构的规则取初始化数组元素。

结构中的位字段

======================================

共用体

共用体（Union）是一种数据格式，它能存储不同的数据类型，但只能同时存储其中的一种类型。

共用体的用途：当数据项使用两种或多种格式时，可节省空间。

匿名共用体：没有名称，其成员将成为位于相同地址处的变量。显然，每次只有一个成员是当前的成员。

共用体常用于节省内存。尤其是对于嵌入式系统编程，共用体常用于操作系统数据结构或硬件数据结构。

===================================

枚举

enum工具提供另一种创建符号常量的方式。这种方式可以替代const。

enum spectrum {red, orange, yellow, green, blue, violet, indigo, ultraviolet};

这条语句做了两件事，第一是让spectrum成为了枚举类型，像struct变量被称为结构一样。

里面的red，orange等被作为符号常量。对应的整数值0~7。这些常量叫作枚举量。

枚举变量，只能使用定义枚举类型时，初始化的那些枚举量来给枚举变量赋值。

spectrum band;

band = blue;

所以spectrum变量会受到限制，只有8个可能的值。如果试图将一个非法值赋值给它，编译器会报错。

枚举量是整型，可被提升为int类型。但int类型不能自动转换为枚举类型。

设置枚举量的值

可以使用赋值运算符来显式地设置枚举量的值；

enum bits{one=1,  two=2, four=4, eight=8};

指定的值必须是整数，也可以只显式地定义其中一些枚举量的值；

enum bigstep{first, second =100, third};

first在默认情况下为0，后面没有被初始化的枚举量的值将比前面的枚举量大1。因此，third的值为101。

枚举的取值范围

======================================

指针和自由存储空间

计算机程序在创建数据时必须跟踪3种属性：

信息存储在何处；

存储的值为多少；

存储的信息是什么类型；

使用一种策略达到上述目的：定义一个简单的变量。声明语句指出了值的类型和符号名。

接下来是另外一种策略：在开发C++类时非常重要，这种策略以指针为基础，指针是一个变量，其存储的值是地址。

查看常规变量地址的方法：取址运算符（&）；

指针策略是C++内存管理编程理念的核心。

指针与C++基本原理

       面向对象编程与传统的过程性编程的区别在于，OOP强调的是运行阶段（而不是编译阶段）进行决策。运行阶段是指程序正在运行时，编译阶段指的是编译器将程序组合起来时。

运行阶段决策提供了灵活性，可以根据当时的情况进行调整。C++采用的方法是，使用关键字new请求正确数量的内存以及使用指针来跟踪新分配的内存的位置。

处理存储数据的新策略刚好相反，将地址视为指定的量，而将值视为派生量。

一种特殊类型的变量：指针。用于存储值的地址，指针名表示的是地址，*运算符被称为间接值或解除引用运算符，将其应用于指针，可以得到该地址处存储的值。

int updates = 6;

int * p_updates;

p_updates = &updates;

变量updates表示值，并使用&运算符表示地址；

指针p_updates表示地址，并使用*运算符表示指向变量的值；

声明与初始化指针

指针声明必须指定指针所指向的值的类型。

p_updates是指针，*p_updates是int，不是指针；

C++风格的指针声明：

int*  ptr;  //用于强调int*是一种类型，指向int的指针。可以把int*理解成一种复合类型

指针是一种特殊类型的变量，指针变量不仅仅是指针，而是指向特定类型的指针。

可以在声明语句中初始化指针，但是被初始化的是指针，而不是它指向的值。

int higgens =5;

int * pt = &higgens;

指针的危险

C++创建指针时，计算机将分配用来存储地址的内存。但不会分配用来存储指针所指向的数据的内存。为数据提供空间是一个独立的步骤。

声明了指针，没有初始化，指针就不知道指向哪里。

指针一定要初始化。在使用指针应用解除引用*运算符之前。

指针和数字

使用new来分配内存

如何实现在程序运行时分配内存。将指针初始化为变量的地址；变量是在编译时分配的有名称的内存。指针只是为可以通过名称直接访问的内存提供了一个别名。

指针真正的用武之地在于：在运行阶段分配未命名的内存以存储值。在这种情况下，只能通过指针来访问内存。在C语言中，可以用库函数malloc()来分配内存；在C++中仍可这样做，但C++还有更好的方法——new运算符。

在运行阶段为一个int值分配未命名的内存，并用指针来访问这个值：

int * pn = new int;

这里的关键所在是C++的new运算符，程序员要告诉new，需要为那种数据类型分配内存，new找到一个长度正确的内存块，并返回该内存块的地址。程序员的责任就是把该地址赋给一个指针。

new分配的内存没有名称，该怎么称呼它呢，我们用一个术语叫：数据对象。数据对象指的是为数据项分配的内存块。变量也是数据对象。

为一个数据对象获得并指定分配内存的通用格式：

typeName * pointer_name = new typeName;

注意：new分配的内存块通常与常规变量声明分配的内存块不同。普通变量的值都存储在被称为栈（stack）的内存区域中。而new从被称为堆（heap）或自由存储区（free store）的内存区域分配内存。

使用delete释放内存

在使用完内存后，需要将其归还给内存池。

使用delete，后面要加上指向内存块的指针。

例如

int * ps = new int;

…

delete ps;

这将释放ps指向的内存，但不会删除ps本身。

一定要配对地使用new和delete。否则将发生内存泄漏，也就是说分配的内存块再也无法使用了。如果内存泄漏严重，则程序将由于不断寻找更多内存而终止。

不要尝试释放已经释放的内存。这样做的结果将是不确定的，这意味着什么情况都有可能发生。

一般来说，不要创建两个指向同一内存块的指针，因为这将增加错误地删除同一个内存块两次的可能性。

使用new来创建动态数组

通常，对于大型数据（数组、字符串，结构），应使用new。这正是new的用武之地。在编译时给数组分配内存被称为静态联编（static binding），这意味着数组在编译时被加入到程序中。但使用new时，如果在运行阶段需要数组，则创建它；如果不需要，则不创建。还可以在程序运行时选择数组的长度。这被称为动态联编（dynamic binding）。这种数组叫作动态数组（dynamic array）。

关于动态数组的两个基本问题：如何使用C++的new运算符创建数组以及如何使用指针访问元素。

使用new创建动态数组：只要将数组的元素类型和元素数目告诉new即可。

int * psome = new int [10];

new运算符返回第一个元素的地址，该地址被赋值给指针。

当使用完new分配的内存块时，应使用delete来释放它们。

对于使用new创建的数组，应使用另一种格式的delete来释放：

delete [ ] psome;

方括号告诉程序，应释放整个数组，而不仅仅是指针指向的元素。要注意指针和delete之间的方括号。

如果使用new时，不带方括号，则使用delete时，也不应带方括号。

为数组分配内存的通用格式如下：

Type_name * pointer_name = new type_name [num_elements];

使用动态数组：

创建动态数组后

int * psome = new int [10]; 如何访问其中的元素？只要把指针当做数组名使用即可。这样使用指针来访问动态数组就很方便了。

===================================

指针、数组和指针算术

整数变量增加1后，其值将增加1；

指针变量增加1后，其值增加的量等于它指向的类型的字节数；

另外指针把数组名解释为地址；

C++把数组名解释为数组第1个元素的地址；

数组名更像是指针常量。

程序说明

sizeof 数组   ---> 得到数组的长度（这种情况下数组名不被解释为地址）

sizeof 指针   ---> 得到指针的长度

short tell[10];

cout << tell <<  endl;  //&tell[0],第一个元素的地址；

cout << &tell << endl;  //&tell是一个20字节内存块的地址；

指针小结

声明指针

要声明指向特定类型的指针：typeName * pointerName;

给指针赋值

应该将内存地址赋值给指针。可以对变量名应用&运算符，来获得被命名内存的地址。new运算符返回未命名内存的地址。

对指针解除引用

对指针解除引用来获得指针指向的值。对指针应用解除引用或间接值运算符（*）。

区分指针和指针所指向的值

如果pt是指向int的指针，则*pt不是指向int的指针，而是完全等同于一个int类型的变量。pt才是指针。

数组名

在多数情况下，C++将数组名视为数组的第一个元素的地址。

将sizeof运算符用于数组名用时，此时将返回整个数组的长度（单位为字节）。

指针算术

C++允许指针与整数相加，加1的结果等于原来的地址值加上指向的对象占用的总字节数。

还可以将两个指针相减，获得两个指针的差，这种运算仅当两个指针指向同一个数组时，才有意义，这将得到两个元素的间隔。

数组的动态联编和静态联编

使用数组声明来创建数组时，采用静态联编，即数组的长度在编译时设置；

使用new[ ]运算符创建数组时，采用动态联编，即将在运行时为数组分配空间，其长度也将在运行时设置。

数组表示法和指针表示法

使用方括号数组表示法等同于对指针解除引用；

指针和字符串

char flower[10] =”rose”;

cout << flower << “s are red\n”;

如果给cout一个字符的地址，则它将从该字符开始打印，直到遇到空字符为止。

对于数组中的字符串、用引号括起来的字符串常量以及指针所描述的字符串，处理方式是一样的，都将传递它们的地址。与逐个传递字符串中的所有字符相比，这样的工作量确实要少。都将解释为字符串第一个字符的地址。

使用new创建动态结构

结构指针访问结构成员不能使用句点运算符；

应该使用：

箭头成员运算符（->）；

或者（* ps）.price  这样的格式；

自动存储、静态存储和动态存储

C++有3种管理内存的方法：自动存储、静态存储、动态存储（自由存储空间或堆）；

自动存储：

函数内部定义的常规变量使用自动存储空间，被称为自动变量，这意味着它们在所属的函数被调用时自动产生，在该函数结束时消亡。

自动变量是一个局部变量，其作用域为包含它的代码块。

自动变量通常存储在栈中。这意味着执行代码块时，其中的变量将依次加入到栈中。而在离开代码块时，将按相反的顺序释放这些变量，这被称为后进先出。在程序执行的过程中，栈将不断地增大和缩小。

静态存储：

静态存储是整个程序执行期间都存在的存储方式。使变量成为静态的方式有两种：一种是在函数外面定义它，一种是在声明变量时使用关键字static。

动态存储：

new和delete运算符提供了一种比自动变量和静态变量更灵活的方法。它们管理了一个内存池，这在C++中被称为自由存储空间（free space）或堆（heap）。该内存池和用于静态变量及自动变量的内存是分开的。

数据的生命周期完全不受程序或函数的生存时间控制。这使得程序员对内存有更大的控制权，然而内存管理也变得复杂了。

栈、堆和内存泄漏：

内存泄漏就是指用new在自由内存空间创建变量后，没有用delete释放，并且在指针无效后，无法访问该内存了。这将导致内存泄漏。后果很严重，可能导致内存被耗尽，程序崩溃。要避免内存泄漏，要养成一种习惯，即同时使用new和delete运算符。

===================================

类型组合

数组、结构和指针

================================== 

数组的替代品

模板类vector和array是数组的替代品。

模板类vector

类似于string类，也是动态数组。

可以在运行阶段设置vector对象的长度，可在末尾附加新数据，还可在中间插入新数据。基本上，它是使用new创建动态数组的替代品。

vector<typename> vt(n_elem);

模板类 array(C++11)

vector类的功能比数组强大，但付出的代价是效率低下。

如果需要长度固定的数组，使用数组时更佳的选择，但代价是不那么方便和安全。

C++11新增了模板类array，它也位于名称空间std中。与数组一样，array对象的长度也是固定的，也使用栈（静态内存分配），而不是自由存储区。

比较数组、vector对象和array对象

========================================

总结

1 数组、结构和指针是C++的3种复合类型。数组可以在一个数据对象中存储多个同类型的值。通过使用索引或下标，可以访问数组中各个元素。

2 结构可以将不同类型的值存储在同一个数据对象中。可以使用成员关系运算符（.）来访问其中的成员。使用结构的第一步是创建结构模板，它定义了结构存储哪些成员。模板的名称将成为新类型的标识符，然后就可以声明这种类型的结构变量。

3 共用体可以存储一个值，但是这个值可以是不同类型。

4 指针是被设计用来存储地址的变量。指针指向它存储的地址。指针声明指出了指针指向的对象的类型。对指针应用解除引用运算符，将得到指针指向的位置中的值。

5 字符串是以空字符为结尾的一系列字符。字符串可用引号括起来的字符串常量表示，其中隐式包含了结尾的空字符。

6 头文件string支持的C++ string类提供了另一种对用户更友好的字符串处理方法。

7 new运算符允许在程序运行时为数据对象请求内存。该运算符返回获得内存的地址，用来赋值给指针。这样程序能够用指针来访问这块内存。如果数据对象是普通变量，可以使用解除引用（*）来获得其值。如果数据对象是数组，则可以使用数组名那样使用指针来访问元素。如果数据对象是结构，则可以用指针解除引用运算符（->）来访问其成员。

8 指针和数组密切相关。如果ar是数组名，则表达式ar[i]被解释为*(ar+i)。其中数组名被解释为数组第一个元素的地址。数组名的作用和指针相同。反过来，可以用数组表示法，通过指针名来访问new分配的数组中的元素。

9 运算符new和delete允许显式控制何时给数据对象分配内存，何时将内存归还给内存池。自动变量是函数中声明的变量。静态变量是在函数外部或者使用关键字static声明的变量。这两种变量都不太灵活。自动变量在进入代码块时产生，离开代码块时终止。静态变量在整个程序周期内都存在。

10 C++98新增的标准模板库（STL）提供了模板类vector，它是动态数组的替代品。C++11提供了模板类array，它是定长数组的替代品。