毕业中：学习速度较慢
开始课程：P21 6_6. 类型转换运算符的重载
课程链接：程序设计与算法（三）C++面向对象程序设计 北京大学 郭炜
课程PPT：github提供的对应课程PPT

1、类型转换运算符

重载强制类型转换符 double 形式：operator double () {return real};
类型转换符重载是不需要写返回值类型的，默认其double自身。

案例：解释包含在代码中

#include <iostream>
using namespace std;class Complex
{double real, imag;public:Complex(double r=0, double i=0):real(r), imag(i) {};operator double () {return real;}// 重载强制类型转换运算符 double，返回类型就是double，不用单独写出
};int main()
{Complex c(1.2, 3.4);cout << (double)c << endl;   // 输出1.2  //等价于c.operator double()double n = 2 + c;  // 等价于double n = 2+c.operator double()// 本来2和c是不能相加的，因为2为一个整形数字，c确实一个对象，// 所以这里调用了重载类型转换运算符cout << n; // 输出 3.2
}

2、自增、自减运算符的重载

• 自增运算符++、自检运算符–有前置/后置之分，为了区分所有重载的是前置运算符还是后置运算符，C++规定：

• 前置运算符作为一元运算符重载

• 重载为成员函数:
  T & operator++();
  T & operator–();
  重载为全局函数：
  T & operator++(T &);
  T & operator—(T &);
  使用样例：++obj, obj.operator++(), operator++(obj) 都调用上述函数

• 后置运算符作为二元运算符重载，多写一个没用的参数即可，这参数不具备任何意义，也不会被使用；

• 重载为成员函数:
  T operator++(int);
  T operator–(int);
  重载为全局函数:
  T operator++(T &, int);
  T operator–(T &, int);
  使用样例：obj++, obj.operator++(0), operator++(obj,0) 都调用上函数

注意事项：在vs中，obj++也调用前置重载，而dev则令obj++编译出错。

案例：课程中的所有解释均在代码中呈现，请配合课程看代码；

#include<iostream>
using namespace std;class CDemo
{private:int n;public:CDemo(int i=0):n(i) {}CDemo & operator++();   // 用于前置形式，返回值为引用CDemo operator++(int);  // 用于后置形式，返回值为对象// 后置类型的++为什么没使用&引用呢！// 答：在C++中 ++a；a的返回值就是a的引用；所以在重载前置++运算符时，我们需要尽量维持它原本的属性。   operator int() {return n;}  // 类型强制转换运算符，直接可以cout输出对象friend CDemo & operator--(CDemo &);     // 全局前置friend CDemo operator--(CDemo &, int);  // 全局后置
};CDemo & CDemo::operator++()  // 返回值为CDemo对象的引用
{// 前置 ++++n;return * this;   // 返回值是一个对象，即对* this的引用；
}  // ++s即为：s.operator++()，即返回值就是s的引用（& s）CDemo CDemo::operator++(int k)  // 这里的k是无用的参数； 返回值为CDemo对象
{// 后置 ++CDemo tmp(*this);   // 记录修改前的对象n++;return tmp;         // 返回修改前的对象
}  // s++即为：s.operator(0);CDemo & operator--(CDemo & d)  // 这里的引用可不是只为了节省空间，而是要通过该引用更改成员变量
{// 前置--d.n--;return d;   // 返回对操作数的引用，即d的引用
}  // --s即为：operator--(s)CDemo operator--(CDemo & d, int)
{// 后置--CDemo tmp(d);  // 生成一个临时的对象，因为后置本身输出的值大小不变，但其运行完后，该对象中的--或++才生效，所以返回的对象是其自身。d.n--;return tmp; // 返回操作数的对象，即d
}  // s--即为：operator--(s, 0)int main()
{CDemo d(5);cout << (d++) << ","; //等价于 d.operator++(0);   //重载为成员函数的形式cout << d << ",";   // 可以重载左移运算符或者重载一个强制类型转换运算符即可输出d；cout << (++d) << ","; //等价于 d.operator++();    //重载为成员函数的形式cout << d << endl;cout << (d--) << ","; //等价于 operator--(d,0);   //重载为全局函数的形式cout << d << ",";cout << (--d) << ","; //等价于 operator--(d);     //重载为全局函数的形式cout << d << endl;return 0;
}// OUT
MacBook-Air beida_lesson % g++ 21.cpp -o 21
MacBook-Air beida_lesson % ./21
5,6,7,7
7,6,5,5

注意事项：一共有以下一些观点：

由上述代码可知，后置运算符的重载比前置运算符的重载多了一个临时函数的构建，所以前置运算符在时间上的开销要小于后置运算符重载的开销，特别是遇到递归时，变得就比较明显了。所以提倡写前置运算符。

3、继承和派生的基本概念

3.1、基本概念

• 继承：在定义一个新的类B时，如果该类与某个已有的类A相似（指的是B拥有A的全部特点），那么就可以把A作为一个基类，而把B作为基类的一个派生类（也称子类）。
• 派生类是通过对基类进行修改和扩充得到的。在派生类中，可以扩充新的成员变量和成员函数。
• 派生类一经定义后，可以独立使用，不依赖于基类。
• 派生类拥有基类的全部成员函数和成员变量，不论是private、protected、public。
• • 在派生类的各个成员函数中，不能访问基类中的private成员。

案例

• 所有学生都有的共同属性：
• • 姓名
• • 学号
• • 性别
• • 成绩
• 所有学生都有的共同方法：（成员函数）
• • 是否该留级
• • 是否该奖励
• 不同学生又有个字==各自不同的属性和方法
• • 研究生
• • • 导师
• • • 系
• • 大学生
• • • 系
• • 中学生
• • • 竞赛特长加分

class CStudent
{private:string sName;int nAge;public:bool IsThreeGood() {};void SetName(const string & name){sName = name;}
};// 要毕业的学生
class CUndergraduateStudent: public Cstudent
{private:int nDepartment;  // 添加自己的新的成员变量public:bool IsThreeGood() {.....};  // 覆盖（与基类的成员函数名一样，但内容不一样）bool CanBao Yan() {.....};
};   // 派生类的写法是：类名：public基类名// 研究生
class CGraduatedStudent:public CStudent
{private:int nDepartment;char szMentorName[20];public:int CountSalary() {.....};
}

3.2、派生类对象的内存空间

派生类对象的体积，等于基类对象的体积，再加上派生类对象自己的成员变量的体积。在派生类对象中，包含着基类对象，而且基类对象的春初位置位于派生类对象新增的成员变量之前。

举例一个完整的例子：两个类的简单学生管理程序

// File name：22.cpp
#include<iostream>
#include<string>
using namespace std;class CStudent
{private:string name;string id;  // 学号char gender; // 性别， “F”代表女， “M”代表男int age;public:void PrintInfo();void SetInfo(const string & name_, const string & id_, int age_, char gender_);string GetName() {return name;}
};void CStudent::PrintInfo()
{cout << "Name = " << name << endl;cout << "ID = " << id << endl;cout << "Age = " << age << endl;cout << "Gender = " << gender << endl;
}void CStudent::SetInfo(const string & name_, const string & id_,int age_, char gender_)
{name = name_;id = id_;age = age_;gender = gender_;
}class CUndergraduateStudent:public CStudent
{// 本科生类，继承了CStudent类private:string department;  // 学生所属的系的名称public:void QualifiedForBaoyan(){// 输出给予保研资格cout << "qualified for baoyan" << endl;}void Printfo()   // 覆盖：CUndergraduateStudent自己的Printfo{CStudent::PrintInfo();   // 调用基类PrintInfocout << "Department:" << department << endl;}void SetInfo(const string & name_, const string & id_, int age_, char gender_, const string & department_){CStudent::SetInfo(name_, id_, age_, gender_);  // 调用基类的Setinfodepartment = department_;}
};int main()
{CUndergraduateStudent s2;s2.SetInfo("Harry Potter", "118829212", 19, 'M', "Computer Science");cout << s2.GetName() << "" ;s2.QualifiedForBaoyan();s2.PrintInfo();return 0;
}// OUT
MacBook-Air beida_lesson % g++ 22.cpp -o 22
MacBook-Air beida_lesson % ./22
Harry Potterqualified for baoyan
Name = Harry Potter
ID = 118829212
Age = 19
Gender = M

4、继承关系和复合关系

继承关系：“是” 关系

• 基类A，B是基类A的派生类。
• 逻辑上要求：“一个B对象也是一个A对象”。（例：从学生类派生出中学生类，因为中学生也是学生。）

复合关系：“有”关系。

• 类C中“有”成员变量k，k是类D的对象，则C和D是复合关系
• 一般逻辑上要求：“D对象是C对象的固有属性或组成部分”。

4.1、继承关系的使用

4.2、复合关系的使用

5、派生类覆盖基类成员

派生类可以定义一个和基类成员同名的成员，这叫覆盖。在派生类中访问这类成员时，缺省的情况是访问派生类中定义的成员。要在派生类中访问有基类定义的同名成员时，要使用作用域符号::。

class base
{int j;public:int i;void func();
};class derived : public base
{public:int i;void access();void func();
};void derived::access()
{// j = 5; // error,这是base的私有成员变量，派生类derived不能访问i = 5; // 引用的是派生类的ibase::i = 5; // 引用的基类的ifunc();  // 派生类的base::func(); // 基类的}int main()
{derived obj;obj.i = 1;   // 派生类的iobj.base::i = 1;  // 引用的基类的i
}// 在派生类和基类中不要写相同的成员变量，如上代码中的i

注意事项：在派生类和基类中不要写相同的成员变量，如上代码中的i

6、存储权限说明符：protected

特点：基类的protected成员：可以被以下函数访问：

• 基类的成员函数
• 基类的有缘函数
• 派生类的成员函数可以访问当前对象的基类的保护成员

class People
{private: int nPrivate;  // 私有成员public: int nPublic;    // 公有成员protected: int nProtected;  // 保护成员
};class Son:public People
{void Accesspeople(){nPublic = 1;     // OknPrivate = 1;    // wrongnProtected = 1;  // Ok, 访问从基类继承的protected成员Son f;  // 非当前对象 f.nProtected = 1; // wrong, f 不是当前对象}
};int main()
{People f; Son s;f.nPublic = 1;s.nPublic = 1;f.nProtected = 1; f.nPrivate = 1; s.nProtected =1; s.nPrivate = 1; 
}

7、派生类的构造函数

class Bug
{private:int nLegs;int nColor;public:int nType;Bug(int nLegs_, int nColor_);void PrintBug(){};
};class FlyBug:public Bug  // FlyBug是Bug的派生类
{int nWings;public:FlyBug(int nLegs_, int nColor_, int nWings_);
};Bug::Bug(int legs, int color)
{nLegs = legs;nColor = color;
}// 错误的FlyBug构造函数
FlyBug::FlyBug(int legs, int color, int wings)
{nLegs = legs;   // 不能访问nColor = color; // 不能访问nType = 1;      // OK，基类的公有成员，没有问题的nWings = wings;
}// 正确的FlyBug构造函数
// 直接初始化派生类所包含的基类的Bug对象（即Bug构造函数）初始化列表
FlyBug::FlyBug(int legs, int color, int wings):Bug(legs, color) // 基类的构造函数
{nWings = wings;
}int main()
{FlyBug fb(2, 3, 4);  // 调用构造函数初始化fb.PrintBug();fb.nType = 1;fb.nLegs = 2;   // error , nLegs is privatereturn 0; 
}

例：

#include <iostream>class Base
{public:int n;Base(int i):n(i){std::cout << "Base" << n << " constructed " << std::endl;}~Base(){std::cout << "Base " << n << "destructed" << std::endl;}
};class Derived:public Base
{public:Derived(int i):Base(i) // 1、先进入Base构造函数{ std::cout << "Derived constructed " << std::endl;} //2、进入Drivate构造函数~Derived(){std::cout << "Derived destructed" << std::endl;}
};int main()
{Derived Obj(3);return 0;// 3、执行 Derived析构函数// 4、执行 Base析构函数
}// OUT
MacBook-Air beida_lesson % ./23
Base3 constructed 
Derived constructed 
Derived destructed
Base 3destructed

例题2:

#include <iostream>class Bug
{private:int nLefs; int nColor;public:int nType;Bug(int legs, int color);void PrintBug() {};
};class Skill
{public:Skill(int n) {};
};class nWings
{public:nWings(int nWings_) {};
};class FlyBug:public Bug
{nWings w1;Skill sk1, sk2;public:FlyBug(int legs, int color, int wings);
};FlyBug::FlyBug(int legs, int color, int wings):Bug(legs, color), sk1(5), sk2(2), w1(wings) {}

老师版本：

#include <iostream>class Bug
{private:int nLefs; int nColor;public:int nType;Bug(int legs, int color);void PrintBug() {};
};class Skill
{public:Skill(int n) {};
};class FlyBug:public Bug
{int nWings;Skill sk1, sk2;public:FlyBug(int legs, int color, int wings);// nWings(int nWings_) { nWings = nWings_};
};FlyBug::FlyBug(int legs, int color, int wings):Bug(legs, color), sk1(5), sk2(2), nWings(wings) {}

8、public继承的赋值兼容规则

以下等号“=”并没有采用运算符重载。

9、直接基类与间接基类（套娃）

例：

#include <iostream>class Base
{public:int n;Base(int i):n(i){std::cout << "Base" << n << " constructed " << std::endl;}~Base(){std::cout << "Base " << n << "destructed" << std::endl;}
};class Derived:public Base
{public:Derived(int i):Base(i){ std::cout << "Derived constructed " << std::endl;}~Derived(){std::cout << "Derived destructed" << std::endl;}
};class MoreDerived:public Derived
{public:MoreDerived():Derived(4){std::cout << "More Derived constructed" << std::endl;}~MoreDerived(){std::cout << "More Derived destructed " << std::endl;}
};int main()
{MoreDerived Obj;return 0;
}// OUT~MoreDerived()^
2 errors generated.
MacBook-Air beida_lesson % g++ 23.cpp -o 23
MacBook-Air beida_lesson % ./23            
Base4 constructed 
Derived constructed 
More Derived construct