一、C/C++ 基本知识

• 防卫式声明

1
2
3
4
5
6

#ifndef __xxx__
#define __xxx__

..

#endif

​ - 相比于#pragma once，上面的更好。

• class template：防止写死，将来使用才规定。

• C++类的两个部分，带指针的类和不带指针的类。

• inline内联函数：在class body内定义完成，成为inline候选人，最后结果由编译器决定。

• 数据用private，函数用public，保证封装性。

• 构造函数

  • 1 2 3

    complex(double x=0,double y=0):re(x),im(y){ }

  • 没有返回值

  • 默认实参

  • 初始列（尽量写在初始列里面）

  • 不带指针的类，多半不用写析构函数

  • 构造函数可以重载

  • 构造函数放在private区，不多，但是一种有名的设计模式 Singleton，作用是只创建一个对象。

• const常量成员函数

  • 只读数据

  • 不改变数据

  • 1 2 3

    double real() const{ return re; }

• 参数传递

  • 值传递
  • 引用传递
  • 指针传递

• 返回值传递

  • 值返回
  • 引用返回
  • 指针返回

二、C语言的万能指针 void *

• C语言中，*类型就是指针类型。比如 int *p，double *q，虽然是不一样的指针，但是大小却一样sizeof(p) == sizeof(q)，其实很容易理解，因为他们都是同一种类型*类型的。C语言是强类型的语言。对类型的区分十分严格。对于一个指针而言，如果我们在前面规定了它的类型。那就相当于决定了它的“跳跃力”。“跳跃力”含义是指针+1时的跳跃字节数。int跳了4个字节，但是double跳了8个字节。基于这样的理解，我要对void *的定义是：

  void * 是一个跳跃力未定的指针

• void* 的作用是我们可以自己控制在需要的时候将它实现为需要的类型。这样的好处是：编程时候节约代码，实现泛型编程。

• void *是一种指针类型，常用在函数参数、函数返回值中需要兼容不同指针类型的地方。我们可以将别的类型的指针无需强制类型转换的赋值给void *类型。也可以将void *强制类型转换成任何别的指针类型，至于强转的类型是否合理，就需要我们程序员自己控制了。

• 如下所示，冒泡排序的泛型编程

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

  #include <stdio.h> #include <string.h> static void Swap(char *vp1, char *vp2, int width) { char tmp; if ( vp1 != vp2 ) { while ( width-- ) { tmp = *vp1; *vp1++ = *vp2; *vp2++ = tmp; } } } void BubbleSort(void *base, int n, int elem_size, int (*compare)( void *, void * )) { int i, last, end = n - 1; char *elem_addr1, *elem_addr2; while (end > 0) { last = 0; for (i = 0; i < end; i++) { elem_addr1 = (char *)base + i * elem_size; elem_addr2 = (char *)base + (i + 1) * elem_size; if (compare( elem_addr1, elem_addr2 ) > 0) { Swap(elem_addr1, elem_addr2, elem_size); last = i; } } end = last; } } int compare_int(void *elem1, void *elem2) { return (*(int *)elem1 - *(int *)elem2); } int compare_double(void *elem1, void *elem2) { return (*(double *)elem1 > *(double *)elem2) ? 1 : 0; } int main(int argc, char *argv[]) { int num_int[8] = {8,7,6,5,4,3,2,1}; double num_double[8] = {8.8,7.7,6.6,5.5,4.4,3.3,2.2,1.1}; int i; BubbleSort(num_int, 8, sizeof(int), compare_int); for (i = 0; i < 8; i++) { printf("%d ", num_int[i]); } printf("\n"); BubbleSort(num_double, 8, sizeof(double), compare_double); for (i = 0; i < 8; i++) { printf("%.1f ", num_double[i]); } printf("\n"); return 0; }

三、C语言的字符数组的末尾\0问题

• 1.char str[10] = “Hello”;

  此时我们只给str数组前5个元素赋值，剩余5个元素系统将会自动赋值为’\0’，当赋值个数会小于数组长度时系统都会自动添加’\0’.

• 2.char str[5] = {‘h’,‘e’,‘l’,‘l’,‘o’}; 此时str的长度刚好==字符串长度，此时系统将不会自动添加’\0’,如果数组长度大于字符串长度则会自动添加’\0’.

• 3.char str[] = {‘H’,‘e’,‘l’,‘l’,‘o’}; 用此方法定义并初始化一个数组系统不会自动添加’\0’.

• 4.char str[] = "hello"; 系统会自动在后面添加‘\0’（对比一下3）

• 注意：char str[5]="hello"是错误的写法。应该定义长度为6.

• 对于sizeof操作符而言，会把最后的\0 包含进去。但是strlen 函数会遇到\0停止计数，同时最后减1.

• 特例，strlen 输出错误结果。

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  #include <bits/stdc++.h> using namespace std; using ll = long long; int main() { //一维数组 char str2[3] = {'a', 's', 'd'}; int cc = sizeof(str2); int dd = strlen(str2); cout << "sizeof = " << cc << endl; cout << "strlen = " << dd << endl; return 0; } /*输出 sizeof = 3 strlen = 4 */

• 从结果可以看出，字符满数组的话，strlen 的结果是错误的，因为没有给结束标志\0。长度是错的。

• 1 2 3 4 5 6 7 8

  char a[]="hello"; char b[]={'h','e','l','l','o'}; /* strlen(a),strlen(b)的值分别是多少? 前面分析过，strlen是求字符串的长度，字符串有个默认的结束符/0,这个结束符是在定义字符串的时候系统自动加上去的，就像定义数组a一样。数组a定义了一个字符串，数组b定义了一个字符数组。因此，strlen(a)=5,而strlen(b)的长度就不确定的，因为strlen找不到结束符。 */

四、C++ 数组和指针

一维数组和指针

• 数组名就是指针，但是数组名取地址和数组名不一样，表现在加+的地址。数组名或者数组指针或者数组第一个元素指针+1，以数组类型如int的大小加地址；但数组名取地址的指针+1，加的大小是整个数组的大小的下一个地址。

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

  #include <bits/stdc++.h> using namespace std; using ll = long long; int main() { int a[10] = {1, 2, 3, 4, 5}; int *p = a; auto *q = &a; int *m = &a[0]; for (int i = 0; i <= 1; ++i) { cout << "*p=a " << p + i << endl; cout << "a " << a + i << endl; cout << "&a[0] " << m + i << endl; cout << "&a " << q + i << endl; } return 0; } /*输出结果 *p=a 0x361fdd0 a 0x361fdd0 &a[0] 0x361fdd0 &a 0x361fdd0 *p=a 0x361fdd4 a 0x361fdd4 &a[0] 0x361fdd4 &a 0x361fdf8 //很明显这个加1，不一样 */

• 对于指针k而言，*k++这种操作是没问题的，但是*array++是不允许的，这是因为array是数组的标识名，是常量，不能跟++。

多维数组和指针

• 首先要理解多维数组的形式，声明一个marray[][MAXSIZE],这里marray[i]每个都是指针，指向该行的首地址，但多维数组的列长度是确定的，这里与指针数组就区别开了。

• 多维数组实质存放在连续的地址空间，而不是逻辑上的多维矩阵，这意味着我们指针的操作可以变得非常强大。

• 声明如下的二维数组

• 1 2 3 4

  static char daytab[2][13] = { {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} };

• 这里的daytab，作为指针，指向的是数组{daytab[0],daytab[1]}的首地址；

• 而daytab[0]也是指针，指向的是{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}的首地址。

• 当我们要求取daytab[0][0]时，是用**daytab。*daytab事实上就等于daytab[0],**daytab就是*daytab[0]，所以这里其实是一个三级结构。

• 当我们要操作某一行某一列的时候，可以用*(daytab+i)+j表示daytab[i][j]的地址，用*(*(daytab+i)+j)表示daytab[i][j]的值；而由于地址的连续性，使用*(*daytab + len*i + j)和*(*(daytab+i)+j)是完全等价的，这里len是二维数组的列数。

指针数组和数组指针

• 确定优先级——()>[]>*;
• (*p)[n]：根据优先级，先看括号内，则p是一个指针，这个指针指向一个一维数组，数组长度为n，这是“数组的指针”，即数组指针；
• *p[n]：根据优先级，先看[]，则p是一个数组，再结合*，这个数组的元素是指针类型，共n个元素，这是“指针的数组”，即指针数组。
• p是数组，则就是指针数组；p是指针，则是数组指针。

数组指针

• 指向一个数组的指针，例如5个int，则指针++步进20字节。

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

  #include <bits/stdc++.h> using namespace std; using ll = long long; int main() { //一维数组 int a[5] = {1, 2, 3, 4, 5}; //定义一个指向有5个元素的数组的指针，此时的指针步进为20个字节=4*5 int (*p)[5]; //把数组a的地址赋给p，则p为数组a的地址，则*p表示数组a本身 p = &a; //%p输出地址, %d输出十进制 printf(" a = %p\n", a); //输出数组名，一般用数组的首元素地址来标识一个数组，则输出数组首元素地址 printf(" p = %p\n", p); //根据上面，p为数组a的地址，输出数组a的地址 printf(" *p = %p\n", *p); //*p表示数组a本身，用数组的首元素地址来标识一个数组 printf("&a[0]=%p\n", &a[0]); //a[0]的地址 printf("&a[1]=%p\n", &a[1]); //a[1]的地址 printf("p[0]= %p\n", p[0]); //数组指针的地址 printf("p[1]= %p\n", p[1]); //数组指针++的地址 printf("**p = %d\n", **p); //*p为数组a本身，即为数组a首元素地址，则*(*p)为值，当*p为数组首元素地址时，**p表示首元素的值1 printf("(*p)[0]=%d\n", (*p)[0]); //指向数组的第一个元素 printf("(*p)[3]=%d\n", (*p)[3]); //指向数组的第4个元素 return 0; } /*输出 a = 000000000362fe00 p = 000000000362fe00 *p = 000000000362fe00 &a[0]=000000000362fe00 &a[1]=000000000362fe04 p[0]= 000000000362fe00 p[1]= 000000000362fe14 **p = 1 (*p)[0]=1 (*p)[3]=4 */

• 指向二维数组

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  #include <bits/stdc++.h> using namespace std; using ll = long long; int main() { //将二维数组赋给指针 int b[2][13] = { {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} }; int(*pp)[13]; //定义一个数组指针，指向含13个元素的一维数组 pp = b; //将该二维数组的首地址赋给pp，也就是b[0]或&b[0]，二维数组中pp=b和pp=&b[0]是等价的 cout << "pp = " << pp << endl; cout << "b = " << b << endl; pp++; //pp=pp+1，该语句执行过后pp的指向从行b[0][]变为了行b[1][]，pp=&b[1] cout << "pp+1 = " << pp << endl; cout << "b[1] = " << b[1] << endl; cout << "b[1][2] = " << b[1][2] << endl; cout << "*(*pp + 2) = " << *(*pp + 2) << endl; return 0; } /*输出 pp = 0x361fdb0 b = 0x361fdb0 pp+1 = 0x361fde4 b[1] = 0x361fde4 b[1][2] = 29 *(*pp + 2) = 29 */

指针数组

• 数组的元素是指针

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main() {

    int a = 1;
    int b = 2;
    int *p[2];
    p[0] = &a;
    p[1] = &b;

    printf("%p\n", p[0]); //a的地址
    printf("%p\n", &a); //a的地址
    printf("%p\n", p[1]); //b的地址
    printf("%p\n", &b); //b的地址
    printf("%d\n", *p[0]); //p[0]表示a的地址，则*p[0]表示a的值
    printf("%d\n", *p[1]); //p[1]表示b的地址，则*p[1]表示b的值

    return 0;
}

/*输出结果
000000000362fe1c
000000000362fe1c
000000000362fe18
000000000362fe18
1
2
*/

char* 和 char[]的区别

• 1.char*和char[]都可以表示字符串

• 2.char[]可读可写,可以修改字符串的内容。char*可读不可写，写入就会导致段错误。

• 具体原因是因为：指针指向常量字符串(位于常量存储区)，而常量字符串的内容是不可以被修改的，企图修改常量字符串的内容而导致运行错误。

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  #include <bits/stdc++.h> using namespace std; using ll = long long; int main() { char *p = "China"; char q[] = "England"; cout << p << endl; cout << q << endl; //不可行 // p[2]='d';//字符串处于常量存储区，不可更改 q[2]='f'; cout << q << endl; return 0; } /*输出结果 China England Enfland */

• sizeof(char*) 得出指针的大小

• sizeof(char[]) 得出数组的字节数

• 在C++语言中char str[]={'h','e','l','l','o'}，只是赋值了字符串的内容，但是却没有赋值字符串的结束标志，所以，它不能将字符串"hello"正确赋给数组。

• 要想达到将字符串"hello"正确地初始化赋给数组、的目的，可以使用以下的三种方法中的任何一种，都可以达到目的：

  • char str[]={'h','e','l','l','o','\0'};
  • char str[6]={'h','e','l','l','o'};
  • char str[]="hello";

• 常见例题

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  int main() { //A,错误，没有给结束标志 char str[] = {'h', 'e', 'l', 'l', 'o'}; str[0] = 'a'; //B 正确 char str[6] = {'h', 'e', 'l', 'l', 'o'}; string str2(str); //C 正确 char str[] = "hello"; str[0] = 'a'; //D,有问题，不可更改 str[0] char *str = "hello"; str[0] = 'a'; return 0; }

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  #include <iostream> using namespace std; int main() { char maxhub[] = "maxbub\0\0\x11\\"; cout << sizeof(maxhub) << "," << strlen(maxhub) << "," << sizeof(maxhub + 1); return 0; } /*输出结果 11,6,8 //原因 ①sizeof(maxhub) 表示包含最后的 \0 的字节数目，其中\x11表示一个字节，x11是16进制。所以有11个字节。 ②strlen(maxhub) 表示遇到第一个 \0 前的字节数。所以有6个。 ③maxhub+1 是一个 char* 类型，所以大小是指针的大小。计算机为64位。 */

五、结构体变量

• 结构体定义

  1 2 3 4 5 6

  struct PersonInfo{ int index; char name[30]; short age; }; PersonInfo person1, person1;

• 引用结构体成员有两种方式：一种是声明结构体变量，通过成员运算符.进行引用；一种是声明结构体变量指针，通过指向运算符->引用。

• 面试必考——结构体内存对齐原则和计算方法

内存对齐

• 虽然所有的变量最后都会保存到特定的地址内存中去，但是相应的内存空间必须满足内存对齐的要求，主要基于存在以下两个原因：

  • 硬件平台原因：并不是所有的平台都能够访问任意地址上的任意数据，某些硬件平台只能够访问对齐的地址，否则就会出现硬件异常错误。

  • 性能原因：如果数据存放在未对齐的内存空间中，则处理器在访问变量时要做两次次内存访问，而对齐的内存访问只需要一次。

    • 假定现在有一个 32 位微处理器，那这个处理器访问内存都是按照 32 位进行的，也就是说一次性读取或写入都是四字节。假设现在有一个处理器要读取一个大小为 4 字节的变量，在内存对齐的情况下，处理器是这样进行读取的：

    • 

    • 那如果数据存储没有按照内存对齐的方式进行的话，处理器就会这样进行读取：

    • 

    • 对比内存对齐和内存没有对齐两种情况我们可以明显地看到： 在内存对齐的情况下，只需要两个个步骤就可以将数据读出来，首先处理器找到要读出变量所在的地址，然后将数据读出来。 在内存没有对齐的情况下，却需要以下四个步骤才能够将数据取出来：

      • 处理器找到要读取变量所在的地址，也就是图中红色方块所在位置。
      • 由于此时内存未对齐，处理器是 32 位的，一次性读取或者写入都是 4 字节，所以需要将 0-3 地址内的数据和 4-7 地址里的数据都取出来。
      • 由于 0 - 3 地址范围的 0 地址里的数据不属于我们要读取的数据，因此将这一小块的数据进行移位，把 0 地址里的数据移出去；同理， 4 - 7 地址范围里的数据也要进行移位，保留 4 地址里的数据
      • 合并移位之后的数据，得出结果

      通过上述的分析，我们可以知道内存对齐能够提升性能，这也是我们要进行内存对齐的原因之一。

• 对齐原则

  • 1.结构体各成员变量的内存空间的首地址必须是“对齐系数”和“变量实际长度”中较小者的整数倍。
  • 2.对于结构体来说，在其各个数据都对齐之后，结构体本身也需要对齐，即结构体占用的总大小应该为“对齐系数”和“最大数据长度”中较小值的整数倍。
  • 3.结构体作为成员：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储。

• 在给定了基本原则之后，我们通过一个例子来说明结构体的内存对齐，假定当前的处理器是 32 位的，对齐系数为4。结构体如下：

• 1 2 3 4 5 6 7 8 9 10

  struct data_test { char a; /*本身大小 1 字节*/ short b; /*本身大小 2 字节*/ char c[2]; /*数组单个成员 1 字节*/ double d; /*本身大小 8 字节*/ char e; /*本身大小 1 字节*/ int f; /*本身大小 4 字节*/ char g; /*本身大小 1 字节*/ }data[2];

• 根据我们刚刚给出的第一条对齐原则，先确定出每个变量的存储位置，变量存储方式是小端对齐，为了看起来更加形象，以 16 个字节作为一行来表示变量的存储位置（这里所说的存储位置是指相对于结构体起始地址地偏移）。

• 

• 当结构体数组相邻排列的时候，需要考虑原则2

• 

• 这里需要注意的是，上述原则针对的是结构体占用的总大小，而不是结构体的首地址，所以，在结构体本身还没有对齐的情况下，data[0] 的大小是 25 个字节，但是根据上述原则，在对齐系数为 4 的前提下，结构体大小应该是 4 的整数倍，所以要对结构体进行所占内存进行填充，因此：data[0] 最终的大小是 28 字节,结构体数组 data 的大小为 56 字节

• 1 2 3 4

  默认对齐值： Linux 默认#pragma pack(4) window 默认#pragma pack(8) 可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是指定的“对齐系数”。

六、联合体/共生体变量

• union定义

  1 2 3 4 5 6 7 8 9

  union myUnion{ int i; char ch; float num; double sum; }u; u.i=50; u.ch='a'; u.num=50.26;

• 联合体没有引用，就如上面的不能直接引用u。

• 联合体的每个成员分别占用自己的内存单元，联合体变量所占的内存大小等于最大的成员占用的内存大小。一个联合体变量不能同时存放多个成员的量，某一时刻只能存放一个成员的量，也就是最后赋予它的值。联合体变量的地址和他的各成员地址都是同一地址。

七、枚举类型

• 1 2 3

  enum weekday{ sunday=0,monday=1,tuesday=2,wednesday=3,thursday=4,friday=5,saturday=6 };

• 如果不加=0，默认也是从0开始，但你可以设置从不同的地方开始。

• 声明枚举类型之后，可以用它定义变量

  • 但是枚举变量只能是枚举类型大括号里面的成员；

    1 2 3 4 5 6 7 8 9 10 11 12

    enum weekday { sunday, monday, tuesday, wednesday, thursday, friday, saturday }; weekday d = saturday; cout << d << endl;

  • 一个整数不能给枚举类型赋值。

    1 2	//但是以下是错误的 weekday dd=2;

八、面向对象OO

• Object Oriented
• 面向对象编程OOP——Object Oriented Progarmming
• 特点：
  • 封装
  • 继承
  • 多态

九、网络通信

• 1.OSI参考模型

  Open System Interconnection——开放式系统互联，分为七层结构

  • 第一层：物理层
  • 第二层：数据链路层
  • 第三层：网络层
  • 第四层：传输层
  • 第五层：会话层
  • 第六层：表示层
  • 第七层：应用层

• 2.TCP/IP参考模型

  分为四层结构：

  • 第一层：数据链路层
  • 第二层：网络层
  • 第三层：传输层
  • 第四层：应用层

• 3.IP地址

• 4.数据包格式

  • 4.1 IP数据包
  • 4.2 TCP数据包
  • 4.3 UDP数据包
  • 4.4 ICMP数据包

• 5.套接字

  套接字实际上是一个指向传输提供者的句柄，可分为以下三种：

  • 原始套接字：接收数据有IP头，在WinSock2规范提出；
  • 流式套接字：TCP，面向连接，可靠；
  • 数据包套接字：UDP，无连接，不可靠。

  windows提供的套接字简称为WinSock。

十、C++ Primier学习笔记

chap2 变量和基本类型

• 类型转换

  • 非布尔转为布尔：0为false，其他为true
  • 布尔转为非布尔：false为0，true为1
  • 浮点数转为整数：省去小数部分
  • 整数转为浮点数：小数部分为0，超出范围有精度损失
  • 赋予无符号类型超出表示范围的值时，结果是值对无符号类型总数取模后的余数
  • 赋予有符号类型超出表示范围的值时，结果是未定义undefined

• 无符号类型不会小于0，关系到循环的写法

  • 当存在有符号和无符号数时，有符号会转化为无符号数

• 1 2 3 4 5 6

  024 //八进制 0x24 //十六进制 24 //十进制 \r //回车，光标回到行首 \n //换行，光标下一行 \t //tab，制表

• 局部作用域变量允许重定义全局变量，并且隐式覆盖了全局变量，要调用全局变量，要么局部作用域没有同名的变量，要么加全局作用域符::，例如::reused

• 引用reference

  1 2 3 4 5 6 7 8 9

  //一般我们说的都是左值引用，在变量左边加&。其实还有右值引用，后讲 //引用不能用于定义变量，引用只是变量的别名 //引用必须初始化 int i=1024; int &j=i;//j是i的引用 int &z;//错误，引用必须初始化 //空指针nullptr int *poi=nullptr; //NULL也可以，但nullptr是c11的新标准 等于 int *poi=0;

• 指针pointer

  • 在条件表达式里面，如果为空指针（即指针的值为0），为false，其他为true

  1 2 3 4 5

  //注意指针类型和对象类型的一致性 int *p; int i=50; p=&i; *p=5;

• 1 2 3

  /*对于& *来讲 前面有类型名，就是声明，即作为引用或指针 不紧随类型名出现，就是操作符，即取地址和解引用

• void *指针

  一种特殊的指针类型，可以存放任意类型对象的地址

• 指向指针的指针

  1 2 3

  int val=5; int *p=&val; int **pi=&p;

• 指向指针的引用

  引用本身不是一个对象，因此不能定义指向引用的指针，但是可以定义指向指针的引用。

  从右往左阅读r的定义，离r越近的符号对r有最直接的影响，即r是一个引用。

  1 2 3

  int i=45; int *p; int *&r=p;//r是对指针p的引用

• const常量和const引用

  1 2 3 4 5 6 7 8 9

  //对const的引用，即指向常量的引用，简称为常量引用 const int &r1=42; //常量引用可以引用非const类型 //但const的引用只能是常量引用 int i=50; const int &r2=i;//正确 int &r3=r2*2;//错误

• 指针和const

  • 指向常量的指针（类似常量引用）

  1 2 3 4 5

  //指向常量的指针，指针可变，可指向const或者普通类型，但同时const的指针只能是指向常量的指针，和常量引用类似。当指向const时，即为底层const。 const int ci=45; const int *p2=&ci;//底层const int c3=42; p2=&c3;//可以指向普通类型，同时p2可变

  • 常量指针，const指针

    与命名符最近的是const，所以是常量，然后才是指针，即这个指针的地址不可变，但这不意味着不能通过指针修改其所指对象的值，能否这样做完全依赖该常量指针所指的对象是否为const类型，是则不能更改。

    1 2	int err=0; int *const durRrr=&err;//顶层const

  • 用顶层const表示指针本身是常量，即常量指针；

    用底层const表示指针所指的对象是一个常量，即指向常量的指针。

• constexpr变量

  • 使得变量为常量

  • 常见误区

    1 2	const int *p=nullptr;//p是指向常量int的指针 constexpr int *q=nullptr;//q是指向int的常量指针, 等于int *const q

• 类型别名和指针常量的误区

  • using 、typedef

    1 2	typedef double wages; using SI=Sales_items;

  • 误区，使用了typedef后与顶层const不一样

    1 2 3

    typedef char *pstring;//此处的*是声明符 const pstring cstr=0;//cstr是指向char的常量指针，切记！！！ const pstring *ps;//ps是一个指针，他的对象是指向char的常量指针。

• auto和decltype

  • auto：自动分析表达式的类型，一般使用在lambda表达式里面，auto &a, 一般传入引用
  • decltype：选择并返回操作数的数据类型。

• struct

• 预编译

chap3 字符串、向量和数组

• 1 2	#include <iostream> using namespace std;

• 头文件不应包含using，一般在cpp内使用

• string可变字符串

  • size_type（一般是无符号）

  • 1 2 3 4

    string str("some"); for (auto c:str){ cout<<c<<endl; }

• vector向量

  • 不能用下标添加数据（Opencv的mat类可以）
  • 但可以在原元素上用下标进行修改，即内存本身已经存在了。

• size_type（一般是无符号）

  • 初始化
    • vector< T> v3(n,value)
    • vector< T> v3{a,b,c...}
    • vector< T> v3=v2

  1 2 3 4 5 6 7 8 9 10

  vector<int> v; v.size();//类型为size_type//无符号 v.empty(); v.push_back(t); // vector<int> v{1,2,3,4,5}; for (auto &i:v){ i*=i;//i是引用 }

• 迭代器

  • 习惯使用!=和==判断条件。因为不是所有的迭代器都有<的运算

  • iterator

  • *it返回迭代器it所指元素、对象的引用。

  • ++iterator

  • --iterator

  • 1 2 3

    for (auto it=s.begin();it!=s.end(),++i){ *it=toupper(*it); }

• 数组

  • 数组的长度必须是常量表达式（尽管有些编译器允许非常量，但为了保险，还是用常量）

    1 2	constexpr unsigned sz=42; int *pz[sz];

  • 不允许拷贝和赋值——与vector不一样。

  • 数组下标的类型是size_t，一种和机器相关的无符号类型

  • 1 2 3 4

    unsigned scores[11]={}; for (auto i:scores){ cout<<i<<endl; }

  • 1 2 3 4 5 6 7 8 9 10 11 12 13

    /* 现有数组a[10]; 数组名a： 数组名可以作为数组第一个元素的指针。我们由数组和指针的关系知道，a代表这个地址数值，它相当于一个指针，指向第一个元素（&a[0])，即指向数组的首地址。数组中的其他元素可以通过a的位移得到，此时的进阶是以数组中单个的元素类型为单位的，即a+i= & a[i]。 数组名取地址&a： 对于一个普通的变量b，&b是指用取地址符号取得变量b的存放地址；a在内存中没有分配空间，只对数组a的各个元素分配了存储空间，此处数组名字a显然不是普通的变量，&a也不代表所取a的存储地址。 &a在数值上等于&a[0]，也等于a。此时，&a数值上等于整个数组的起始位置地址，含义上代表整个数组所占内存的大小，因为它的进阶单位是整个数组的字节长度，（&a + 1）等于的是数组结束之后的下一段的起始位置地址。 数组首地址&a[0]： 这个就是取地址的最直接的应用，a[0]在内存中实际分类存储空间，而&a[0]就是取该存储空间的地址，这与对于任意满足范围的i，&a[i]就是取第i个元素的存储地址一样。 */

  • 数组指针也是迭代器

    1 2 3 4 5 6 7

    int a[]={0,1,2,3,4}; int *beg=begin(a); int *en=end(a); while(beg!=en){ cout<<*beg<<endl; ++beg; }

• string和C风格字符串

  1 2 3 4 5 6

  //C风格字符串 const char ca[]={'h','e','l','l','o'}; const char *cap=ca; //转换 string s("hello!"); const char *str=s.c_str();

chap4 表达式

• sizeof()：返回字节数

• 位操作

• 条件运算符 ?:

• 类型转换

  • 隐式转换

  • 强制转换

    • static_cast
    • const_cast
    • dynamic_cast
    • reinterpret_cast

  • 1	double slope=static_cast<double>(j)/i;

chap5 语句

• if
• 传统for
• 范围for语句
• do while语句：无论条件，都会先执行一次
• while语句
• switch case default break
• break语句：终止离他最近的while、do while 、for、 switch语句，并执行下一语句。
• continue语句：终止本次迭代，开始下一次迭代
• goto语句：无条件跳转本函数其他语句，尽量不用
• throw
• try catch

chap6 函数

• 函数参数

  • 传值形参
  • 指针传参：两个指针不一样，但指向同一个对象
  • 引用传参：避免拷贝

• 数组形参

  • 实际传递的是第一个元素的地址，同时应传递数组大小的形参
  • P194三种管理形参的方式

• 数组引用形参

  1	void print(int (&arr)[10]);

• return返回值

  • 不要返回局部变量的引用和指针
  • 返回数组指针

函数指针

• 可以利用typedef进行函数指针的重命名

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  #include <iostream> #include <iomanip> typedef int (*pfun)(int, int);//此时pfun是一种类型 using namespace std; int avg(int a, int b) { return int((a + b) / 2); } int main() { pfun PFUN;//PFUN是一个变量 int a = 50; int b = 60; int ret, ret2; int (*pFun)(int, int); pFun = avg; PFUN = avg; ret = (*pFun)(a, b); ret2 = (*PFUN)(a, b); cout << "ret=" << ret << endl; cout << "ret2=" << ret2 << endl; return 0; }

• 

• 函数名本身就是指针，编译器在调用函数指针的时候会直接把函数名转为函数指针，而且直接不加(*p)用函数指针调用函数也可以

• 1 2 3 4 5 6 7 8 9 10 11 12 13

  #include <bits/stdc++.h> using namespace std; typedef int (*p1)(int, int); int add(int a, int b) { return a + b; } int main() { p1 ss1 = add; p1 ss2 = &add;//两个地址是一样的 cout<<ss1(1,2)<<endl; cout<<(*ss2)(3,4)<<endl;//都可以调用 return 0; }

• 

• void (*signal(int sig, void(*func)(int)))(int); 如何理解

• 可以看成是一个signal()函数，它自己是带两个参数(一个为整型,一个为函数指针)，而这个signal()函数的返回值也为一个函数指针；这个函数指针指向一个带一个整型参数并且返回值为void的一个函数。

• 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

  //函数定义： #include <iostream> using namespace std; typedef void(*f_ptr)();//f_ptr是一个类型，函数指针 void aaa() { cout << "check out" << endl; } // void (* f())() f_ptr f() //返回值是函数指针的函数定义， 语义一目了然 { return aaa; } int main() { // void (*(*f_ptr)())() = f; // f_ptr()(); f_ptr(*ff)() = f; //返回函数指针的函数指针 ff()(); return 0; } /* *输出 *check out **/

chap7 类

• 1.数据成员初始化

  • c++17之后支持直接赋值初始化

  • 默认构造函数初始化

  • 带参数的构造函数初始化

  • 初始化列表

    1 2 3 4 5 6 7

    class foo{ public: foo(string s, int i):name(s),id(i){};//初始化列表 private: string name; int id; };

• 2.const成员变量

  • const 成员变量的用法和普通 const 变量的用法相似，只需要在声明时加上 const 关键字
  • 初始化 const 成员变量只有一种方法，就是通过构造函数的初始化列表。

• 3.const成员函数

  • const加在小括号后面花括号前面。

  • const 成员函数可以使用类中的所有成员变量，但是不能修改它们的值，这种措施主要还是为了保护数据而设置的。const 成员函数也称为常成员函数。

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

    class Student{ public: Student(char *name, int age, float score); void show(); //声明常成员函数 char *getname() const; int getage() const; float getscore() const; private: char *m_name; int m_age; 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; } //定义常成员函数 char * Student::getname() const{ return m_name; } int Student::getage() const{ return m_age; } float Student::getscore() const{ return m_score; }

  • 必须在成员函数的声明和定义处同时加上 const 关键字。char *getname() const和char *getname()是两个不同的函数原型，如果只在一个地方加 const 会导致声明和定义处的函数原型冲突。

  • 注意是在函数尾部加const，此时才表示是常成员函数；

  • 如果是在函数头部加const，表示返回的是常量。

• 4.拷贝构造函数

  • 拷贝构造函数的参数是一个已经初始化的类对象

  • 输入参数为常量左值引用

  • 1 2 3 4 5

    CPerson::CPerson(const CPerson &copyPerson){ m_iIndex=copyPerson.m_iIndex; m_age=copyPerson.m_age; m_salary=copyPerson.m_salary; }

  • 以上只是示例，实际上成员数据一般设置为private，并不可以直接访问得到。

• 5.析构函数

• 6.普通成员函数

• 7.内联成员函数

• 8.静态数据成员

  • 定义静态数据成员通常在类的外部进行初始化

  • 类和类的对象都可以直接访问同一个静态数据成员

  • 静态数据成员可以作为普通成员函数的默认参数，但是普通数据成员不可以

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

    #include <iostream> #include <iomanip> using namespace std; class MyClass { private: /* data */ static int data; public: MyClass(/* args */); ~MyClass(); void change(int param); }; int MyClass::data = 50; void MyClass::change(int param) { cout << "change forward: " << data << endl; data = param; cout << "change later: " << data << endl; } MyClass::MyClass(/* args */) { } MyClass::~MyClass() { } int main() { MyClass p1; p1.change(20); p1.change(80); MyClass p2; p2.change(15); p1.change(25); return 0; }

  • 

• 9.静态成员函数

  • 静态成员函数只能访问类的静态数据成员，不能访问普通的数据成员

  • 在函数前加static修饰

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

    class MyClass { private: static int data; public: MyClass(); ~MyClass(); static void show_static(); //静态成员函数 void change(int param); }; int MyClass::data = 50; //定义的时候不用加static void MyClass::show_static() { cout << data << endl; }

• 10.this指针

• 11.友元函数

  • 可以使得普通函数具备类似成员函数一样的能力访问private、protected成员数据。

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

    #include <iostream> #include <iomanip> using namespace std; class MyFriClass { private: int width; int height; public: MyFriClass(int a, int b); ~MyFriClass(); //设置全局函数 friend void calc_area(const MyFriClass &friendclass); }; void calc_area(const MyFriClass &friendclass) { cout << "area= " << friendclass.width * friendclass.height << endl; } MyFriClass::MyFriClass(int a, int b) { width = a; height = b; } MyFriClass::~MyFriClass() { } int main() { MyFriClass p1(25,20); calc_area(p1); return 0; }

  • 

• 12.友元类和友元方法

  • 类的私有数据和函数只有该类可以访问，但有时候当其他类也可以访问该类的私有数据时，可以提高很大的效率和便利。

  • 为此，C++提供了友元类和友元函数。

  • 当用户希望一个类A可以完全访问另外一个类B时，可以将类A设置为类B的友元类

    1 2 3 4 5 6 7 8 9

    class A{ ... }; class B{ private: ... public: friend class A;//A可以访问B的私有部分 };

  • 当用户希望一个类A的成员函数可以完全访问另外一个类B时，可以将类A的成员函数设置为类B的友元函数

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

    //注意点：类A应该先定义，但是类B要先声明 #include <iostream> #include <iomanip> using namespace std; //必须将先定义的类的成员函数作为后定义类的友元函数，调换顺序会出现语法错误 class CItem;//类B class CList//类A { private: CItem *m_pItem; public: CList(); ~CList(); void OutputItem(); }; class CItem { friend void CList::OutputItem(); private: int data; public: CItem(int input); ~CItem(); }; CItem::CItem(int input) { data = input; } CItem::~CItem() { } CList::CList() { m_pItem = new CItem(55); } CList::~CList() { delete m_pItem; m_pItem = nullptr; } void CList::OutputItem() { cout << "item data:" << m_pItem->data << endl; } int main() { CList P1; P1.OutputItem(); return 0; }

    

• 13.命名空间

chap8 继承和派生

• 1.访问权限

• 继承方式	基类的public成员	基类的protected成员	基类的private成员	继承引起的访问控制关系概括
  public继承	仍为派生类的public成员	仍为派生类的protected成员	派生类不可见	基类的非私有成员在子类的访问属性不变，私有成员不可访问
  protected继承	变为派生类的protected成员	变为派生类的protected成员	派生类不可见	基类的非私有成员成为子类的保护成员，私有成员不可访问
  private继承	变为派生类的private成员	变为派生类的private成员	派生类不可见	基类的非私有成员成为子类的私有成员，私有成员不可访问

• 2.总结

  1 2 3 4 5 6

  1. 基类的 private 成员在派生类中是不能被访问的,如果基类成员不想在类外直接被访问,但需要在派生类中能访问,就定义为 protected 。可以看出保护成员限定符是因继承才出现的。 2. public继承是一个接口继承,保持is-a原则,每个父类可用的成员对子类也可用,因为每个子类对象也都是一个父类对象。 3. protetced/private继承是一个实现继承,基类的部分成员并非完全成为子类接口的一部分,是 has-a 的关系原则,所以非特殊情况下不会使用这两种继承关系,在绝大多数的场景下使用的都是公有继承。 4. 不管是哪种继承方式,在派生类内部都可以访问基类的公有成员和保护成员,基类的私有成员存在但是在子类中不可见(不能访问)。 5. 使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public,不过最好显示的写出继承方式。 6. 在实际运用中一般使用都是public继承,极少场景下才会使用protetced/private继承。

• 3.继承关系中构造函数调用顺序

  • 3.1调用基类构造函数——按照继承列表中的顺序调用

  • 3.2调用派生类中的类成员对象的构造函数——按照在派生类中的成员对象说明顺序调用

  • 3.3调用派生类本身的构造函数

  • 注意点：创建子类对象时，无论调用的是那种子类的构造函数，都会自动调用父类默认的无参构造函数；若想使用父类带参数的构造函数，则需要通过显式的方法调用

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

    #include <iostream> #include <iomanip> using namespace std; class CEmploy { private: int data; public: CEmploy(/* args */); CEmploy(char name[]); ~CEmploy(); }; CEmploy::CEmploy(char name[]) { cout << name << "调用基类带参构造函数" << endl; } CEmploy::CEmploy(/* args */) { cout << "调用基类默认构造函数" << endl; } CEmploy::~CEmploy() { } class COperator : public CEmploy { private: /* data */ public: COperator(/* args */); COperator(char name[]); ~COperator(); }; COperator::COperator(/* args */) { cout << "调用派生类默认构造函数" << endl; } //显式调用基类带参构造函数 COperator::COperator(char name[]) : CEmploy(name) { cout << name << "调用派生类带参构造函数" << endl; } COperator::~COperator() { } int main() { COperator p1; char str2[] = "Jack"; COperator p2(str2); return 0; }

  • 

• 4.继承关系中析构函数调用过程

  • 4.1调用派生类的析构函数
  • 4.2调用派生类中的类成员对象的析构函数——与派生类中的成员对象说明顺序相反
  • 4.3调用基类析构函数——与继承列表中的顺序相反

• 5.子类定义了一个和父类一样的函数，那么子类调用的是子类自己的成员函数；如果要调用父类的成员函数，则需要显式调用。

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

    #include <iostream> #include <iomanip> using namespace std; class CEmploy { private: int data; public: CEmploy(/* args */); CEmploy(char name[]); ~CEmploy(); void test_fun(int input); }; void CEmploy::test_fun(int input) { cout << "父类函数" << input << endl; } CEmploy::CEmploy(char name[]) { cout << name << "调用基类带参构造函数" << endl; } CEmploy::CEmploy(/* args */) { cout << "调用基类默认构造函数" << endl; } CEmploy::~CEmploy() { } class COperator : public CEmploy { private: /* data */ public: COperator(/* args */); COperator(char name[]); ~COperator(); void test_fun(int input); }; void COperator::test_fun(int input) { cout << "子类函数" << input << endl; } COperator::COperator(/* args */) { cout << "调用派生类默认构造函数" << endl; } COperator::COperator(char name[]) : CEmploy(name) { cout << name << "调用派生类带参构造函数" << endl; } COperator::~COperator() { } int main() { COperator p1; char str2[] = "Jack"; COperator p2(str2); p1.test_fun(50); p2.CEmploy::test_fun(50); return 0; }

  • 

• 6.重载运算符

  • operator 类型名（输入参数）

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

    #include <iostream> #include <iomanip> using namespace std; class COperator_check { private: public: int data; public: COperator_check(/* args */); COperator_check(const int input); //运算符重载 COperator_check operator+(COperator_check a) { return COperator_check(data + a.data); } void inshow(); ~COperator_check(); }; void COperator_check::inshow() { cout << data << endl; } COperator_check::COperator_check(const int input) { data = input; } COperator_check::COperator_check(/* args */) { } COperator_check::~COperator_check() { } int main() { COperator_check p1(50), p2(60); COperator_check p3 = p1 + p2; p3.inshow(); return 0; }

  • 

• 7.多重继承

  • 多重继承的基类构造函数被调用顺序安装类派生表中声明的顺序为准。

• 8.函数重载和虚函数的区别

  • 8.1.函数重载可以用于非成员函数和类的成员函数，而虚函数只能用于类的成员函数。
  • 8.2.函数重载可用于构造函数，而虚函数不能用于构造函数。
  • 8.3.如果对成员函数进行重载，重载的函数与被重载的函数应该是用一个类中的成员函数，不能分属于两个不同继承层次的类，函数重载处理的是横向的重载。虚函数是对同一类族中的基类和派生类的同名函数的处理，即允许在派生类中对基类的成员函数重新定义。虚函数处理的是纵向的同名函数。
  • 8.4.重载的函数必须具有相同的函数名，函数类型可以相同也可以不同，但函数的参数个数和参数类型二者中至少有一个不同，否则在编译时无法区分。而虚函数则要求同一类族中的所有虚函数的函数名，函数类型，函数的参数个数和参数类型都全部相同，否则就不是重定义了，也就不是虚函数了。
  • 8.5.函数重载是在程序编译阶段确定操作的对象的，属于静态关联。虚函数是在程序运行阶段确定操作对象的，属于动态关联。

• 9.虚函数

  • 只有类的成员函数才能是虚函数；

  • 静态成员函数不能是虚函数，因为静态成员函数不受限于某个对象；

  • 内联函数不能是虚函数，因为内联函数是不能在运行中动态确定位置的；

  • 构造函数不能是虚函数，析构函数通常是虚函数；

  • 基类函数头加virtual，派生类函数尾部加override。

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

    #include <iostream> #include <iomanip> using namespace std; class baseClass { private: /* data */ public: virtual void Outname(); baseClass(/* args */); ~baseClass(); }; void baseClass::Outname() { cout << "这是基类的虚函数" << endl; } baseClass::baseClass(/* args */) { } baseClass::~baseClass() { } class sonClass : public baseClass { private: /* data */ public: //虚函数重写 void Outname() override; sonClass(/* args */); ~sonClass(); }; void sonClass::Outname() { cout << "这是子类虚函数" << endl; } sonClass::sonClass(/* args */) { } sonClass::~sonClass() { } int main() { sonClass p1; p1.Outname(); return 0; }

  • 

• 10.虚继承

  • 虚继承在一般的应用中很少用到，所以也往往被忽视，这也主要是因为在C++中，多重继承是不推荐的，也并不常用，而一旦离开了多重继承，虚继承就完全失去了存在的必要。

  • 虚继承：在继承定义中包含了virtual关键字的继承关系。

  • 不加虚继承，会多次调用基类的公共构造函数

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

    #include <iostream> #include <iomanip> using namespace std; class CAnimal { private: /* data */ public: CAnimal(/* args */); ~CAnimal(); }; CAnimal::CAnimal(/* args */) { cout << "动物类被构造" << endl; } CAnimal::~CAnimal() { } class CBird : public CAnimal { private: /* data */ public: CBird(/* args */); ~CBird(); }; CBird::CBird(/* args */) { cout << "鸟类被构造" << endl; } CBird::~CBird() { } class CFish : public CAnimal { private: /* data */ public: CFish(/* args */); ~CFish(); }; CFish::CFish(/* args */) { cout << "鱼类被构造" << endl; } CFish::~CFish() { } class CWaterBird : public CBird, public CFish { private: /* data */ public: CWaterBird(/* args */); ~CWaterBird(); }; CWaterBird::CWaterBird(/* args */) { cout << "水鸟类被构造" << endl; } CWaterBird::~CWaterBird() { } int main() { CWaterBird p1; return 0; }

    

  • 加上虚继承，只调用一次公共构造函数

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

    #include <iostream> #include <iomanip> using namespace std; class CAnimal { private: /* data */ public: CAnimal(/* args */); ~CAnimal(); }; CAnimal::CAnimal(/* args */) { cout << "动物类被构造" << endl; } CAnimal::~CAnimal() { } //虚继承 class CBird : virtual public CAnimal { private: /* data */ public: CBird(/* args */); ~CBird(); }; CBird::CBird(/* args */) { cout << "鸟类被构造" << endl; } CBird::~CBird() { } //虚继承 class CFish : virtual public CAnimal { private: /* data */ public: CFish(/* args */); ~CFish(); }; CFish::CFish(/* args */) { cout << "鱼类被构造" << endl; } CFish::~CFish() { } class CWaterBird : public CBird, public CFish { private: /* data */ public: CWaterBird(/* args */); ~CWaterBird(); }; CWaterBird::CWaterBird(/* args */) { cout << "水鸟类被构造" << endl; } CWaterBird::~CWaterBird() { } int main() { CWaterBird p1; return 0; }

    

• 11.抽象类和纯虚函数

  • 包含纯虚函数的类称为抽象类，一个抽象类至少有一个纯虚函数。

  • 抽象类不能被实例化，但是可以使用指向抽象类的指针。

  • 纯虚函数不能被继承，抽象类的派生类必须给出纯虚函数的定义。

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

    #include <iostream> #include <iomanip> using namespace std; class CFigure { private: /* data */ public: CFigure(/* args */); ~CFigure(); //定义纯虚函数 virtual double get_area() = 0; }; CFigure::CFigure(/* args */) { } CFigure::~CFigure() { } class CCircle : public CFigure { private: double radius; public: CCircle(double input); //重写纯虚函数 double get_area(); ~CCircle(); }; CCircle::CCircle(double input) { radius = input; } double CCircle::get_area() { return radius * radius * 3.14; } CCircle::~CCircle() { } int main() { CFigure *p1; p1 = new CCircle(55.5); double are = p1->get_area(); cout << are << "面积" << endl; return 0; }

  • 

• 12.关于虚函数实现多态

  • 需要满足三个条件
    • 类满足赋值兼容规则，即公有继承
    • 声明虚函数
    • 只能通过指针或引用访问虚函数。若通过对象实体，是静态绑定，无法正确调用虚函数。