目录
C++类和对象
- C++ 中的类（Class）可以看做C语言中结构体（Struct）的升级版。结构体是一种构造类型，可以包含若干成员变量，每个成员变量的类型可以不同；可以通过结构体来定义结构体变量，每个变量拥有相同的性质。
- C++ 中的类也是一种构造类型，但是进行了一些扩展，类的成员不但可以是变量，还可以是函数；通过类定义出来的变量也有特定的称呼，叫做“对象”。创建对象后就可以通过点号
.来使用变量和函数。- C语言中的 struct 只能包含变量，而 C++ 中的 class 除了可以包含变量，还可以包含函数。
- 结构体和类都可以看做一种由用户自己定义的复杂数据类型，在C语言中可以通过结构体名来定义变量，在 C++ 中可以通过类名来定义变量。不同的是，通过结构体定义出来的变量还是叫变量，而通过类定义出来的变量有了新的名称，叫做对象（Object）
- 类起到说明的作用，不占用内存空间；对象才是具体的零件，要有地方来存放，才会占用内存空间。
在 C++ 中，通过类名就可以创建对象，这个过程叫做类的实例化，因此也称对象是类的一个实例（Instance）。
有些资料也将类的成员变量称为属性（Property），将类的成员函数称为方法（Method）。
- 因为 C++、Java、C#、PHP 等语言都支持类和对象，所以使用这些语言编写程序也被称为面向对象编程，这些语言也被称为面向对象的编程语言。C语言因为不支持类和对象的概念，被称为面向过程的编程语言。
- 在C语言中，我们会把重复使用或具有某项功能的代码封装成一个函数，将拥有相关功能的多个函数放在一个源文件，再提供一个对应的头文件，这就是一个模块。使用模块时，引入对应的头文件就可以。
- 而在 C++ 中，多了一层封装，就是类（Class）。类由一组相关联的函数、变量组成，你可以将一个类或多个类放在一个源文件，使用时引入对应的类就可以。下面是C和C++项目组织方式的对比：
- 面向对象编程在代码执行效率上绝对没有任何优势，它的主要目的是方便程序员组织和管理代码，快速梳理编程思路，带来编程思想上的革新。
- 面向对象编程是针对开发中大规模的程序而提出来的，目的是提高软件开发的效率。不要把面向对象和面向过程对立起来，面向对象和面向过程不是矛盾的，而是各有用途、互为补充的。如果你希望开发一个贪吃蛇游戏，类和对象或许是多余的，几个函数就可以搞定；但如果开发一款大型游戏，那你绝对离不开面向对象。
C++命名空间
一个中大型软件往往由多名程序员共同开发，会使用大量的变量和函数，不可避免地会出现变量或函数的命名冲突。当所有人的代码都测试通过，没有问题时，将它们结合到一起就有可能会出现命名冲突。为了解决合作开发时的命名冲突问题，C++ 引入了命名空间（Namespace）的概念。
命名空间有时也被称为名字空间、名称空间。
namespace 是C++中的关键字，用来定义一个命名空间，语法格式为：
namespace name{ //variables, functions, classes }
name是命名空间的名字，它里面可以包含变量、函数、类、typedef、#define 等，最后由{ }包围。
使用变量、函数时要指明它们所在的命名空间。
Li::fp = fopen("one.txt", "r"); //使用小李定义的变量 fp Han::fp = fopen("two.txt", "rb+"); //使用小韩定义的变量 fp
::是一个新符号，称为域解析操作符，在C++中用来指明要使用的命名空间。
除了直接使用域解析操作符，还可以采用 using 关键字声明，例如：
using Li::fp; fp = fopen("one.txt", "r"); //使用小李定义的变量 fp Han :: fp = fopen("two.txt", "rb+"); //使用小韩定义的变量 fp在代码的开头用
using声明了 Li::fp，它的意思是，using 声明以后的程序中如果出现了未指明命名空间的 fp，就使用 Li::fp；但是若要使用小韩定义的 fp，仍然需要 Han::fp。
using 声明不仅可以针对命名空间中的一个变量，也可以用于声明整个命名空间，例如：using namespace Li; fp = fopen("one.txt", "r"); //使用小李定义的变量 fp Han::fp = fopen("two.txt", "rb+"); //使用小韩定义的变量 fp
- 命名空间内部不仅可以声明或定义变量，对于其它能在命名空间以外声明或定义的名称，同样也都能在命名空间内部进行声明或定义，例如类、函数、typedef、#define 等都可以出现在命名空间中。
- 站在编译和链接的角度，代码中出现的变量名、函数名、类名等都是一种符号（Symbol）。有的符号可以指代一个内存位置，例如变量名、函数名；有的符号仅仅是一个新的名称，例如 typedef 定义的类型别名。
下面来看一个命名空间完整示例代码：
#include <stdio.h> //将类定义在命名空间中 namespace Diy{ class Student{ public: char *name; int age; float score; public: void say(){ printf("%s的年龄是 %d，成绩是 %f\n", name, age, score); } }; } int main(){ Diy::Student stu1; stu1.name = "小明"; stu1.age = 15; stu1.score = 92.5f; stu1.say(); return 0; }
C++头文件和std命名空间
- C++ 开发人员保留了原来的库和头文件，让它们在 C++ 中可以继续使用，然后再把原来的库复制一份，在此基础上稍加修改，把类、函数、宏等纳入命名空间 std 下，就成了新版 C++ 标准库。这样共存在了两份功能相似的库，使用了老式 C++ 的程序可以继续使用原来的库，新开发的程序可以使用新版的 C++ 库。
- 为了避免头文件重名，新版 C++ 库也对头文件的命名做了调整，去掉了后缀
.h，所以老式 C++ 的iostream.h变成了iostream，fstream.h变成了fstream。而对于原来C语言的头文件，也采用同样的方法，但在每个名字前还要添加一个c字母，所以C语言的stdio.h变成了cstdio，stdlib.h变成了cstdlib。下面是总结的 C++ 头文件的现状：
- 1) 旧的 C++ 头文件，如 iostream.h、fstream.h 等将会继续被支持，尽管它们不在官方标准中。这些头文件的内容不在命名空间 std 中。
- 2) 新的 C++ 头文件，如 iostream、fstream 等包含的基本功能和对应的旧版头文件相似，但头文件的内容在命名空间 std 中。
- 注意：在标准化的过程中，库中有些部分的细节被修改了，所以旧的头文件和新的头文件不一定完全对应。
- 3) 标准C头文件如 stdio.h、stdlib.h 等继续被支持。头文件的内容不在 std 中。
- 4) 具有C库功能的新C++头文件具有如 cstdio、cstdlib 这样的名字。它们提供的内容和相应的旧的C头文件相同，只是内容在 std 中。
- 可以发现，对于不带
.h的头文件，所有的符号都位于命名空间 std 中，使用时需要声明命名空间 std；对于带.h的头文件，没有使用任何命名空间，所有符号都位于全局作用域。这也是 C++ 标准所规定的。
C++输入输出
C++ 中的输入与输出可以看做是一连串的数据流，输入即可视为从文件或键盘中输入程序中的一串数据流，而输出则可以视为从程序中输出一连串的数据流到显示屏或文件中。
在编写 C++ 程序时，如果需要使用输入输出时，则需要包含头文件iostream，它包含了用于输入输出的对象，例如常见的cin表示标准输入、cout表示标准输出、cerr表示标准错误。
iostream 是 Input Output Stream 的缩写，意思是“输入输出流”。
cout 和 cin 都是 C++ 的内置对象，而不是关键字。C++ 库定义了大量的类（Class），程序员可以使用它们来创建对象，cout 和 cin 就分别是 ostream 和 istream 类的对象，只不过它们是由标准库的开发者提前创建好的，可以直接拿来使用。这种在 C++ 中提前创建好的对象称为内置对象。
使用 cout 进行输出时需要紧跟<<运算符，使用 cin 进行输入时需要紧跟>>运算符，这两个运算符可以自行分析所处理的数据类型，因此无需像使用 scanf 和 printf 那样给出格式控制字符串。C++变量的定义位置
C++布尔类型（bool）
- 在C语言中，关系运算和逻辑运算的结果有两种，真和假：0 表示假，非 0 表示真。
- C语言并没有彻底从语法上支持“真”和“假”，只是用 0 和非 0 来代表。这点在 C++ 中得到了改善，C++ 新增了 bool 类型（布尔类型），它一般占用 1 个字节长度。bool 类型只有两个取值，true 和 false：true 表示“真”，false 表示“假”。
- bool 是类型名字，也是 C++ 中的关键字，它的用法和 int、char、long 是一样的，
- 遗憾的是，在 C++ 中使用 cout 输出 bool 变量的值时还是用数字 1 和 0 表示，而不是 true 或 false。Java、PHP、JavaScript 等也都支持布尔类型，但输出结果为 true 或 false，我武断地认为这样更科学。
- 注意，true 和 false 是 C++ 中的关键字，true 表示“真”，false 表示“假”。
#include <iostream>
using namespace std;
int main()
{
bool a=-11;
int b=1;
if(a==b)
cout<<"="<<endl;//=
if(a==true)
cout<<"="<<endl;//=
if(a==-11)
cout<<"="<<endl;//=
cout<<a<<endl;//1
return 0;
}c++的bool类型占一个字节
true表示的是非0的数，数值上是1
false表示的是0，数值上也是0
一个数被声明为bool类型那它只能有0和1两个数值
C++ new
- new其实就是告诉计算机开辟一段新的空间，但是和一般的声明不同的是，new开辟的空间在堆上，而一般声明的变量存放在栈上。（栈上的是临时变量，程序结束就没了，但是堆区不是，需要手动释放）
- 通常来说，当在局部函数中new出一段新的空间，该段空间在局部函数调用结束后仍然能够使用，可以用来向主函数传递参数。
- 另外需要注意的是，new的使用格式，new出来的是一段空间的首地址。所以一般需要用指针来存放这段地址
- new和delete必须成对出现
new和delete必须成对出现
看个例子
void temp() { int * a = new int; *a=5; printf("%d",a); }你要求系统分bai配了一块4个字节大小的du内存给你用zhi，指针a指向这块内存起点，然后你可能用a来做些事情，加减乘除啊什么的，当你用完它，并且以后再也用不到的时候，你必须delete掉它，因为函数离开后，你找不到a指针了，你永远也没法用这块内存了，这4个字节的内存被永远占着，系统一直觉得你还要用到这块内存，我们把这个叫做内存泄漏，这样泄漏的地方多了，你的程序占用的内存会越来越大，最后占满电脑内存，导致程序崩溃
malloc和free必须成对出现
malloc和free必须成对出现，因为malloc开辟的内存空间在堆区，系统在程序结束时不会自动释放，如果程序员自己不手动释放的话就会造成内存泄露（就是有个指针指向一块内存，结果函数一结束，指针被删除了，而那块内存空间还在），那块内存空间就再也找不到了。同样的道理，new开辟的空间也在堆区，你也必须用delete去释放。
new和malloc区别
- malloc和free是函数，new和delete是运算符，不是函数，因此执行效率高。
- new 返回的是一个地址。
- 用new分配数组空间时不能指定初值。
- malloc会分配内存不会调用构造函数，new既分配内存又调用构造函数
- free会释放内存不会调用析构函数，delete既释放内存又调用析构函数
- new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void* ，需要通过强制类型转换将void* 指针转换成我们需要的类型。
C++ inline内联函数
- 函数是一个可以重复使用的代码块，CPU 会一条一条地挨着执行其中的代码。CPU 在执行主调函数代码时如果遇到了被调函数，主调函数就会暂停，CPU 转而执行被调函数的代码；被调函数执行完毕后再返回到主调函数，主调函数根据刚才的状态继续往下执行。
- 一个 C/C++ 程序的执行过程可以认为是多个函数之间的相互调用过程，它们形成了一个或简单或复杂的调用链条，这个链条的起点是 main()，终点也是 main()。当 main() 调用完了所有的函数，它会返回一个值（例如
return 0;）来结束自己的生命，从而结束整个程序。- 函数调用是有时间和空间开销的。程序在执行一个函数之前需要做一些准备工作，要将实参、局部变量、返回地址以及若干寄存器都压入栈中，然后才能执行函数体中的代码；函数体中的代码执行完毕后还要清理现场，将之前压入栈中的数据都出栈，才能接着执行函数调用位置以后的代码。
- 如果函数体代码比较多，需要较长的执行时间，那么函数调用机制占用的时间可以忽略；如果函数只有一两条语句，那么大部分的时间都会花费在函数调用机制上，这种时间开销就就不容忽视。
注意，要在函数定义处添加 inline 关键字，在函数声明处添加 inline 关键字虽然没有错，但这种做法是无效的，编译器会忽略函数声明处的 inline 关键字。- 为了消除函数调用的时空开销，C++ 提供一种提高效率的方法，即在编译时将函数调用处用函数体替换，类似于C语言中的宏展开。这种在函数调用处直接嵌入函数体的函数称为内联函数（Inline Function），又称内嵌函数或者内置函数
- 当函数比较复杂时，函数调用的时空开销可以忽略，大部分的 CPU 时间都会花费在执行函数体代码上，所以我们一般是将非常短小的函数声明为内联函数。
- 由于内联函数比较短小，我们通常的做法是省略函数原型，将整个函数定义（包括函数头和函数体）放在本应该提供函数原型的地方。
下面的例子是一个反面教材，这样的写法是不被推荐的：
#include <iostream>
using namespace std;
//声明内联函数
void swap1(int *a, int *b); //也可以添加inline，但编译器会忽略
int main(){
int m, n;
cin>>m>>n;
cout<<m<<", "<<n<<endl;
swap1(&m, &n);
cout<<m<<", "<<n<<endl;
return 0;
}
//定义内联函数
inline void swap1(int *a, int *b){
int temp;
temp = *a;
*a = *b;
*b = temp;
}
- 使用内联函数的缺点也是非常明显的，编译后的程序会存在多份相同的函数拷贝，如果被声明为内联函数的函数体非常大，那么编译后的程序体积也将会变得很大，所以再次强调，一般只将那些短小的、频繁调用的函数声明为内联函数。
- 最后需要说明的是，对函数作 inline 声明只是程序员对编译器提出的一个建议，而不是强制性的，并非一经指定为 inline 编译器就必须这样做。编译器有自己的判断能力，它会根据具体情况决定是否这样做。
C++函数的默认参数
- 在C++中，定义函数时可以给形参指定一个默认的值，这样调用函数时如果没有给这个形参赋值（没有对应的实参），那么就使用这个默认的值。也就是说，调用函数时可以省略有默认值的参数。如果用户指定了参数的值，那么就使用用户指定的值，否则使用参数的默认值。
- 所谓默认参数，指的是当函数调用中省略了实参时自动使用的一个值，这个值就是给形参指定的默认值。
- C++规定，默认参数只能放在形参列表的最后，而且一旦为某个形参指定了默认值，那么它后面的所有形参都必须有默认值。实参和形参的传值是从左到右依次匹配的，默认参数的连续性是保证正确传参的前提。
C++函数重载
- 在实际开发中，有时候我们需要实现几个功能类似的函数，只是有些细节不同。例如希望交换两个变量的值，这两个变量有多种类型，可以是 int、float、char、bool 等，我们需要通过参数把变量的地址传入函数内部。在C语言中，程序员往往需要分别设计出三个不同名的函数。
- 但在C++中，这完全没有必要。C++ 允许多个函数拥有相同的名字，只要它们的参数列表不同就可以，这就是函数的重载（Function Overloading）。借助重载，一个函数名可以有多种用途。
- 参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同。
- 重载就是在一个作用范围内（同一个类、同一个命名空间等）有多个名称相同但参数不同的函数。重载的结果是让一个函数名拥有了多种用途，使得命名更加方便（在中大型项目中，给变量、函数、类起名字是一件让人苦恼的问题），调用更加灵活。
函数的重载的规则：- 在使用重载函数时，同名函数的功能应当相同或相近，不要用同一函数名去实现完全不相干的功能，虽然程序也能运行，但可读性不好，使人觉得莫名其妙。
- 注意，参数列表不同包括参数的个数不同、类型不同或顺序不同，仅仅参数名称不同是不可以的。函数返回值也不能作为重载的依据。
- 函数名称必须相同。
- 参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。
- 函数的返回类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为函数的重载。
C++ 是如何做到函数重载的
- C++代码在编译时会根据参数列表对函数进行重命名，例如
void Swap(int a, int b)会被重命名为_Swap_int_int，void Swap(float x, float y)会被重命名为_Swap_float_float。当发生函数调用时，编译器会根据传入的实参去逐个匹配，以选择对应的函数，如果匹配失败，编译器就会报错，这叫做重载决议（Overload Resolution）。- 不同的编译器有不同的重命名方式，这里仅仅举例说明，实际情况可能并非如此。
- 从这个角度讲，函数重载仅仅是语法层面的，本质上它们还是不同的函数，占用不同的内存，入口地址也不一样。
C++类的定义和对象的创建
- 类和对象是 C++ 的重要特性，它们使得 C++ 成为面向对象的编程语言，可以用来开发中大型项目。
- 类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数。
- 有些教程将类的成员变量称为类的属性（Property），将类的成员函数称为类的方法（Method）。在面向对象的编程语言中，经常把函数（Function）称为方法（Method）。
- 与结构体一样，类只是一种复杂数据类型的声明，不占用内存空间。而对象是类这种数据类型的一个变量，或者说是通过类这种数据类型创建出来的一份实实在在的数据，所以占用内存空间。
class是 C++ 中新增的关键字，专门用来定义类。类名的首字母一般大写，以和其他的标识符区分开。{ }内部是类所包含的成员变量和成员函数，它们统称为类的成员（Member）；由{ }包围起来的部分有时也称为类体，和函数体的概念类似。public也是 C++ 的新增关键字，它只能用在类的定义中，表示类的成员变量或成员函数具有“公开”的访问权限。- 注意在类定义的最后有一个分号
;，它是类定义的一部分，表示类定义结束了，不能省略。- 类可以理解为一种新的数据类型，与 char、int、float 等基本数据类型不同的是，类是一种复杂数据类型，可以包含基本类型，而且还有很多基本类型中没有的特性。
使用对象指针创建对象
- 下面代码中创建的对象 stu 在栈上分配内存，需要使用
&获取它的地址：Student stu; Student *pStu = &stu;pStu 是一个指针，它指向 Student 类型的数据，也就是通过 Student 创建出来的对象。
- 当然，你也可以在堆上创建对象，这个时候就需要使用前面讲到的
new关键字，例如：Student *pStu = new Student;
- 在栈上创建出来的对象都有一个名字，比如 stu，使用指针指向它不是必须的。
- 但是通过 new 创建出来的对象就不一样了，它在堆上分配内存，没有名字，只能得到一个指向它的指针，所以必须使用一个指针变量来接收这个指针，否则以后再也无法找到这个对象了，更没有办法使用它。
- 也就是说，使用 new 在堆上创建出来的对象是匿名的，没法直接使用，必须要用一个指针指向它，再借助指针来访问它的成员变量或成员函数。
- 栈内存是程序自动管理的，不能使用 delete 删除在栈上创建的对象；堆内存由程序员管理，对象使用完毕后可以通过 delete 删除。在实际开发中，new 和 delete 往往成对出现，以保证及时删除不再使用的对象，防止无用内存堆积。
- 有了对象指针后，可以通过箭头
->来访问对象的成员变量和成员函数，这和通过结构体指针来访问它的成员类似，请看下面的示例：pStu -> name = "小明"; pStu -> age = 15; pStu -> score = 92.5f; pStu -> say();
- 两种创建对象的方式：一种是在栈上创建，形式和定义普通变量类似；另外一种是在堆上使用 new 关键字创建，必须要用一个指针指向它，要记得 delete 掉不再使用的对象。
C++类的成员变量和成员函数
在类体中和类体外定义成员函数的区别
- 在类体中定义的成员函数会自动成为内联函数，在类体外定义的不会。当然，在类体内部定义的函数也可以加 inline 关键字，但这是多余的，因为类体内部定义的函数默认就是内联函数。
- 内联函数一般不是我们所期望的，它会将函数调用处用函数体替代，所以我建议在类体内部对成员函数作声明，而在类体外部进行定义，这是一种良好的编程习惯，实际开发中大家也是这样做的。
- 当然，如果你的函数比较短小，希望定义为内联函数，那也没有什么不妥的。
- 如果你既希望将函数定义在类体外部，又希望它是内联函数，那么可以在定义函数时加 inline 关键字。
C++类成员的访问权限以及类的封装
- C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表示公有的、受保护的、私有的，被称为成员访问限定符。所谓访问权限，就是你能不能使用该类中的成员
- 在类的内部（定义类的代码内部），无论成员被声明为 public、protected 还是 private，都是可以互相访问的，没有访问权限的限制。
- 在类的外部（定义类的代码之外），只能通过对象访问成员，并且通过对象只能访问 public 属性的成员，不能访问 private、protected 属性的成员。
- 成员变量大都以
m_开头，这是约定成俗的写法，不是语法规定的内容。以m_开头既可以一眼看出这是成员变量，又可以和成员函数中的形参名字区分开。
简单地谈类的封装
- private 关键字的作用在于更好地隐藏类的内部实现，该向外暴露的接口（能通过对象访问的成员）都声明为 public，不希望外部知道、或者只在类内部使用的、或者对外部没有影响的成员，都建议声明为 private。
- 根据C++软件设计规范，实际项目开发中的成员变量以及只在类内部使用的成员函数（只被成员函数调用的成员函数）都建议声明为 private，而只将允许通过对象调用的成员函数声明为 public。
- 另外还有一个关键字 protected，声明为 protected 的成员在类外也不能通过对象访问，但是在它的派生类内部可以访问，这点我们将在后续章节中介绍，现在你只需要知道 protected 属性的成员在类外无法访问即可。
有读者可能会提出疑问，将成员变量都声明为 private，如何给它们赋值呢，又如何读取它们的值呢？
- 我们可以额外添加两个 public 属性的成员函数，一个用来设置成员变量的值，一个用来获取成员变量的值。上面的代码中，setname()、setage()、setscore() 函数就用来设置成员变量的值；如果希望获取成员变量的值，可以再添加三个函数 getname()、getage()、getscore()。
- 给成员变量赋值的函数通常称为 set 函数，它们的名字通常以
set开头，后跟成员变量的名字；读取成员变量的值的函数通常称为 get 函数，它们的名字通常以get开头，后跟成员变量的名字。- 除了 set 函数和 get 函数，在创建对象时还可以调用构造函数来初始化各个成员变量。不过构造函数只能给成员变量赋值一次，以后再修改还得借助 set 函数。
- 这种将成员变量声明为 private、将部分成员函数声明为 public 的做法体现了类的封装性。所谓封装，是指尽量隐藏类的内部实现，只向用户提供有用的成员函数。
对private和public的更多说明
- 声明为 private 的成员和声明为 public 的成员的次序任意，既可以先出现 private 部分，也可以先出现 public 部分。如果既不写 private 也不写 public，就默认为 private。
- 在一个类体中，private 和 public 可以分别出现多次。每个部分的有效范围到出现另一个访问限定符或类体结束时（最后一个右花括号）为止。但是为了使程序清晰，应该养成这样的习惯，使每一种成员访问限定符在类定义体中只出现一次。
C++构造函数
- 在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）。
- 在栈上创建对象时，实参位于对象名后面，例如
Student stu("小明", 15, 92.5f)；在堆上创建对象时，实参位于类名后面，例如new Student("李华", 16, 96)。- 构造函数必须是 public 属性的，否则创建对象时无法调用。当然，设置为 private、protected 属性也不会报错，但是没有意义。
- 构造函数没有返回值，因为没有变量来接收返回值，即使有也毫无用处。
- 这意味着：不管是声明还是定义，函数名前面都不能出现返回值类型，即使是 void 也不允许；
- 函数体中不能有 return 语句。
构造函数的重载
- 和普通成员函数一样，构造函数是允许重载的。一个类可以有多个重载的构造函数，创建对象时根据传递的实参来判断调用哪一个构造函数。
- 构造函数的调用是强制性的，一旦在类中定义了构造函数，那么创建对象时就一定要调用，不调用是错误的。如果有多个重载的构造函数，那么创建对象时提供的实参必须和其中的一个构造函数匹配；
- 反过来说，创建对象时只有一个构造函数会被调用。
- 对示例中的代码，如果写作
Student stu或者new Student就是错误的，因为类中包含了构造函数，而创建对象时却没有调用。- 构造函数在实际开发中会大量使用，它往往用来做一些初始化工作，例如对成员变量赋值、预先打开文件等。
默认构造函数
- 如果用户自己没有定义构造函数，那么编译器会自动生成一个默认的构造函数，只是这个构造函数的函数体是空的，也没有形参，也不执行任何操作。比如上面的 Student 类，默认生成的构造函数如下：
Student(){}
- 一个类必须有构造函数，要么用户自己定义，要么编译器自动生成。一旦用户自己定义了构造函数，不管有几个，也不管形参如何，编译器都不再自动生成。在示例1中，Student 类已经有了一个构造函数
Student(char *, int, float)，也就是我们自己定义的，编译器不会再额外添加构造函数Student()，在示例2中我们才手动添加了该构造函数。- 实际上编译器只有在必要的时候才会生成默认构造函数，而且它的函数体一般不为空。默认构造函数的目的是帮助编译器做初始化工作，而不是帮助程序员。这是C++的内部实现机制，这里不再深究，初学者可以按照上面说的“一定有一个空函数体的默认构造函数”来理解。
- 最后需要注意的一点是，调用没有参数的构造函数也可以省略括号。在栈上创建对象可以写作
Student stu()或Student stu，在堆上创建对象可以写作Student *pstu = new Student()或Student *pstu = new Student，它们都会调用构造函数 Student()。- 以前我们就是这样做的，创建对象时都没有写括号，其实是调用了默认的构造函数。
C++构造函数初始化列表
- 构造函数的一项重要功能是对成员变量进行初始化，为了达到这个目的，可以在构造函数的函数体中对成员变量一一赋值，还可以采用初始化列表。
- C++构造函数的初始化列表使得代码更加简洁，请看下面的例子：
#include <iostream> using namespace std; class Student{ private: char *m_name; int m_age; float m_score; public: Student(char *name, int age, float score); void show(); }; //采用初始化列表 Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ //TODO: } void Student::show(){ cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl; } int main(){ Student stu("小明", 15, 92.5f); stu.show(); Student *pstu = new Student("李华", 16, 96); pstu -> show(); return 0; }运行结果：
小明的年龄是15，成绩是92.5
李华的年龄是16，成绩是96
- 如本例所示，定义构造函数时并没有在函数体中对成员变量一一赋值，其函数体为空（当然也可以有其他语句），而是在函数首部与函数体之间添加了一个冒号
:，后面紧跟m_name(name), m_age(age), m_score(score)语句，这个语句的意思相当于函数体内部的m_name = name; m_age = age; m_score = score;语句，也是赋值的意思。- 使用构造函数初始化列表并没有效率上的优势，仅仅是书写方便，尤其是成员变量较多时，这种写法非常简单明了。
- 初始化列表可以用于全部成员变量，也可以只用于部分成员变量。下面的示例只对 m_name 使用初始化列表，其他成员变量还是一一赋值：
Student::Student(char *name, int age, float score): m_name(name){ m_age = age; m_score = score; }注意，成员变量的初始化顺序与初始化列表中列出的变量的顺序无关，它只与成员变量在类中声明的顺序有关。请看代码：
#include <iostream> using namespace std; class Demo{ private: int m_a; int m_b; public: Demo(int b); void show(); }; Demo::Demo(int b): m_b(b), m_a(m_b){ } void Demo::show(){ cout<<m_a<<", "<<m_b<<endl; } int main(){ Demo obj(100); obj.show(); return 0; }
- 运行结果：
2130567168, 100
- 在初始化列表中，我们将 m_b 放在了 m_a 的前面，看起来是先给 m_b 赋值，再给 m_a 赋值，其实不然！成员变量的赋值顺序由它们在类中的声明顺序决定，在 Demo 类中，我们先声明的 m_a，再声明的 m_b，所以构造函数和下面的代码等价：
Demo::Demo(int b): m_b(b), m_a(m_b){ m_a = m_b; m_b = b; }
- 给 m_a 赋值时，m_b 还未被初始化，它的值是不确定的，所以输出的 m_a 的值是一个奇怪的数字；给 m_a 赋值完成后才给 m_b 赋值，此时 m_b 的值才是 100。
- obj 在栈上分配内存，成员变量的初始值是不确定的。
初始化 const 成员变量
- 构造函数初始化列表还有一个很重要的作用，那就是初始化 const 成员变量。初始化 const 成员变量的唯一方法就是使用初始化列表。例如 VS/VC 不支持变长数组（数组长度不能是变量），我们自己定义了一个 VLA 类，用于模拟变长数组，请看下面的代码：
class VLA{ private: const int m_len; int *m_arr; public: VLA(int len); }; //必须使用初始化列表来初始化 m_len VLA::VLA(int len): m_len(len){ m_arr = new int[len]; }
- VLA 类包含了两个成员变量，m_len 和 m_arr 指针，需要注意的是 m_len 加了 const 修饰，只能使用初始化列表的方式赋值，如果写作下面的形式是错误的：
class VLA{ private: const int m_len; int *m_arr; public: VLA(int len); }; VLA::VLA(int len){ m_len = len; m_arr = new int[len]; }
C++析构函数
创建对象时系统会自动调用构造函数进行初始化工作，同样，销毁对象时系统也会自动调用一个函数来进行清理工作，例如释放分配的内存、关闭打开的文件等，这个函数就是析构函数。
析构函数（Destructor）也是一种特殊的成员函数，没有返回值，不需要程序员显式调用（程序员也没法显式调用），而是在销毁对象时自动执行。构造函数的名字和类名相同，而析构函数的名字是在类名前面加一个
~符号。注意：析构函数没有参数，不能被重载，因此一个类只能有一个析构函数。如果用户没有定义，编译器会自动生成一个默认的析构函数。
函数名是标识符的一种，原则上标识符的命名中不允许出现
~符号，在析构函数的名字中出现的~可以认为是一种特殊情况，目的是为了和构造函数的名字加以对比和区分。
初始化列表来进行赋值。C++ 中的 new 和 delete 分别用来分配和释放内存，它们与C语言中 malloc()、free() 最大的一个不同之处在于：用 new 分配内存时会调用构造函数，用 delete 释放内存时会调用析构函数。构造函数和析构函数对于类来说是不可或缺的，所以在C++中我们非常鼓励使用 new 和 delete。
析构函数的执行时机
析构函数在对象被销毁时调用，而对象的销毁时机与它所在的内存区域有关。
在所有函数之外创建的对象是全局对象，它和全局变量类似，位于内存分区中的全局数据区，程序在结束执行时会调用这些对象的析构函数。
在函数内部创建的对象是局部对象，它和局部变量类似，位于栈区，函数执行结束时会调用这些对象的析构函数。
new 创建的对象位于堆区，通过 delete 删除时才会调用析构函数；如果没有 delete，析构函数就不会被执行。
C++ this指针
所谓当前对象，是指正在使用的对象。
this 只能用在类的内部，通过 this 可以访问类的所有成员，包括 private、protected、public 属性的。
注意，this 是一个指针，要用
->来访问成员变量或成员函数。this 虽然用在类的内部，但是只有在对象被创建以后才会给 this 赋值，并且这个赋值的过程是编译器自动完成的，不需要用户干预，用户也不能显式地给 this 赋值。
几点注意：
this 是 const 指针，它的值是不能被修改的，一切企图修改该指针的操作，如赋值、递增、递减等都是不允许的。
this 只能在成员函数内部使用，用在其他地方没有意义，也是非法的。
只有当对象被创建后 this 才有意义，因此不能在 static 成员函数中使用。
this 到底是什么
this 实际上是成员函数的一个形参，在调用成员函数时将对象的地址作为实参传递给 this。不过 this 这个形参是隐式的，它并不出现在代码中，而是在编译阶段由编译器默默地将它添加到参数列表中。
this 作为隐式形参，本质上是成员函数的局部变量，所以只能用在成员函数的内部，并且只有在通过对象调用成员函数时才给 this 赋值。
成员函数最终被编译成与对象无关的普通函数，除了成员变量，会丢失所有信息，所以编译时要在成员函数中添加一个额外的参数，把当前对象的首地址传入，以此来关联成员函数和成员变量。这个额外的参数，实际上就是 this，它是成员函数和成员变量关联的桥梁。
C++ static静态成员变量
对象的内存中包含了成员变量，不同的对象占用不同的内存，这使得不同对象的成员变量相互独立，它们的值不受其他对象的影响。例如有两个相同类型的对象 a、b，它们都有一个成员变量 m_name，那么修改 a.m_name 的值不会影响 b.m_name 的值。
可是有时候我们希望在多个对象之间共享数据，对象 a 改变了某份数据后对象 b 可以检测到。共享数据的典型使用场景是计数，以前面的 Student 类为例，如果我们想知道班级中共有多少名学生，就可以设置一份共享的变量，每次创建对象时让该变量加 1。
在C++中，我们可以使用静态成员变量来实现多个对象共享数据的目标。静态成员变量是一种特殊的成员变量，它被关键字
static修饰，static 成员变量属于类，不属于某个具体的对象，即使创建多个对象，也只为 m_total 分配一份内存，所有对象使用的都是这份内存中的数据。当某个对象修改了 m_total，也会影响到其他对象。
static 成员变量必须在类声明的外部初始化，具体形式为：
type class::name = value;
type 是变量的类型，class 是类名，name 是变量名，value 是初始值。将上面的 m_total 初始化：
int Student::m_total = 0;
静态成员变量在初始化时不能再加 static，但必须要有数据类型。被 private、protected、public 修饰的静态成员变量都可以用这种方式初始化。
注意：static 成员变量的内存既不是在声明类时分配，也不是在创建对象时分配，而是在（类外）初始化时分配。反过来说，没有在类外初始化的 static 成员变量不能使用。
static 成员变量既可以通过对象来访问，也可以通过类来访问。请看下面的例子：
//通过类类访问 static 成员变量 Student::m_total = 10; //通过对象来访问 static 成员变量 Student stu("小明", 15, 92.5f); stu.m_total = 20; //通过对象指针来访问 static 成员变量 Student *pstu = new Student("李华", 16, 96); pstu -> m_total = 20;这三种方式是等效的。
注意：static 成员变量不占用对象的内存，而是在所有对象之外开辟内存，即使不创建对象也可以访问。具体来说，static 成员变量和普通的 static 变量类似，都在内存分区中的全局数据区分配内存。
几点说明 ：
- 1) 一个类中可以有一个或多个静态成员变量，所有的对象都共享这些静态成员变量，都可以引用它。
- 2) static 成员变量和普通 static 变量一样，都在内存分区中的全局数据区分配内存，到程序结束时才释放。这就意味着，static 成员变量不随对象的创建而分配内存，也不随对象的销毁而释放内存。而普通成员变量在对象创建时分配内存，在对象销毁时释放内存。
- 3) 静态成员变量必须初始化，而且只能在类体外进行。例如：
int Student::m_total = 10;
- 初始化时可以赋初值，也可以不赋值。如果不赋值，那么会被默认初始化为 0。全局数据区的变量都有默认的初始值 0，而动态数据区（堆区、栈区）变量的默认值是不确定的，一般认为是垃圾值。
- 4) 静态成员变量既可以通过对象名访问，也可以通过类名访问，但要遵循 private、protected 和 public 关键字的访问权限限制。当通过对象名访问时，对于不同的对象，访问的是同一份内存。
C++ static静态成员函数
- 在类中，static 除了可以声明静态成员变量，还可以声明静态成员函数。普通成员函数可以访问所有成员（包括成员变量和成员函数），静态成员函数只能访问静态成员。
- 编译器在编译一个普通成员函数时，会隐式地增加一个形参 this，并把当前对象的地址赋值给 this，所以普通成员函数只能在创建对象后通过对象来调用，因为它需要当前对象的地址。
- 而静态成员函数可以通过类来直接调用，编译器不会为它增加形参 this，它不需要当前对象的地址，所以不管有没有创建对象，都可以调用静态成员函数。
- 普通成员变量占用对象的内存，静态成员函数没有 this 指针，不知道指向哪个对象，无法访问对象的成员变量，也就是说静态成员函数不能访问普通成员变量，只能访问静态成员变量。
- 普通成员函数必须通过对象才能调用，而静态成员函数没有 this 指针，无法在函数体内部访问某个对象，所以不能调用普通成员函数，只能调用静态成员函数。
静态成员函数与普通成员函数的根本区别在于：
- 普通成员函数有 this 指针，可以访问类中的任意成员；
- 而静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。
- 普通成员变量占用对象的内存，静态成员函数没有 this
示例：
#include <iostream> using namespace std; class Student{ public: Student(char *name, int age, float score); void show(); public: //声明静态成员函数 static int getTotal(); static float getPoints(); private: static int m_total; //总人数 static float m_points; //总成绩 private: char *m_name; int m_age; float m_score; }; int Student::m_total = 0; float Student::m_points = 0.0; Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ m_total++; m_points += score; } void Student::show(){ cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl; } //定义静态成员函数 int Student::getTotal(){ return m_total; } float Student::getPoints(){ return m_points; } int main(){ (new Student("小明", 15, 90.6)) -> show(); (new Student("李磊", 16, 80.5)) -> show(); (new Student("张华", 16, 99.0)) -> show(); (new Student("王康", 14, 60.8)) -> show(); int total = Student::getTotal(); float points = Student::getPoints(); cout<<"当前共有"<<total<<"名学生，总成绩是"<<points<<"，平均分是"<<points/total<<endl; return 0; }
- 运行结果：
小明的年龄是15，成绩是90.6
李磊的年龄是16，成绩是80.5
张华的年龄是16，成绩是99
王康的年龄是14，成绩是60.8
当前共有4名学生，总成绩是330.9，平均分是82.725
- 总人数 m_total 和总成绩 m_points 由各个对象累加得到，必须声明为 static 才能共享；getTotal()、getPoints() 分别用来获取总人数和总成绩，为了访问 static 成员变量，我们将这两个函数也声明为 static。
- 在C++中，静态成员函数的主要目的是访问静态成员。getTotal()、getPoints() 当然也可以声明为普通成员函数，但是它们都只对静态成员进行操作，加上 static 语义更加明确。
- 和静态成员变量类似，静态成员函数在声明时要加 static，在定义时不能加 static。静态成员函数可以通过类来调用（一般都是这样做），也可以通过对象来调用，上例仅仅演示了如何通过类来调用。
C++ const成员变量和成员函数（常成员函数）
- const 成员函数可以使用类中的所有成员变量，但是不能修改它们的值，这种措施主要还是为了保护数据而设置的。const 成员函数也称为常成员函数。
- 我们通常将 get 函数设置为常成员函数。读取成员变量的函数的名字通常以
get开头，后跟成员变量的名字，所以通常将它们称为 get 函数。- 需要强调的是，必须在成员函数的声明和定义处同时加上 const 关键字。
char *getname() const和char *getname()是两个不同的函数原型。- 如果只在一个地方加 const 会导致声明和定义处的函数原型冲突。
最后再来区分一下 const 的位置：
函数开头的 const 用来修饰函数的返回值，表示返回值是 const 类型，也就是不能被修改，例如
const char * getname()。函数头部的结尾加上 const 表示常成员函数，这种函数只能读取成员变量的值，而不能修改成员变量的值，例如
char * getname() const。
C++ const对象（常对象）
在 C++ 中，const 也可以用来修饰对象，称为常对象。一旦将对象定义为常对象之后，就只能调用类的 const 成员（包括 const 成员变量和 const 成员函数）了。
- 定义常对象的语法和定义常量的语法类似：
const class object(params);
class const object(params);
- 当然你也可以定义 const 指针：
const class *p = new class(params);
class const *p = new class(params);
class为类名，object为对象名，params为实参列表，p为指针名。两种方式定义出来的对象都是常对象。一旦将对象定义为常对象之后，不管是哪种形式，该对象就只能访问被 const 修饰的成员了（包括 const 成员变量和 const 成员函数），因为非 const 成员可能会修改对象的数据（编译器也会这样假设），C++禁止这样做。
C++友元函数和友元类（C++ friend关键字）
- 在 C++ 中，一个类中可以有 public、protected、private 三种属性的成员，通过对象可以访问 public 成员，只有本类中的函数可以访问本类的 private 成员。现在，我们来介绍一种例外情况——友元（friend）。
- 借助友元（friend），可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。
- friend 的意思是朋友，或者说是好友，与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉，倾诉自己的秘密，而对一般人会谨言慎行，潜意识里就自我保护。在 C++ 中，这种友好关系可以用 friend 关键字指明，中文多译为“友元”，借助友元可以访问与其有好友关系的类中的私有成员。如果你对“友元”这个名词不习惯，可以按原文 friend 理解为朋友。
友元函数
在当前类以外定义的、不属于当前类的函数也可以在类中声明，但要在前面加 friend 关键字，这样就构成了友元函数。友元函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数。
友元函数可以访问当前类中的所有成员，包括 public、protected、private 属性的。
1) 将非成员函数声明为友元函数。
注意，友元函数不同于类的成员函数，在友元函数中不能直接访问类的成员，必须要借助对象。下面的写法是错误的：
void show(){ cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl; }成员函数在调用时会隐式地增加 this 指针，指向调用它的对象，从而使用该对象的成员；而 show() 是非成员函数，没有 this 指针，编译器不知道使用哪个对象的成员，要想明确这一点，就必须通过参数传递对象（可以直接传递对象，也可以传递对象指针或对象引用），并在访问成 员时指明对象。
2) 将其他类的成员函数声明为友元函数
friend 函数不仅可以是全局函数（非成员函数），还可以是另外一个类的成员函数。请看下面的例子：
#include <iostream> using namespace std; class Address; //提前声明Address类 //声明Student类 class Student{ public: Student(char *name, int age, float score); public: void show(Address *addr); private: char *m_name; int m_age; float m_score; }; //声明Address类 class Address{ private: char *m_province; //省份 char *m_city; //城市 char *m_district; //区（市区） public: Address(char *province, char *city, char *district); //将Student类中的成员函数show()声明为友元函数 friend void Student::show(Address *addr); }; //实现Student类 Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ } void Student::show(Address *addr){ cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl; cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl; } //实现Address类 Address::Address(char *province, char *city, char *district){ m_province = province; m_city = city; m_district = district; } int main(){ Student stu("小明", 16, 95.5f); Address addr("陕西", "西安", "雁塔"); stu.show(&addr); Student *pstu = new Student("李磊", 16, 80.5); Address *paddr = new Address("河北", "衡水", "桃城"); pstu -> show(paddr); return 0; }本例定义了两个类 Student 和 Address，程序第 27 行将 Student 类的成员函数 show() 声明为 Address 类的友元函数，由此，show() 就可以访问 Address 类的 private 成员变量了。
几点注意：
① 程序第 4 行对 Address 类进行了提前声明，是因为在 Address 类定义之前、在 Student 类中使用到了它，如果不提前声明，编译器会报错，提示'Address' has not been declared。类的提前声明和函数的提前声明是一个道理。
② 程序将 Student 类的声明和实现分开了，而将 Address 类的声明放在了中间，这是因为编译器从上到下编译代码，show() 函数体中用到了 Address 的成员 province、city、district，如果提前不知道 Address 的具体声明内容，就不能确定 Address 是否拥有该成员（类的声明中指明了类有哪些成员）。
这里简单介绍一下类的提前声明。一般情况下，类必须在正式声明之后才能使用；但是某些情况下（如上例所示），只要做好提前声明，也可以先使用。
但是应当注意，类的提前声明的使用范围是有限的，只有在正式声明一个类以后才能用它去创建对象。如果在上面程序的第4行之后增加如下所示的一条语句，编译器就会报错：Address addr; //企图使用不完整的类来创建对象
因为创建对象时要为对象分配内存，在正式声明类之前，编译器无法确定应该为对象分配多大的内存。编译器只有在“见到”类的正式声明后（其实是见到成员变量），才能确定应该为对象预留多大的内存。在对一个类作了提前声明后，可以用该类的名字去定义指向该类型对象的指针变 量（本例就定义了 Address 类的指针变量）或引用变量（后续会介绍引用），因为指针变量和引用变量本身的大小是固定的，与它所指向的数据的大小无关。
③ 一个函数可以被多个类声明为友元函数，这样就可以访问多个类中的 private 成员。
友元类
- 不仅可以将一个函数声明为一个类的“朋友”，还可以将整个类声明为另一个类的“朋友”，这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。
- 例如将类 B 声明为类 A 的友元类，那么类 B 中的所有成员函数都是类 A 的友元函数，可以访问类 A 的所有成员，包括 public、protected、private 属性的。
- 第 24 行代码将 Student 类声明为 Address 类的友元类，声明语句为：
friend class Student;
- 有的编译器也可以不写 class 关键字，不过为了增强兼容性还是建议写上。
关于友元，有两点需要说明：
- 友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类，不等于类 A 是类 B 的友元类，类 A 中的成员函数不能访问类 B 中的 private 成员。
- 友元的关系不能传递。如果类 B 是类 A 的友元类，类 C 是类 B 的友元类，不等于类 C 是类 A 的友元类。
除非有必要，一般不建议把整个类声明为友元类，而只将某些成员函数声明为友元函数，这样更安全一些。
C++ class和struct区别
- C++ 中保留了C语言的 struct 关键字，并且加以扩充。在C语言中，struct 只能包含成员变量，不能包含成员函数。而在C++中，struct 类似于 class，既可以包含成员变量，又可以包含成员函数。
- C++中的 struct 和 class 基本是通用的，唯有几个细节不同：
1）使用 class 时，类中的成员默认都是 private 属性的；而使用 struct 时，结构体中的成员默认都是 public 属性的。
class 继承默认是 private 继承，而 struct 继承默认是 public 继承。
class 可以使用模板，而 struct 不能。
- C++ 没有抛弃C语言中的 struct 关键字，其意义就在于给C语言程序开发人员有一个归属感，并且能让C++编译器兼容以前用C语言开发出来的项目。
- 在编写C++代码时，强烈建议使用 class 来定义类，而使用 struct 来定义结构体，这样做语义更加明确。
C++字符串
- C++ 大大增强了对字符串的支持，除了可以使用C风格的字符串，还可以使用内置的 string 类。string 类处理起字符串来会方便很多，完全可以代替C语言中的字符数组或字符串指针。
- string 是 C++ 中常用的一个类，它非常重要，我们有必要在此单独讲解一下。
- 使用 string 类需要包含头文件
<string>。下面的例子介绍了几种定义 string 变量（对象）的方法：
#include <iostream> #include <string> using namespace std; int main(){ string s1; string s2 = "c plus plus"; string s3 = s2; string s4 (5, 's'); return 0; }
- 变量 s1 只是定义但没有初始化，编译器会将默认值赋给 s1，默认值是
""，也即空字符串。- 变量 s2 在定义的同时被初始化为
"c plus plus"。与C风格的字符串不同，string 的结尾没有结束标志'\0'。- 变量 s3 在定义的时候直接用 s2 进行初始化，因此 s3 的内容也是
"c plus plus"。- 变量 s4 被初始化为由 5 个
's'字符组成的字符串，也就是"sssss"。
- 从上面的代码可以看出，string 变量可以直接通过赋值操作符
=进行赋值。string 变量也可以用C风格的字符串进行赋值，例如，s2 是用一个字符串常量进行初始化的，而 s3 则是通过 s2 变量进行初始化的。- 与C风格的字符串不同，当我们需要知道字符串长度时，可以调用 string 类提供的 length() 函数。如下所示：
string s = "http://c.biancheng.net"; int len = s.length(); cout<<len<<endl;
- 输出结果为
22。由于 string 的末尾没有'\0'字符，所以 length() 返回的是字符串的真实长度，而不是长度 +1。
转换为C风格的字符串
虽然 C++ 提供了 string 类来替代C语言中的字符串，但是在实际编程中，有时候必须要使用C风格的字符串（例如打开文件时的路径），为此，string 类为我们提供了一个转换函数 c_str()，该函数能够将 string 字符串转换为C风格的字符串，并返回该字符串的 const 指针（const char*）。请看下面的代码：
string path = "D:\\demo.txt"; FILE *fp = fopen(path.c_str(), "rt");为了使用C语言中的 fopen() 函数打开文件，必须将 string 字符串转换为C风格的字符串。
string 字符串的输入输出
string 类重载了输入输出运算符，可以像对待普通变量那样对待 string 变量，也就是用
>>进行输入，用<<进行输出。请看下面的代码#include <iostream> #include <string> using namespace std; int main(){ string s; cin>>s; //输入字符串 cout<<s<<endl; //输出字符串 return 0; }运行结果：
http://c.biancheng.net http://vip.biancheng.net↙
http://c.biancheng.net
虽然我们输入了两个由空格隔开的网址，但是只输出了一个，这是因为输入运算符>>默认会忽略空格，遇到空格就认为输入结束，所以最后输入的http://vip.biancheng.net没有被存储到变量 s。
访问字符串中的字符
string 字符串也可以像C风格的字符串一样按照下标来访问其中的每一个字符。string 字符串的起始下标仍是从 0 开始。请看下面的代码：
#include <iostream> #include <string> using namespace std; int main(){ string s = "1234567890"; for(int i=0,len=s.length(); i<len; i++){ cout<<s[i]<<" "; } cout<<endl; s[5] = '5'; cout<<s<<endl; return 0; }运行结果：
1 2 3 4 5 6 7 8 9 0
1234557890
本例定义了一个 string 变量 s，并赋值 "1234567890"，之后用 for 循环遍历输出每一个字符。借助下标，除了能够访问每个字符，也可以修改每个字符，s[5] = '5';就将第6个字符修改为 '5'，所以 s 最后为 "1234557890"。
字符串的拼接
- 有了 string 类，我们可以使用
+或+=运算符来直接拼接字符串，非常方便，再也不需要使用C语言中的 strcat()、strcpy()、malloc() 等函数来拼接字符串了，再也不用担心空间不够会溢出了。用
+来拼接字符串时，运算符的两边可以都是 string 字符串，也可以是一个 string 字符串和一个C风格的字符串，还可以是一个 string 字符串和一个字符数组，或者是一个 string 字符串和一个单独的字符。请看下面的例子：
#include <iostream> #include <string> using namespace std; int main(){ string s1 = "first "; string s2 = "second "; char *s3 = "third "; char s4[] = "fourth "; char ch = '@'; string s5 = s1 + s2; string s6 = s1 + s3; string s7 = s1 + s4; string s8 = s1 + ch; cout<<s5<<endl<<s6<<endl<<s7<<endl<<s8<<endl; return 0; }运行结果：
first second
first third
first fourth
first @
string 字符串的增删改查
C++ 提供的 string 类包含了若干实用的成员函数，大大方便了字符串的增加、删除、更改、查询等操作。
一. 插入字符串
- insert() 函数可以在 string 字符串中指定的位置插入另一个字符串，它的一种原型为：
string& insert (size_t pos, const string& str);
- pos 表示要插入的位置，也就是下标；str 表示要插入的字符串，它可以是 string 字符串，也可以是C风格的字符串。
请看下面的代码：#include <iostream> #include <string> using namespace std; int main(){ string s1, s2, s3; s1 = s2 = "1234567890"; s3 = "aaa"; s1.insert(5, s3); cout<< s1 <<endl; s2.insert(5, "bbb"); cout<< s2 <<endl; return 0; }运行结果：
12345aaa67890
12345bbb67890
- insert() 函数的第一个参数有越界的可能，如果越界，则会产生运行时异常。
二. 删除字符串
- erase() 函数可以删除 string 中的一个子字符串。它的一种原型为：
string& erase (size_t pos = 0, size_t len = npos);
- pos 表示要删除的子字符串的起始下标，len 表示要删除子字符串的长度。如果不指明 len 的话，那么直接删除从 pos 到字符串结束处的所有字符（此时 len = str.length - pos）。
请看下面的代码：
#include <iostream> #include <string> using namespace std; int main(){ string s1, s2, s3; s1 = s2 = s3 = "1234567890"; s2.erase(5); s3.erase(5, 3); cout<< s1 <<endl; cout<< s2 <<endl; cout<< s3 <<endl; return 0; }运行结果：
1234567890
12345
1234590
- 有读者担心，在 pos 参数没有越界的情况下， len 参数也可能会导致要删除的子字符串越界。但实际上这种情况不会发生，erase() 函数会从以下两个值中取出最小的一个作为待删除子字符串的长度：
1）len 的值；
2）字符串长度减去 pos 的值。
- 说得简单一些，待删除字符串最多只能删除到字符串结尾。
三. 提取子字符串
- substr() 函数用于从 string 字符串中提取子字符串，它的原型为：
string substr (size_t pos = 0, size_t len = npos) const;
- pos 为要提取的子字符串的起始下标，len 为要提取的子字符串的长度。
请看下面的代码：
#include <iostream> #include <string> using namespace std; int main(){ string s1 = "first second third"; string s2; s2 = s1.substr(6, 6); cout<< s1 <<endl; cout<< s2 <<endl; return 0; }运行结果：
first second third
second
- 系统对 substr() 参数的处理和 erase() 类似：
1）如果 pos 越界，会抛出异常；
2）如果 len 越界，会提取从 pos 到字符串结尾处的所有字符。
四. 字符串查找
string 类提供了几个与字符串查找有关的函数，如下所示。
1) find() 函数
- find() 函数用于在 string 字符串中查找子字符串出现的位置，它其中的两种原型为：
1）size_t find (const string& str, size_t pos = 0) const;
2）size_t find (const char* s, size_t pos = 0) const;
- 第一个参数为待查找的子字符串，它可以是 string 字符串，也可以是C风格的字符串。第二个参数为开始查找的位置（下标）；如果不指明，则从第0个字符开始查找。
请看下面的代码：
#include <iostream> #include <string> using namespace std; int main(){ string s1 = "first second third"; string s2 = "second"; int index = s1.find(s2,5); if(index < s1.length()) cout<<"Found at index : "<< index <<endl; else cout<<"Not found"<<endl; return 0; }运行结果：
Found at index : 6
- find() 函数最终返回的是子字符串第一次出现在字符串中的起始下标。本例最终是在下标6处找到了 s2 字符串。如果没有查找到子字符串，那么会返回一个无穷大值 4294967295。
2) rfind() 函数
- rfind() 和 find() 很类似，同样是在字符串中查找子字符串，不同的是 find() 函数从第二个参数开始往后查找，而 rfind() 函数则最多查找到第二个参数处，如果到了第二个参数所指定的下标还没有找到子字符串，则返回一个无穷大值4294967295。
请看下面的例子：
#include <iostream> #include <string> using namespace std; int main(){ string s1 = "first second third"; string s2 = "second"; int index = s1.rfind(s2,6); if(index < s1.length()) cout<<"Found at index : "<< index <<endl; else cout<<"Not found"<<endl; return 0; }运行结果：
Found at index : 63) find_first_of() 函数
- find_first_of() 函数用于查找子字符串和字符串共同具有的字符在字符串中首次出现的位置。请看下面的代码：
#include <iostream> #include <string> using namespace std; int main(){ string s1 = "first second second third"; string s2 = "asecond"; int index = s1.find_first_of(s2); if(index < s1.length()) cout<<"Found at index : "<< index <<endl; else cout<<"Not found"<<endl; return 0; }运行结果：
Found at index : 3
- 本例中 s1 和 s2 共同具有的字符是 ’s’，该字符在 s1 中首次出现的下标是3，故查找结果返回3。
C++类和对象的总结
- 类的成员有成员变量和成员函数两种。
- 成员函数之间可以互相调用，成员函数内部可以访问成员变量。
- 私有成员只能在类的成员函数内部访问。默认情况下，class 类的成员是私有的，struct 类的成员是公有的。
- 可以用“对象名.成员名”、“引用名.成员名”、“对象指针->成员名”的方法访问对象的成员变量或调用成员函数。成员函数被调用时，可以用上述三种方法指定函数是作用在哪个对象上的。
- 对象所占用的存储空间的大小等于各成员变量所占用的存储空间的大小之和（如果不考虑成员变量对齐问题的话）。
- 定义类时，如果一个构造函数都不写，则编译器自动生成默认（无参）构造函数和复制构造函数。如果编写了构造函数，则编译器不自动生成默认构造函数。一个类不一定会有默认构造函数，但一定会有复制构造函数。
- 任何生成对象的语句都要说明对象是用哪个构造函数初始化的。即便定义对象数组，也要对数组中的每个元素如何初始化进行说明。如果不说明，则编译器认为对象是用默认构造函数或参数全部可以省略的构造函数初始化。在这种情况下，如果类没有默认构造函数或参数全部可以省略的构造函数，则编译出错。
- 对象在消亡时会调用析构函数。
- 每个对象有各自的一份普通成员变量，但是静态成员变量只有一份，被所有对象所共享。静态成员函数不具体作用于某个对象。即便对象不存在，也可以访问类的静态成员。静态成员函数内部不能访问非静态成员变量，也不能调用非静态成员函数。
- 常量对象上面不能执行非常量成员函数，只能执行常量成员函数。
- 包含成员对象的类叫封闭类。任何能够生成封闭类对象的语句，都要说明对象中包含的成员对象是如何初始化的。如果不说明，则编译器认为成员对象是用默认构造函数或参数全部可以省略的构造函数初始化。
- 在封闭类的构造函数的初始化列表中可以说明成员对象如何初始化。封闭类对象生成时，先执行成员对象的构造函数，再执行自身的构造函数；封闭类对象消亡时，先执行自身的析构函数，再执行成员对象的析构函数。
- const 成员和引用成员必须在构造函数的初始化列表中初始化，此后值不可修改。
- 友元分为友元函数和友元类。友元关系不能传递。
- 成员函数中出现的 this 指针，就是指向成员函数所作用的对象的指针。因此，静态成员函数内部不能出现 this 指针。成员函数实际上的参数个数比表面上看到的多一个，多出来的参数就是 this 指针。
C++引用
- 我们知道，参数的传递本质上是一次赋值的过程，赋值就是对内存进行拷贝。所谓内存拷贝，是指将一块内存上的数据复制到另一块内存上。
- 对于像 char、bool、int、float 等基本类型的数据，它们占用的内存往往只有几个字节，对它们进行内存拷贝非常快速。而数组、结构体、对象是一系列数据的集合，数据的数量没有限制，可能很少，也可能成千上万，对它们进行频繁的内存拷贝可能会消耗很多时间，拖慢程序的执行效率。
C/C++ 禁止在函数调用时直接传递数组的内容，而是强制传递数组指针。
而对于结构体和对象没有这种限制，调用函数时既可以传递指针，也可以直接传递内容。
- 但是在 C++ 中，我们有了一种比指针更加便捷的传递聚合类型数据的方式，那就是引用（Reference）。
- 引用（Reference）是 C++ 相对于C语言的又一个扩充。引用可以看做是数据的一个别名，通过这个别名和原来的名字都能够找到这份数据。引用类似于 Windows 中的快捷方式，一个可执行程序可以有多个快捷方式，通过这些快捷方式和可执行程序本身都能够运行程序；引用还类似于人的绰号（笔名），使用绰号（笔名）和本名都能表示一个人。
- 引用的定义方式类似于指针，只是用
&取代了*，语法格式为：type &name = data;
- type 是被引用的数据的类型，name 是引用的名称，data 是被引用的数据。引用必须在定义的同时初始化，并且以后也要从一而终，不能再引用其它数据，这有点类似于常量（const 变量）。
- 注意，引用在定义时需要添加
&，在使用时不能添加&，使用时添加&表示取地址。如下面代码所示，第 6 行中的&表示引用，第 8 行中的&表示取地址。除了这两种用法，&还可以表示位运算中的与运算。- 由于引用 r 和原始变量 a 都是指向同一地址，所以通过引用也可以修改原始变量中所存储的数据。
- 如果读者不希望通过引用来修改原始的数据，那么可以在定义时添加 const 限制，形式为：
const type &name = value;
- 也可以是：
type const &name = value;
- 这种引用方式为常引用
#include <iostream> using namespace std; int main() { int a = 99; int &r = a; cout << a << ", " << r << endl; cout << &a << ", " << &r << endl; return 0; }运行结果：
99, 99
0x28ff44, 0x28ff44
C++引用作为函数参数
- 在定义或声明函数时，我们可以将函数的形参指定为引用的形式，这样在调用函数时就会将实参和形参绑定在一起，让它们都指代同一份数据。如此一来，如果在函数体中修改了形参的数据，那么实参的数据也会被修改，从而拥有“在函数内部影响函数外部数据”的效果。
- 一个能够展现按引用传参的优势的例子就是交换两个数的值，请看下面的代码：
#include <iostream> using namespace std; void swap1(int a, int b); void swap2(int *p1, int *p2); void swap3(int &r1, int &r2); int main() { int num1, num2; cout << "Input two integers: "; cin >> num1 >> num2; swap1(num1, num2); cout << num1 << " " << num2 << endl; cout << "Input two integers: "; cin >> num1 >> num2; swap2(&num1, &num2); cout << num1 << " " << num2 << endl; cout << "Input two integers: "; cin >> num1 >> num2; swap3(num1, num2); cout << num1 << " " << num2 << endl; return 0; } //直接传递参数内容 void swap1(int a, int b) { int temp = a; a = b; b = temp; } //传递指针 void swap2(int *p1, int *p2) { int temp = *p1; *p1 = *p2; *p2 = temp; } //按引用传参 void swap3(int &r1, int &r2) { int temp = r1; r1 = r2; r2 = temp; }运行结果：
Input two integers: 12 34↙
12 34
Input two integers: 88 99↙
99 88
Input two integers: 100 200↙
200 100
本例演示了三种交换变量的值的方法：
- 1) swap1() 直接传递参数的内容，不能达到交换两个数的值的目的。对于 swap1() 来说，a、b 是形参，是作用范围仅限于函数内部的局部变量，它们有自己独立的内存，和 num1、num2 指代的数据不一样。调用函数时分别将 num1、num2 的值传递给 a、b，此后 num1、num2 和 a、b 再无任何关系，在 swap1() 内部修改 a、b 的值不会影响函数外部的 num1、num2，更不会改变 num1、num2 的值。
- 2) swap2() 传递的是指针，能够达到交换两个数的值的目的。调用函数时，分别将 num1、num2 的指针传递给 p1、p2，此后 p1、p2 指向 a、b 所代表的数据，在函数内部可以通过指针间接地修改 a、b 的值。
- 3) swap3() 是按引用传递，能够达到交换两个数的值的目的。调用函数时，分别将 r1、r2 绑定到 num1、num2 所指代的数据，此后 r1 和 num1、r2 和 num2 就都代表同一份数据了，通过 r1 修改数据后会影响 num1，通过 r2 修改数据后也会影响 num2。
- 从以上代码的编写中可以发现，按引用传参在使用形式上比指针更加直观。在以后的 C++ 编程中，我鼓励读者大量使用引用，它一般可以代替指针（当然指针在C++中也不可或缺），C++ 标准库也是这样做的。
C++引用作为函数返回值
- 引用除了可以作为函数形参，还可以作为函数返回值，请看下面的例子：
#include <iostream> using namespace std; int &plus10(int &r) { r += 10; return r; } int main() { int num1 = 10; int num2 = plus10(num1); cout << num1 << " " << num2 << endl; return 0; }运行结果：
20 20
- 在将引用作为函数返回值时应该注意一个小问题，就是不能返回局部数据（例如局部变量、局部对象、局部数组等）的引用，因为当函数调用完成后局部数据就会被销毁，有可能在下次使用时数据就不存在了，C++ 编译器检测到该行为时也会给出警告。
更改上面的例子，让 plus10() 返回一个局部数据的引用：
#include <iostream> using namespace std; int &plus10(int &r) { int m = r + 10; return m; //返回局部数据的引用 } int main() { int num1 = 10; int num2 = plus10(num1); cout << num2 << endl; int &num3 = plus10(num1); int &num4 = plus10(num3); cout << num3 << " " << num4 << endl; return 0; }
- 在 Visual Studio 下的运行结果：
20
-858993450 -858993450
- 在 GCC 下的运行结果：
20
30 30
- 在 C-Free 下的运行结果：
20
30 0
- 而我们期望的运行结果是：
20
20 30
- plus10() 返回一个对局部变量 m 的引用，这是导致运行结果非常怪异的根源，因为函数是在栈上运行的，并且运行结束后会放弃对所有局部数据的管理权，后面的函数调用会覆盖前面函数的局部数据。本例中，第二次调用 plus10() 会覆盖第一次调用 plus10() 所产生的局部数据，第三次调用 plus10() 会覆盖第二次调用 plus10() 所产生的局部数据。
C++继承和派生
- 继承（Inheritance）可以理解为一个类从另一个类获取成员变量和成员函数(除了构造函数和析构函数)的过程。例如类 B 继承于类 A，那么 B 就拥有 A 的成员变量和成员函数。
- 在C++中，派生（Derive）和继承是一个概念，只是站的角度不同。继承是儿子接收父亲的产业，派生是父亲把产业传承给儿子。
- 被继承的类称为父类或基类，继承的类称为子类或派生类。“子类”和“父类”通常放在一起称呼，“基类”和“派生类”通常放在一起称呼。
- 派生类除了拥有基类的成员，还可以定义自己的新成员，以增强类的功能。
- 以下是两种典型的使用继承的场景：
1) 当你创建的新类与现有的类相似，只是多出若干成员变量或成员函数时，可以使用继承，这样不但会减少代码量，而且新类会拥有基类的所有功能。
2) 当你需要创建多个类，它们拥有很多相似的成员变量或成员函数时，也可以使用继承。可以将这些类的共同成员提取出来，定义为基类，然后从基类继承，既可以节省代码，也方便后续修改成员。
- 由此总结出继承的一般语法为：
class 派生类名:［继承方式］ 基类名{
派生类新增加的成员
};
- 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。
C++三种继承方式
public、protected、private 指定继承方式
不同的继承方式会影响基类成员在派生类中的访问权限。
1) public继承方式
- 基类中所有 public 成员在派生类中为 public 属性；
- 基类中所有 protected 成员在派生类中为 protected 属性；
- 基类中所有 private 成员在派生类中不能使用。
2) protected继承方式
- 基类中的所有 public 成员在派生类中为 protected 属性；
- 基类中的所有 protected 成员在派生类中为 protected 属性；
- 基类中的所有 private 成员在派生类中不能使用。
3) private继承方式
- 基类中的所有 public 成员在派生类中均为 private 属性；
- 基类中的所有 protected 成员在派生类中均为 private 属性；
- 基类中的所有 private 成员在派生类中不能使用。
通过上面的分析可以发现：
- 1) 基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。再如，当继承方式为 public 时，那么基类成员在派生类中的访问权限将保持不变。也就是说，继承方式中的 public、protected、private 是用来指明基类成员在派生类中的最高访问权限的。
- 2) 不管继承方式如何，基类中的 private 成员在派生类中始终不能使用（不能在派生类的成员函数中访问或调用）。
- 3) 如果希望基类的成员能够被派生类继承并且毫无障碍地使用，那么这些成员只能声明为 public 或 protected；只有那些不希望在派生类中使用的成员才声明为 private。
- 4) 如果希望基类的成员既不向外暴露（不能通过对象访问），还能在派生类中使用，那么只能声明为 protected。
注意，我们这里说的是基类的 private 成员不能在派生类中使用，并没有说基类的 private 成员不能被继承。实际上，基类的 private 成员是能够被继承的，并且（成员变量）会占用派生类对象的内存，它只是在派生类中不可见，导致无法使用罢了。private 成员的这种特性，能够很好的对派生类隐藏基类的实现，以体现面向对象的封装性。
由于 private 和 protected 继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以实际开发中我们一般使用 public。
#include<iostream> using namespace std; //基类People class People{ public: void setname(char *name); void setage(int age); void sethobby(char *hobby); char *gethobby(); protected: char *m_name; int m_age; private: char *m_hobby; }; void People::setname(char *name){ m_name = name; } void People::setage(int age){ m_age = age; } void People::sethobby(char *hobby){ m_hobby = hobby; } char *People::gethobby(){ return m_hobby; } //派生类Student class Student: public People{ public: void setscore(float score); protected: float m_score; }; void Student::setscore(float score){ m_score = score; } //派生类Pupil class Pupil: public Student{ public: void setranking(int ranking); void display(); private: int m_ranking; }; void Pupil::setranking(int ranking){ m_ranking = ranking; } void Pupil::display(){ cout<<m_name<<"的年龄是"<<m_age<<"，考试成绩为"<<m_score<<"分，班级排名第"<<m_ranking<<"，TA喜欢"<<gethobby()<<"。"<<endl; } int main(){ Pupil pup; pup.setname("小明"); pup.setage(15); pup.setscore(92.5f); pup.setranking(4); pup.sethobby("乒乓球"); pup.display(); return 0; }
- 运行结果：
小明的年龄是15，考试成绩为92.5分，班级排名第4，TA喜欢乒乓球。
- 这是一个多级继承的例子，Student 继承自 People，Pupil 又继承自 Student，它们的继承关系为 People --> Student --> Pupil。Pupil 是最终的派生类，它拥有基类的 m_name、m_age、m_score、m_hobby 成员变量以及 setname()、setage()、sethobby()、gethobby()、setscore() 成员函数。
- 注意，在派生类 Pupil 的成员函数 display() 中，我们借助基类的 public 成员函数 gethobby() 来访问基类的 private 成员变量 m_bobby，因为 m_hobby 是 private 属性的，在派生类中不可见，所以只能借助基类的 public 成员函数 sethobby()、gethobby() 来访问。
- 在派生类中访问基类 private 成员的唯一方法就是借助基类的非 private 成员函数，如果基类没有非 private 成员函数，那么该成员在派生类中将无法访问。
改变基类成员在派生类中的访问权限
使用 using 关键字可以改变基类成员在派生类中的访问权限，例如将 public 改为 private、将 protected 改为 public。
注意：using 只能改变基类中 public 和 protected 成员的访问权限，不能改变 private 成员的访问权限，因为基类中 private 成员在派生类中是不可见的，根本不能使用，所以基类中的 private 成员在派生类中无论如何都不能访问。
using 关键字使用示例：#include<iostream> using namespace std; //基类People class People { public: void show(); protected: char *m_name; int m_age; }; void People::show() { cout << m_name << "的年龄是" << m_age << endl; } //派生类Student class Student : public People { public: void learning(); public: using People::m_name; //将protected改为public using People::m_age; //将protected改为public float m_score; //private: using People::show; //将public改为private }; void Student::learning() { cout << "我是" << m_name << "，今年" << m_age << "岁，这次考了" << m_score << "分！" << endl; } int main() { Student stu; stu.m_name = "小明"; stu.m_age = 16; stu.m_score = 99.5f; stu.show(); //compile error stu.learning(); return 0; }
- 代码中首先定义了基类 People，它包含两个 protected 属性的成员变量和一个 public 属性的成员函数。定义 Student 类时采用 public 继承方式，People 类中的成员在 Student 类中的访问权限默认是不变的。
- 不过，我们使用 using 改变了它们的默认访问权限，如代码第 21~25 行所示，将 show() 函数修改为 private 属性的，是降低访问权限，将 name、age 变量修改为 public 属性的，是提高访问权限。
C++继承的同名覆盖
如果派生类中的成员（包括成员变量和成员函数）和基类中的成员重名，那么就会遮蔽从基类继承过来的成员。所谓遮蔽，就是在派生类中使用该成员（包括在定义派生类时使用，也包括通过派生类对象访问该成员）时，实际上使用的是派生类新增的成员，而不是从基类继承来的。
#include<iostream> using namespace std; //基类People class People{ public: void show(); protected: char *m_name; int m_age; }; void People::show(){ cout<<"嗨，大家好，我叫"<<m_name<<"，今年"<<m_age<<"岁"<<endl; } //派生类Student class Student: public People{ public: Student(char *name, int age, float score); public: void show(); //遮蔽基类的show() private: float m_score; }; Student::Student(char *name, int age, float score){ m_name = name; m_age = age; m_score = score; } void Student::show(){ cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl; } int main(){ Student stu("小明", 16, 90.5); //使用的是派生类新增的成员函数，而不是从基类继承的 stu.show(); //使用的是从基类继承来的成员函数 stu.People::show(); return 0; }
- 运行结果：
小明的年龄是16，成绩是90.5
嗨，大家好，我叫小明，今年16岁
- 本例中，基类 People 和派生类 Student 都定义了成员函数 show()，它们的名字一样，会造成遮蔽。第 37 行代码中，stu 是 Student 类的对象，默认使用 Student 类的 show() 函数。
但是，基类 People 中的 show() 函数仍然可以访问，不过要加上类名和域解析符，如第 39 行代码所示
基类成员函数和派生类成员函数不构成重载--------重定义
- 基类成员和派生类成员的名字一样时会造成遮蔽，这句话对于成员变量很好理解，对于成员函数要引起注意，不管函数的参数如何，只要名字一样就会造成遮蔽。
- 换句话说，基类成员函数和派生类成员函数不会构成重载，如果派生类有同名函数，那么就会遮蔽基类中的所有同名函数，不管它们的参数是否一样。
#include<iostream> using namespace std; //基类Base class Base{ public: void func(); void func(int); }; void Base::func(){ cout<<"Base::func()"<<endl; } void Base::func(int a){ cout<<"Base::func(int)"<<endl; } //派生类Derived class Derived: public Base{ public: void func(char *); void func(bool); }; void Derived::func(char *str){ cout<<"Derived::func(char *)"<<endl; } void Derived::func(bool is){ cout<<"Derived::func(bool)"<<endl; } int main(){ Derived d; d.func("c.biancheng.net"); d.func(true); d.func(); //compile error d.func(10); //compile error d.Base::func(); d.Base::func(100); return 0; }
- 本例中，Base 类的
func()、func(int)和 Derived 类的func(char *)、func(bool)四个成员函数的名字相同，参数列表不同，它们看似构成了重载，能够通过对象 d 访问所有的函数，实则不然，Derive 类的 func 遮蔽了 Base 类的 func，导致第 26、27 行代码没有匹配的函数，所以调用失败。- 如果说有重载关系，那么也是 Base 类的两个 func 构成重载，而 Derive 类的两个 func 构成另外的重载。
- 重载必须在同一个类
- 子类无法重载父类的函数，父类函数同名覆盖
C++基类和派生类的构造函数
- 前面我们说基类的成员函数可以被继承，可以通过派生类的对象访问，但这仅仅指的是普通的成员函数，类的构造函数不能被继承。
- 构造函数不能被继承是有道理的，因为即使继承了，它的名字和派生类的名字也不一样，不能成为派生类的构造函数，当然更不能成为普通的成员函数。
- C++继承中是普遍存在的解决这个问题的思路是：在派生类的构造函数中调用基类的构造函数。
下面的例子展示了如何在派生类的构造函数中调用基类的构造函数：
#include<iostream> using namespace std; //基类People class People{ protected: char *m_name; int m_age; public: People(char*, int); }; People::People(char *name, int age): m_name(name), m_age(age){} //派生类Student class Student: public People{ private: float m_score; public: Student(char *name, int age, float score); void display(); }; //People(name, age)就是调用基类的构造函数 Student::Student(char *name, int age, float score): People(name, age), m_score(score){ } void Student::display(){ cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<"。"<<endl; } int main(){ Student stu("小明", 16, 90.5); stu.display(); return 0; }运结果为：
小明的年龄是16，成绩是90.5。
- 请注意第 23 行代码：
Student::Student(char *name, int age, float score): People(name, age), m_score(score){ }
People(name, age)就是调用基类的构造函数，并将 name 和 age 作为实参传递给它，m_score(score)是派生类的参数初始化表，它们之间以逗号,隔开。
也可以将基类构造函数的调用放在参数初始化表后面：Student::Student(char *name, int age, float score): m_score(score), People(name, age){ }但是不管它们的顺序如何，派生类构造函数总是先调用基类构造函数再执行其他代码（包括参数初始化表以及函数体中的代码），总体上看和下面的形式类似：
Student::Student(char *name, int age, float score){ People(name, age); m_score = score; }当然这段代码只是为了方便大家理解，实际上这样写是错误的，因为基类构造函数不会被继承，不能当做普通的成员函数来调用。换句话说，只能将基类构造函数的调用放在函数头部，不能放在函数体中。
另外，函数头部是对基类构造函数的调用，而不是声明，所以括号里的参数是实参，它们不但可以是派生类构造函数参数列表中的参数，还可以是局部变量、常量等，例如：Student::Student(char *name, int age, float score): People("小明", 16), m_score(score){ }构造函数的调用顺序
- 从上面的分析中可以看出，基类构造函数总是被优先调用，这说明创建派生类对象时，会先调用基类构造函数，再调用派生类构造函数，如果继承关系有好几层的话，例如：
A --> B --> C
- 那么创建 C 类对象时构造函数的执行顺序为：
A类构造函数 --> B类构造函数 --> C类构造函数
- 构造函数的调用顺序是按照继承的层次自顶向下、从基类再到派生类的。
- 还有一点要注意，派生类构造函数中只能调用直接基类的构造函数，不能调用间接基类的。以上面的 A、B、C 类为例，C 是最终的派生类，B 就是 C 的直接基类，A 就是 C 的间接基类。
- C++ 这样规定是有道理的，因为我们在 C 中调用了 B 的构造函数，B 又调用了 A 的构造函数，相当于 C 间接地（或者说隐式地）调用了 A 的构造函数，如果再在 C 中显式地调用 A 的构造函数，那么 A 的构造函数就被调用了两次，相应地，初始化工作也做了两次，这不仅是多余的，还会浪费CPU时间以及内存，毫无益处，所以 C++ 禁止在 C 中显式地调用 A 的构造函数。
基类构造函数调用规则
事实上，通过派生类创建对象时必须要调用基类的构造函数，这是语法规定。换句话说，定义派生类构造函数时最好指明基类构造函数；如果不指明，就调用基类的默认构造函数（不带参数的构造函数）；如果没有默认构造函数，那么编译失败。请看下面的例子：
#include <iostream> using namespace std; //基类People class People{ public: People(); //基类默认构造函数 People(char *name, int age); protected: char *m_name; int m_age; }; People::People(): m_name("xxx"), m_age(0){ } People::People(char *name, int age): m_name(name), m_age(age){} //派生类Student class Student: public People{ public: Student(); Student(char*, int, float); public: void display(); private: float m_score; }; Student::Student(): m_score(0.0){ } //派生类默认构造函数 Student::Student(char *name, int age, float score): People(name, age), m_score(score){ } void Student::display(){ cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<"。"<<endl; } int main(){ Student stu1; stu1.display(); Student stu2("小明", 16, 90.5); stu2.display(); return 0; }
- 运行结果：
xxx的年龄是0，成绩是0。
小明的年龄是16，成绩是90.5。
- 创建对象 stu1 时，执行派生类的构造函数
Student::Student()，它并没有指明要调用基类的哪一个构造函数，从运行结果可以很明显地看出来，系统默认调用了不带参数的构造函数，也就是People::People()。- 创建对象 stu2 时，执行派生类的构造函数
Student::Student(char *name, int age, float score)，它指明了基类的构造函数。- 在第 27 行代码中，如果将
People(name, age)去掉，也会调用默认构造函数，第 37 行的输出结果将变为：xxx的年龄是0，成绩是90.5。
- 如果将基类 People 中不带参数的构造函数删除，那么会发生编译错误，因为创建对象 stu1 时需要调用 People 类的默认构造函数， 而 People 类中已经显式定义了构造函数，编译器不会再生成默认的构造函数。
C++基类和派生类的析构函数
和构造函数类似，析构函数也不能被继承。与构造函数不同的是，在派生类的析构函数中不用显式地调用基类的析构函数，因为每个类只有一个析构函数，编译器知道如何选择，无需程序员干涉。
- 另外析构函数的执行顺序和构造函数的执行顺序也刚好相反
- 创建派生类对象时，构造函数的执行顺序和继承顺序相同，即先执行基类构造函数，再执行派生类构造函数。
- 而销毁派生类对象时，析构函数的执行顺序和继承顺序相反，即先执行派生类析构函数，再执行基类析构函数。
请看下面的例子：
#include <iostream> using namespace std; class A{ public: A(){cout<<"A constructor"<<endl;} ~A(){cout<<"A destructor"<<endl;} }; class B: public A{ public: B(){cout<<"B constructor"<<endl;} ~B(){cout<<"B destructor"<<endl;} }; class C: public B{ public: C(){cout<<"C constructor"<<endl;} ~C(){cout<<"C destructor"<<endl;} }; int main(){ C test; return 0; }运行结果：
A constructor
B constructor
C constructor
C destructor
B destructor
A destructor
C++虚继承和虚基类详解
多继承（Multiple Inheritance）是指从多个直接基类中产生派生类的能力，多继承的派生类继承了所有父类的成员。尽管概念上非常简单，但是多个基类的相互交织可能会带来错综复杂的设计问题，命名冲突就是不可回避的一个。
多继承时很容易产生命名冲突，即使我们很小心地将所有类中的成员变量和成员函数都命名为不同的名字，命名冲突依然有可能发生，比如典型的是菱形继承，如下图所示：
图1：菱形继承
类 A 派生出类 B 和类 C，类 D 继承自类 B 和类 C，这个时候类 A 中的成员变量和成员函数继承到类 D 中变成了两份，一份来自 A-->B-->D 这条路径，另一份来自 A-->C-->D 这条路径。
在一个派生类中保留间接基类的多份同名成员，虽然可以在不同的成员变量中分别存放不同的数据，但大多数情况下这是多余的：因为保留多份成员变量不仅占用较多的存储空间，还容易产生命名冲突。假如类 A 有一个成员变量 a，那么在类 D 中直接访问 a 就会产生歧义，编译器不知道它究竟来自 A -->B-->D 这条路径，还是来自 A-->C-->D 这条路径。
虚继承（Virtual Inheritance）
为了解决多继承时的命名冲突和冗余数据问题，C++ 提出了虚继承，使得在派生类中只保留一份间接基类的成员。
在继承方式前面加上 virtual 关键字就是虚继承，请看下面的例子
//间接基类A
class A{
protected:
int m_a;
};
//直接基类B
class B: virtual public A{ //虚继承
protected:
int m_b;
};
//直接基类C
class C: virtual public A{ //虚继承
protected:
int m_c;
};
//派生类D
class D: public B, public C{
public:
void seta(int a){ m_a = a; } //正确
void setb(int b){ m_b = b; } //正确
void setc(int c){ m_c = c; } //正确
void setd(int d){ m_d = d; } //正确
private:
int m_d;
};
int main(){
D d;
return 0;
}这段代码使用虚继承重新实现了上图所示的菱形继承，这样在派生类 D 中就只保留了一份成员变量 m_a，直接访问就不会再有歧义了。
虚继承的目的是让某个类做出声明，承诺愿意共享它的基类。其中，这个被共享的基类就称为虚基类（Virtual Base Class），本例中的 A 就是一个虚基类。在这种机制下，不论虚基类在继承体系中出现了多少次，在派生类中都只包含一份虚基类的成员。
现在让我们重新梳理一下本例的继承关系，如下图所示：
图2：使用虚继承解决菱形继承中的命名冲突问题
观察这个新的继承体系，我们会发现虚继承的一个不太直观的特征：必须在虚派生的真实需求出现前就已经完成虚派生的操作。在上图中，当定义 D 类时才出现了对虚派生的需求，但是如果 B 类和 C 类不是从 A 类虚派生得到的，那么 D 类还是会保留 A 类的两份成员。
换个角度讲，虚派生只影响从指定了虚基类的派生类中进一步派生出来的类，它不会影响派生类本身。
在实际开发中，位于中间层次的基类将其继承声明为虚继承一般不会带来什么问题。通常情况下，使用虚继承的类层次是由一个人或者一个项目组一次性设计完成的。对于一个独立开发的类来说，很少需要基类中的某一个类是虚基类，况且新类的开发者也无法改变已经存在的类体系。
C++标准库中的 iostream 类就是一个虚继承的实际应用案例。iostream 从 istream 和 ostream 直接继承而来，而 istream 和 ostream 又都继承自一个共同的名为 base_ios 的类，是典型的菱形继承。此时 istream 和 ostream 必须采用虚继承，否则将导致 iostream 类中保留两份 base_ios 类的成员。
图3：虚继承在C++标准库中的实际应用
虚基类成员的可见性
因为在虚继承的最终派生类中只保留了一份虚基类的成员，所以该成员可以被直接访问，不会产生二义性。此外，如果虚基类的成员只被一条派生路径覆盖，那么仍然可以直接访问这个被覆盖的成员。但是如果该成员被两条或多条路径覆盖了，那就不能直接访问了，此时必须指明该成员属于哪个类。
以图2中的菱形继承为例，假设 A 定义了一个名为 x 的成员变量，当我们在 D 中直接访问 x 时，会有三种可能性：
- 如果 B 和 C 中都没有 x 的定义，那么 x 将被解析为 A 的成员，此时不存在二义性。
- 如果 B 或 C 其中的一个类定义了 x，也不会有二义性，派生类的 x 比虚基类的 x 优先级更高。
- 如果 B 和 C 中都定义了 x，那么直接访问 x 将产生二义性问题。
可以看到，使用多继承经常会出现二义性问题，必须十分小心。上面的例子是简单的，如果继承的层次再多一些，关系更复杂一些，程序员就很容易陷人迷魂阵，程序的编写、调试和维护工作都会变得更加困难，因此我不提倡在程序中使用多继承，只有在比较简单和不易出现二义性的情况或实在必要时才使用多继承，能用单一继承解决的问题就不要使用多继承。也正是由于这个原因，C++ 之后的很多面向对象的编程语言，例如 Java、C#、PHP 等，都不支持多继承。
C++虚继承时的构造函数
在虚继承中，虚基类是由最终的派生类初始化的，换句话说，最终派生类的构造函数必须要调用虚基类的构造函数。对最终的派生类来说，虚基类是间接基类，而不是直接基类。这跟普通继承不同，在普通继承中，派生类构造函数中只能调用直接基类的构造函数，不能调用间接基类的。
下面我们以菱形继承为例来演示构造函数的调用：
#include <iostream>
using namespace std;
//虚基类A
class A{
public:
A(int a);
protected:
int m_a;
};
A::A(int a): m_a(a){ }
//直接派生类B
class B: virtual public A{
public:
B(int a, int b);
public:
void display();
protected:
int m_b;
};
B::B(int a, int b): A(a), m_b(b){ }
void B::display(){
cout<<"m_a="<<m_a<<", m_b="<<m_b<<endl;
}
//直接派生类C
class C: virtual public A{
public:
C(int a, int c);
public:
void display();
protected:
int m_c;
};
C::C(int a, int c): A(a), m_c(c){ }
void C::display(){
cout<<"m_a="<<m_a<<", m_c="<<m_c<<endl;
}
//间接派生类D
class D: public B, public C{
public:
D(int a, int b, int c, int d);
public:
void display();
private:
int m_d;
};
D::D(int a, int b, int c, int d): A(a), B(90, b), C(100, c), m_d(d){ }
void D::display(){
cout<<"m_a="<<m_a<<", m_b="<<m_b<<", m_c="<<m_c<<", m_d="<<m_d<<endl;
}
int main(){
B b(10, 20);
b.display();
C c(30, 40);
c.display();
D d(50, 60, 70, 80);
d.display();
return 0;
}运行结果：
m_a=10, m_b=20
m_a=30, m_c=40
m_a=50, m_b=60, m_c=70, m_d=80
请注意第 50 行代码，在最终派生类 D 的构造函数中，除了调用 B 和 C 的构造函数，还调用了 A 的构造函数，这说明 D 不但要负责初始化直接基类 B 和 C，还要负责初始化间接基类 A。而在以往的普通继承中，派生类的构造函数只负责初始化它的直接基类，再由直接基类的构造函数初始化间接基类，用户尝试调用间接基类的构造函数将导致错误。
现在采用了虚继承，虚基类 A 在最终派生类 D 中只保留了一份成员变量 m_a，如果由 B 和 C 初始化 m_a，那么 B 和 C 在调用 A 的构造函数时很有可能给出不同的实参，这个时候编译器就会犯迷糊，不知道使用哪个实参初始化 m_a。
为了避免出现这种矛盾的情况，C++ 干脆规定必须由最终的派生类 D 来初始化虚基类 A，直接派生类 B 和 C 对 A 的构造函数的调用是无效的。在第 50 行代码中，调用 B 的构造函数时试图将 m_a 初始化为 90，调用 C 的构造函数时试图将 m_a 初始化为 100，但是输出结果有力地证明了这些都是无效的，m_a 最终被初始化为 50，这正是在 D 中直接调用 A 的构造函数的结果。
另外需要关注的是构造函数的执行顺序。虚继承时构造函数的执行顺序与普通继承时不同：在最终派生类的构造函数调用列表中，不管各个构造函数出现的顺序如何，编译器总是先调用虚基类的构造函数，再按照出现的顺序调用其他的构造函数；而对于普通继承，就是按照构造函数出现的顺序依次调用的。
修改本例中第 50 行代码，改变构造函数出现的顺序：
D::D(int a, int b, int c, int d): B(90, b), C(100, c), A(a), m_d(d){ }虽然我们将 A() 放在了最后，但是编译器仍然会先调用 A()，然后再调用 B()、C()，因为 A() 是虚基类的构造函数，比其他构造函数优先级高。如果没有使用虚继承的话，那么编译器将按照出现的顺序依次调用 B()、C()、A()。
C++将派生类赋值给基类（向上转型）
扫一扫
1187
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
