北京大学：C++程序设计 课堂笔记

介绍

北京大学程序设计与算法系列之C++程序设计，视频：Coursera、哔哩哔哩。

说明

本课堂笔记目的是方便自己和大家复习以及查阅使用，所以课件内容偏多，请见谅。如有修改意见，欢迎大家提出。

C++程序设计

P3 01 :函数指针

1. 定义： 类型名( 指针变量名)(参数类型1， 参数类型2， …)*
   例如：int (*pf)(int, char)
2. 使用：函数指针名(实参表)
   例如：pf = PrintMin; pf(x, y);
3. 应用：C快速排序任意类型数组：qsort库函数
   void qsort(void *base, int nelem, unsigned int width, int(* pfCompare)(const void *, const void *)
   函数需要以下四个参数：
   1. 数组的起始地址：base
   2. 数组元素个数：nelem
   3. 数组元素大小：width
   4. 排序前后规则：int(* pfCompare)(a, b)
      其中，返回值包含以下三种情况：
      • 负整数：a在前，b在后；
      • 0：哪个参数在前都可以；
      • 正整数：a在后， b在前。

• 课件
  • 如下：

P4 02 命令行参数

命令行程序示例：

> notepad sample.txt
> copy file1.txt file2.txt

实现方式：

int main(int argc, char * argv[])
{
	...
}

其中，argc：命令行参数的个数。由于可执行程序本身的文件名也计算在内，故argc大于等于1。而argv[]是一个指针数组，argv[0]:可执行文件名；argv[1]:第2个命令行参数；以此类推。
注：某一命令行参数如果有空格，可用双引号括起。

• 课件
  • 如下：
    

P5 03 位运算

位运算符包括：

1. &：按位与
2. |：按位或
3. ^：按位异或
4. ～：按位非（取反）
5. <<：按位左移
6. >>：按位右移

&：按位与运算

用途：

1. 变量中的某位置清0，且同时保留其他位不变。
   例如：int型变量n，使其低8位置0，其他位不变：
   n = n & 0xffffff00;
   或者：n &= 0xffffff00;
   若n为short型(16位)，则n &= 0xff00
2. 获取变量中的某一位。
   例如：判断n第7位是否为1（从右往左，从0开始）：
   判断n & 0x80是否等于0x80，因为0x80 == 1000 0000。

|：按位或运算

用途：

1. 变量中的某位置置1，且同时保留其他位不变。
   例如：int型变量n，使其低8位置1，其他位不变：
   n |= 0xff;

^：按位异或运算

用途：

1. 变量中的某位置取反，且同时保留其他位不变。
   例如：int型变量n，使其低8位取反，其他位不变：
   n ^= 0xff;
   特点：由a ^ b = c可得：c ^ b = a以及c ^ a = b
   因此按位异或运算可用作简单的加密和解密。
2. 不通过临时变量，交换两个变量的值。

int a = 5, b = 7;
a = a ^ b;
b = b ^ a;
a = a ^ b;

~：按位非运算

用途：pass.

<<：按位左移运算

含义：a << b:将a按位左移b位。
性质：高位丢弃，低位补0；a的值不会因此改变。
左移n位，相当于乘以2ⁿ。但是左移运算比乘法运算快得多。

>>：按位右移运算

含义：a >> b:将a按位右移b位。
性质：低位丢弃，高位补0；a的值不会因此改变。

有符号数，如long, int, short, char 类型，符号位（最高位）一起移动。大多数编译器规定，如果原符号位为1，则右移时高位就补充1；原符号位为0，则右移时高位就补充0。

右移n位，相当于除以2ⁿ，并将结果往小里取整。例如

-25 >> 4 = -2
-2 >> 4 = -1
18 >> 4 = 1

注：负数转化成二进制：以补码形式表示，即先按正数转换，然后取反加1。

• 课件
  • 如下：
    

P6 04 引用

形式：类型名 & 引用名 = 某个变量名
例如：

int n = 4;
int & r = n;   // r 引用了 n, r 类型是 int &

含义：某个变量的引用，等价于这个变量，相当该变量的一个别名。

• 课件
  • 如下：
    

P7 05 const 关键字和常量

• 要点：
  1. 避免使用define, 因为const有类型方便检查。
• 课件
  • 如下：
    
    错误1：不可通过常量指针修改其指向的内容；错误2：strcpy()的第一个参数类型为char *，而p为const char *，不能将const char *类型的指针赋给char *类型。
    

P8 06 动态内存分配

• 要点：
  1. C语言：通过malloc分配内存。C++：new关键字实现动态分配内存。
  2. 分配变量：P = new T;，其中T为任意类型名。
  3. 分配数组：P = new T[N];
• 课件
  • 如下：
    

P9 07 内联函数和重载函数

内联函数：不用栈调用，直接贴到主程序。
优点：加快程序运行。
缺点：导致可执行程序体积过大。

重载函数：名字相同，参数表不同。

• 课件
  • 如下：

P10 08 函数缺省参数

• 课件
  • 如下：
    
    

P11 09 面向对象程序设计

• 结构化程序设计的弊端
• 课件
  • 如下：
    
    
  • 面向对象程序设计
    含义：类，相当于模板。
    

P12 10 面向对象语言发展历程

• 课件
  • 如下：
    

P13 11 从客观事物抽象出类的例子

• 实例化对象
• 类成员的访问：

1. 对象名.成员名
2. 指针->成员名
3. 引用名.成员名

• 课件
  • 如下：
    实例化过程：
    
    注：函数形参里的 &r 去掉不影响结果输出，但效率低。
    
    

P14 12 类成员的可访问范围

• 要点：

  1. 缺省类型的成员为私有成员，即未明确可访问类型的变量。
  2. 类的公有成员函数内部的私有变量是可以访问到的。
  3. 类的私有成员变量只能由类的成员函数访问。原因之一：方便修改。

• 课件

  • 如下：
    
    

P15 01 内联成员函数和重载成员函数

• 要点：

  1. 内联函数的设计目的：单独一个函数语句少的情况下，反复调用，开销大。
  2. 参数缺省的目的：提高程序的可扩展性。添加新的函数时，不需要的参数可直接用默认值。

• 课件

  • 如下：
    

P16 02 构造函数（constructor）

• 要点：

  1. 构造函数的目的：对象初始化
  2. 它不分配存储空间，而是在已经分配空间之后做初始化的工作。例如：盖房子，房子是一个对象，构造函数仅仅是在房子盖好之后进行装修。
  3. 对象生成时一定会调用构造函数。
  4. 对象一定要初始化在使用。

• 课件：

  • 如下
    注：pArray[3]是 指针数组，不是对象数组，它的每一个元素都是指针，可以不初始化，因此，它不会引发对象生成。指针只表示指示作用，所以不会导致指示的对象生成构造函数。此时，对前两个指针初始化，new的返回值类型为Test *。

P17 03 复制构造函数

• 要点：

  1. 把某一对象C1的成员变量复制到另一对象C2，即复制品。
  2. 复制构造函数被调用的三种方式：
     1. 一个对象去初始化另一个对象；
     2. 函数参数是类A的对象
     3. 函数返回值是类A的对象

• 课件

  • 如下：
    注：C++的标准不允许复制构造函数传值参数，否则会编译出错。因为是传值参数，我们把形参复制到实参会调用复制构造函数。如果允许复制构造函数传值，就会在复制构造函数内调用复制构造函数，就会形成永无休止的递归调用从而导致栈溢出。(来自：剑指offer)
    
    注：复制构造函数的作用：复制一个对象的成员变量给另一对象。

  void Func(Complex1 a1){}		//	会调用复制构造函数，如同值传递
  void Func(Complex1 & a1){}		//	对象引用，不会调用复制构造函数，如同地址传递
  void Func(const Complex1 a1){}	//	会调用复制构造函数，不允许修改。
  void Func(const Complex1 & a1){}//	常对象引用，不会调用复制构造函数，不允许修改，如同地址传递
  

  博客C++构造函数详解（复制构造函数）是这么说的：复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中。 注：（来自B站评论）不管是返回一个类对象还是传入类对象作为参数，这个类对象不再是类对象，而是调用了以这个类对象作为参数的复制构造函数。即非引用类型的对象作为形参或是函数返回值时，在调用函数过程都会初始化同类型的对象，因此都会调用复制构造函数。
  

P18 04 类型转换构造函数

• 要点：
  1. 适用于解决两边类型不一致的情况。
• 课件
  • 如下：
    注：Complex c2 = 9;中的等号=代表初始化，并非赋值。在调用类型转换构造函数时不会生成临时对象。而c1 = 9;为赋值语句，等号两端为不同类型，相当于以9作为实参调用类型转换构造函数Complex (int i)，生成一个临时Complex对象赋值给c1。

P19 05 析构函数

• 要点：
  1. 在对象销毁时调用，与构造函数相对应。
• 课件
  • 如下：
    
    注：构造函数和析构函数的调用时机
  1. d4 = 6;：调用类型转换构造函数，生成临时对象。
  2. {}：代表作用域，相当于生命周期。
  3. 静态变量在整个函数结束时消亡。
  4. 析构函数释放顺序：局部变量->静态变量->全局变量
     

P20 06 静态成员变量和静态成员函数

• 要点：
  1. 静态成员变量和函数，相当于该类的全局变量和函数。
  2. 静态成员函数中不能包含非静态变量和函数。
  3. 静态成员，实际上不放在成员内部，而是放在所有成员的外面，被所有对象共享。即静态成员只与该类相关，与其他变量和成员基本上没有关系。
• 课件
  • 如下：
    注：复制构造函数，与所有构造函数享有同等权利。

P21 07 成员对象和封闭类

• 要点：
  1. 成员变量(形参)，等价于成员变量=形参。括号()相当于赋值操作。
  2. 成员对象(形参1，形参2)，等价于通过形参1和2来初始化该成员对象。具体看下面的例子。
  3. 封闭类的构造函数后跟有冒号：和成员变量的参数表。
• 课件
  • 如下：
    注：封闭类构造和析构的调用顺序：先构造的后析构；后构造的先析构。类似栈实现。构造函数：成员对象->封闭类。析构函数：封闭类->成员对象。

P22 08 友元（Friend）

• 要点：
  1. 友元函数和友元类
• 课件
  • 如下：
    

P23 09 this指针

• 要点：
  1. this指针可以理解为C++程序转换为C程序所用到的指针。
• 课件
  • 如下：
    注：C++转换成C，利用C编译器编译。因此，C++的class对应于C的结构体struct,又由于C无成员函数，故C需要定义全局函数，其全局函数的参数相比较于C++成员函数要多一个形参，即this指针，它指向C++中成员函数所作用的对象，在C中即为结构体变量。
    

P24 10 常量对象，常量成员函数和常引用

• 要点：
  1. const：保证其限定的成分不被修改。
  2. 常引用：对象的引用作为函数参数，不是对象，因此不会引发复制构造函数。而声明为常引用，确保形参不会修改原始值，既保证效率，又保证数据安全。
• 课件
  • 如下：
    

P25 01 运算符重载

• 要点：
  1. 注意重载成普通函数和成员函数的区别。
• 课件
  • 如下：
    

P26 02 赋值运算符重载（浅拷贝与深拷贝）

• 要点：
  1. 赋值=重载解决的问题：c1 = c2;等号两端类型不匹配。
  2. 运算符重载可通过重载为成员函数和普通函数来实现。但赋值运算符只可重载为成员函数。
• 课件
  • 如下：
    注：String s2 = "hello!"非赋值语句，而是初始化，它不会调用s2.operator=()成员函数，而是会调用String(char *)构造函数。
    注：S1 = S2;两者指向同一块地址。S1和S2消亡时，内存先后释放两次，会造成内存错误或异常终止。
    注：设计构造函数时，也要对其做与运算符重载同样的处理。

P27 03 运算符重载为友元函数

• 要点：
  1. 略。
• 课件
  • 如下：
    

P28 04 运算符重载实例：长度可变的整型数组类

• 要点：
  1. 数组大小可变的实现方法有两种：
     • 动态申请内存：new和delete。
     • 长度可变：运算符重载。
• 课件
  • 如下：
    
    注：动态分配空间需要指针成员变量。a2 = a;：赋值运算符重载。a2[i]:[]重载。a4(a)：不能用缺省的复制构造函数，因为存在深浅拷贝的问题。
    注：非引用函数的返回值，不可以作为左值引用！
    注：初始化成员列表：CArray(int s) : size(s) { ... }，将size初始化为s。调用默认复制构造函数指向了同一片内存：CArray a2(a1);，会将a1的成员变量复制给a2。
    注：空间分配方案：32->64->128->...，以此类推。标准库的vector实现可变长度数组就是采用了这种方式。相比每次内存增1的方案要高效地多。

P29 05 流插入运算符和流提取运算符的重载

• 要点：
  1. 略。
• 课件
  • 如下：
    

P30 06 自增自减运算符的重载

• 要点：
  1. 可通过全局函数和成员函数来实现。
  2. 全局函数若是想访问私有成员，需要将其声明为友元。
  3. 全局函数：操作数的数目等于参数个数。比成员函数多一个参数。

---

• 成员函数与全局函数的区别（参考：c++：利用成员函数和全局函数实现对运算符的重载）：
  1. 全局变量可以在整个程序里使用；而局部变量只可以在一个函数或一段代码中使用。
  2. 类成员函数是面向对象，全局函数是面向过程。
  3. 类成员函数 => 全局函数：增加一个参数，增加的这个参数代替this指针。
  4. 全局函数 => 类成员函数：减少一个参数，减少的这个参数由this指针隐藏。

---

• 课件
  • 如下：
    注：深浅复制是在成员变量是指针时所考虑的。
    

P31 01 继承和派生

• 要点：
  1. 略。
• 课件
  • 如下：
    注：PrintInfo()非重载，而是覆盖！因为重载：函数名相同，参数表不同。而覆盖是同名同参数表。
    

P32 02 复合关系和继承关系

• 要点：
  1. 类间关系包含以下三种：
     1. 没关系
     2. 继承关系：是
     3. 复合关系：有
• 课件
  • 如下：
    注：使Circle方便操作center的成员变量，最好声明为CPoint的友元函数。
    注：这样的定义方式是：人中有狗，狗中有人。重复定义，CMaster体积包含1个CDog对象，而CDog体积又包含CMaster。
    注：这种定义方式，如何维护不同的狗的相同的主任的信息一致性问题。修改一个狗主人信息，需要全部修改。
    注：复合关系的定义：类的成员对象是另一个类的固有属性或组成成分。而狗非主人的固有属性。狗没有了狗格“人格”：对狗操作，必须要对其主人进行操作，没有自由，不能独立活动。
    注：一个类是另一个类的指针，称两个类是知道的关系。一个类的对象通过指针就能知道另一个类的对象。类似于双向树。

P33 03 基类派生类同名成员和Protected关键字

• 要点：
  1. 基类和派生类的同名成员包括：同名成员变量、同名成员函数。不推荐！
  2. 同名条件下，访问基类成员的方式：
     • 函数访问：基类::成员
     • 对象访问：对象.基类::成员
  3. 派生类不能访问基类的私有成员变量。必须声明为protected类型才行，但是也只能允许当前对象访问。
• 课件
  • 如下：
    
    

P34 04 派生类的构造函数

• 要点：
  1. 略
• 课件
  • 如下：
    

P35 05 public继承的赋值兼容规则

• 要点：
  1.派生类构造函数前会从最顶层基类开始依次执行各个基类的构造函数。
• 课件
  • 如下：
    

---

P36 01 多态和虚函数

• 要点：
  1. 多态：提高程序可扩充性。
  2. 虚函数可参与多态，而普通成员函数不能。
• 课件
  • 如下：
    
    

P37 02 使用多态的游戏程序实例

• 要点：
  1. 新增怪物：使用多态可以使得代码改动和增加量最小。
  2. 新增怪物可通过基类指针指向派生类对象来实现。
  3. 顶层基类：概括了所有怪物的共同特点。
• 课件
  • 如下：
    注：基类指针p是一个指向派生类对象的指针，保存了派生类对象的地址。利用了public继承的赋值兼容规则3：派生类对象的地址可以赋值给基类指针。

P38 03更多多态程序实例

• 要点：
  1. 纯虚函数：无函数体
• 问题1：为什么构造函数和析构函数中调用虚函数，不是多态？
  理由：当一个派生类对象那个初始化时，会先执行基类对象的构造函数。在基类对象的构造函数执行期间，派生类对象它自己的那部分成员变量还未被初始化。如果在基类构造函数执行期间调用虚函数，还允许虚函数是多态的话，那么在基类的构造函数执行期间就会调用派生类的虚函数，这是由于多态，这时派生类对象它自己的成员变量还未被初始化好，此时执行派生类对象的成员函数，有可能不正确。因此，不能在基类的构造函数执行派生类的虚函数。
• 课件
  • 如下：
    注：pShape[i]：基类指针；PrintInfo()：基类和派生类的同名虚函数。因此为多态：指向的对象为哪个派生类，就调用哪个对象的虚函数。
    注：*S1：void类型，占用多少个字节未知，因此直接取内容会编译出错。
    
    】注：this：基类指针；func2()：虚函数。因此调用过程取决于this指针是哪种类型的对象。
    

P39 04 多态实现原理

• 要点：
  1. 每一个含有虚函数的类（基类或继承含有虚函数的基类的派生类）都有一个虚函数表。虚函数表存放了所有虚函数的内存地址。
  2. 多态的代价：会有额外的时间和空间开销。其中，时间开销是查找虚函数表；空间开销是每个对象都多了4个字节的内存空间，存放虚函数表。
• 课件
  • 如下：
    

P40 虚析构函数

• 要点：
  1. 通过基类指针删除派生类对象时（delete p），仅调用基类析构函数。导致派生类无法回收内存空间。
  2. 基类析构函数声明为virtual，使得delete p先调用派生类析构函数，再调用基类析构函数。
• 课件
  • 如下：
    

P41 纯虚函数和抽象类

• 要点：
  1. 包含纯虚函数的类，称为抽象类。
  2. 抽象类的指针和引用，只能指向由抽象类派生而来的派生类的对象。
  3. 派生类实现抽象类的所有纯虚函数，才能称为非抽象类。包含一对{}也相当于实现化。
• 课件
  • 如下：
    

P42 文件操作

• 要点：
  1. ifstream：input。从文件中读取数据，输入到文件流对象。
  2. ofstream：output。文件流对象输出，写入数据到文件中，
  3. fstream：既可读取数据，也能写入数据。
  4. 文件读取必须遵循以下流程：打开文件 -> 读/写文件 -> 关闭文件。
• 课件
  • 如下：
    

P43 函数模板

• 要点：
  1. C++突出特性：抽象、封装、继承、多态、模板。
  2. 函数模板 => 泛型程序设计。
  3. 函数模板简单地实现 “重载”的功能。例如Swap交换int、float、double等。
  4. 模板 + 重载 ，需要定义多个参数类型避免二义性。
• 课件
  • 如下：
    

P44 类模板

• 要点：
  1. 类模板中的函数模板的类型参数不能使用同一个。
• 课件
  • 如下：
    
    

P45 string类

• 要点：
  1. string，模板类实现
• 课件
  • 如下：
    

P46 输入输出

• 要点：
  1. 略
• 课件
  • 如下：
    注：cin >> x强制类型转换运算符的重载。虽然返回值为cin，经过fstream强制类型转换为布尔类型的值。
    注：peek读入但不流失，可判断输入流的数据类型。EOF = -1
    

P47 STL 标准模板库

• 要点：
  1. 容器使用前，一定要了解各个容器的时间复杂度。针对具体情况，择优选取。
  2. 顺序容器：vector 动态数组（32->64->128->256）；deque 双向队列（两端增删，性能佳）；list 双向链表。
  3. 关联容器：排好序的，查找速度快。set：集合；multiset：允许有相同元素；map：字典（key:value）；multimap：允许key相同。
  4. 容器适配器：stack；queue；prority-queue：优先级队列。
  5. 反向迭代器++，会指向前一个元素，与正向不同。
  6. 双向迭代器* p返回的是引用。
• 课件
  • 如下：
    
    
    

P48

• 要点：
  1. 略
• 课件
  • 如下：

未完待续…