03 面向对象

1、封装

1.1 属性和行为

#include <iostream>
using namespace std;// 面向对象三大特性：封装、继承、多态/*
封装的语法：class 类名 {
访问权限:属性（成员变量）行为（成员函数）
};
*/class Hero {// 访问权限  public private protected
public:// 属性int   m_Id;   // m -> memberint   m_Hp;// 行为void addHp(int hp) {m_Hp += hp;}void subHp(int hp) {m_Hp -= hp;}
};int main() {// 通过类来生成对象的过程，叫  实例化Hero h;// 访问对象的属性h.m_Id = 5;h.m_Hp = 100;h.addHp(100);cout << "Id 为" << h.m_Id << "的英雄，血量是" << h.m_Hp << endl;h.subHp(100);cout << "Id 为" << h.m_Id << "的英雄，血量是" << h.m_Hp << endl;return 0;
}

1.2 访问权限

#include <iostream>
using namespace std;/*
访问权限
公共权限   public         类内可以访问，类外也可以访问
保护权限   protected      类内可以访问，类外不可以访问    子类可以访问
私有权限   private        类内可以访问，类外不可以访问    子类不可以访问（继承）B -> AA  父类、基类       名字、房子、支付密码
B  子类、派生类     公有、保护、私有*/class People {// 公有权限
public:int m_Id;// 保护权限
protected:int m_HouseId;// 私有权限
private:int m_PayPass;public:void work() {// 所有成员变量，类内均可以访问m_Id = 1;m_HouseId = 2;m_PayPass = 1314;}
private:void work1() {// 所有成员变量，类内均可以访问m_Id = 1;m_HouseId = 2;m_PayPass = 1314;}};class Son : public People {void func() {m_Id = 1;m_HouseId = 4;    // 保护成员，子类可以访问// m_PayPass = 123;  // 私有成员，子类无法访问People::work();// People::work1();//私有成员，子类无法访问}
};int main() {// 实例化People p;p.m_Id = 1;       // 公有成员，类外可以访问//p.m_HouseId = 5;  // 保护成员，类外不可以访问//p.m_PayPass = 10; // 私有成员，类外不可以访问p.work();// p.work1();        // 私有成员函数，类外不可访问return 0;
}

 1.3class和struct

#include <iostream>
using namespace std;/*
struct && classstruct 默认是公共的
class  默认是私有的
*/class C {int m_a;
};struct S {int m_a;void func() {   //c和c++区别 c不能定义函数m_a = 666;}
};int main() {C c;S s;// c.m_a;      // 私有的s.m_a = 4;  // 公有的s.func();cout << s.m_a << endl;//666return 0;
}

1.4 属性私有化

#include <iostream>
#include <string>
using namespace std;// 接口、方法、函数 是同一个概念
// 1、可以控制读写权限
// 2、可以检测数据的有效性class Hero {
public://方法来访问属性成员变量void SetName(string name) {  //设置m_Name = name;}string GetName() {  //获取return m_Name;}int GetSkillCount() {return m_SkillCount;}void SetSpeed(int speed) {  //设置if (speed < 100 || speed > 500) {cout << "速度设置不合法" << endl;return;}m_Speed = speed;}private:string   m_Name;            // 可读，可写int      m_SkillCount = 4;  // 只读int      m_Speed;           // 只写
};int main() {Hero h;/*   不行，访问不了h.m_Name = "123";h.m_SkillCount = 4;h.m_Speed = 10;*/h.SetName("剑圣");cout << "英雄的名字叫：" << h.GetName() << endl;cout << "英雄的技能数是：" << h.GetSkillCount() << endl;h.SetSpeed(666);return 0;
}

2、对象特性

2.1构造函数

#include <iostream>
#include <string>
using namespace std;/*
构造函数需要注意的点1、函数名称和类名保持一致
2、返回值类型 不需要写
3、构造函数可以有参数
*/
class Hero {
public:// 默认构造函数/* Hero() {m_Name = "";m_SkillCount = 4;m_Speed = 100;cout << "默认构造函数：Hero 构造完毕！" << endl;}*/// 有参构造函数1Hero(string name="123") {  //加了"123"    Hero h1;也调用m_Name = name;m_SkillCount = 4;m_Speed = 100;cout << "有参构造函数1：Hero 构造完毕！" << endl;}// 有参构造函数2Hero(string name , int skillCount) {m_Name = name;m_SkillCount = skillCount;m_Speed = 100;cout << "有参构造函数2：Hero 构造完毕！" << endl;}private:string   m_Name;int      m_SkillCount;int      m_Speed;
};int main() {Hero h1;Hero h2("剑圣");Hero h3();   // 函数声明  像int main(); int work(); 没调任何构造函数Hero h4{};Hero h5 = Hero("剑圣");Hero h6{ "猴子", 4 };return 0;
}
/*
默认构造函数：Hero 构造完毕！
有参构造函数1：Hero 构造完毕！
默认构造函数：Hero 构造完毕！
有参构造函数1：Hero 构造完毕！
有参构造函数2：Hero 构造完毕！
*/

2.2析构函数

#include <iostream>
using namespace std;/*
析构函数注意点1、函数名称和类名一致，并且在最前面加上一个 ~ 波浪号
2、函数返回值不需要写
3、不能有参数*/
class Hero {
public:// 构造函数  对象创建Hero() {cout << "Hero 默认构造函数调用完毕！" << endl;}// 析构函数   对象销毁~Hero() {cout << "Hero 析构函数调用完毕！" << endl;}
};void test() {Hero h;
}int main() {test();Hero h;int a;cin >> a;return 0;
}
/*
Hero 默认构造函数调用完毕！
Hero 析构函数调用完毕！
Hero 默认构造函数调用完毕！
12
Hero 析构函数调用完毕！
*/

2.3拷贝构造函数

#include <iostream>
using namespace std;/*
拷贝构造函数的定义
类名(const 类型& 变量名) {}*/
class Hero {
public:// 默认构造函数Hero() {m_Hp = 100;cout << "Hero 默认构造函数调用完毕！" << endl;}// 有参构造函数Hero(int hp) {m_Hp = hp;cout << "Hero 有参构造函数调用完毕！" << endl;}//拷贝构造函数Hero(const Hero& h) {// h.m_Hp = 4;//不可以m_Hp = h.m_Hp;cout << "Hero 拷贝构造函数调用完毕！" << endl;}// 析构函数~Hero() {cout << "Hero 析构函数调用完毕！" << endl;}private:int   m_Hp;
};/*
拷贝构造函数的调用时机1、用已经创建的对象来初始化对象
2、函数的传参
3、函数的返回值*/// 1、用已经创建的对象来初始化对象
void func1() {cout << "--------------func1--------------" << endl;Hero h1(20);Hero h2(h1);
}// 2
void test1(Hero h) {}void test2(Hero* h) {}// 2、函数的传参
void func2() {cout << "--------------func2--------------" << endl;Hero h1;// test1(h1);//调拷贝test2(&h1);//传指针，没有生成对象，不调用拷贝
}// 3、函数的返回值
Hero test3() {Hero h(40);return h;
}void func3() {cout << "--------------func3--------------" << endl;Hero h = test3(); //会优化，不调用拷贝构造函数， //解决：右键点击属性->c/c++->命令行 /Zc:nrvo-
}int main() {func1();func2();func3();return 0;
}

 2.4初始化列表

#include <iostream>
#include <string>
using namespace std;/*
初始化列表的语法构造函数(传参1, 传参2): 成员变量1(传参1), 成员变量2(传参2) {}*/
class Hero {
public:/*Hero(string name, int hp) {m_Name = name;m_Hp = hp;}*/Hero(string name, int hp, int speed) : m_Name(name), m_Hp(hp), m_Speed(speed) {}void Print() {cout << "英雄：" << m_Name << "的血量是" << m_Hp << ",速度是" << m_Speed << endl;}private:string m_Name;int m_Hp;int m_Speed;
};
int main() {Hero h("剑圣", 100, 10);h.Print();return 0;
}

 2.5静态成员变量

#include <iostream>
#include <string>
using namespace std;/*
静态成员变量的特点：
1、所有的对象共享同一份数据
2、编译阶段分配内存
3、需要在类中进行声明，在类外进行初始化
*/
class Hero {
public:Hero() {m_Name = "英雄";m_Hp = 100;}~Hero() {}// 3.1 声明static int m_HeroCount;
private:string m_Name;int m_Hp;};// 3.2 初始化
int Hero::m_HeroCount = 100;//作用域 Hero::int main() {Hero h;cout << h.m_HeroCount << endl;//1  100h.m_HeroCount = 101;cout << Hero::m_HeroCount << endl;//2  101cout << &(h.m_HeroCount) << endl;//00007FF6BC742000cout << &(Hero::m_HeroCount) << endl;//00007FF6BC742000  同一个变量return 0;
}

2.6静态成员函数

#include <iostream>
#include <string>
using namespace std;/*
静态成员函数
1、所有对象共享函数
2、静态成员函数只能使用静态成员变量，无法使用普通成员变量
*/class Hero {
public:Hero() {m_Name = "英雄";m_Hp = 100;}~Hero() {}static int m_HeroCount;static int GetHeroCount() {  //静态成员函数//m_Hp += 1;return m_HeroCount;}
private:string   m_Name;int      m_Hp;static int GetHeroCount1() {// m_Hp += 1;return m_HeroCount;}
};int Hero::m_HeroCount = 100;int main() {Hero h;cout << h.GetHeroCount() << endl;cout << Hero::GetHeroCount() << endl;//h.GetHeroCount1();//拿不了return 0;
}

2.7 this指针

#include <iostream>
using namespace std;/*
this指针
1、解决命名冲突
2、*this 就可以获取到这个对象本身this     *this&h      *(&h) == h*/class Hero {
public:Hero(int hp) {//hp = hp;//形参覆盖实参this->hp = hp;cout << this << endl;//地址  000000BFDDF1F984cout << (*this).hp << endl;//100}int hp;
};int main() {Hero h(100);cout << h.hp << endl;//100cout << &h << endl;  //000000BFDDF1F984  一样cout << (*(&h)).hp << endl;//100return 0;
}

2.8 const修饰成员函数

#include <iostream>
#include <vector>
using namespace std;// 常函数class Hero {
public:Hero() : m_Hp(0) {}int getHp() const {// m_Hp = m_Hp + 1;//无法修改成员变量的值return m_Hp;}int setHp(int hp) {m_Hp = hp;}
private:int m_Hp;
};int main() {const Hero h;//不能被修改// h.setHp(100);//常量不能调用非常量函数h.getHp();return 0;
}

2.9 mutable关键字

#include <iostream>
using namespace std;// mutable 可变  <-> constclass Hero {
public:Hero() :m_Hp(0), m_getHpCounter(0) {}int getHp() const {m_getHpCounter++;return m_Hp;}void printCounter() const {cout << "Counter: " << m_getHpCounter << endl;}private:int m_Hp;mutable int m_getHpCounter;//const函数里可操作
};int main() {Hero h;h.getHp(), h.getHp(), h.getHp(), h.getHp(), h.getHp(), h.getHp();//调6次h.printCounter();return 0;
}

3、友元

3.1全局函数作为友元

#include <iostream>
#include <string>
using namespace std;/*
友元的目的让一个类 或者 函数
能够访问另一个类的私有成员友元的关键字： friend三种友元
1、全局函数作为友元
2、类作为友元
3、成员函数作为友元
*/class People {friend void friendVisit(People* p);
public:People() {m_House = "别墅";m_Car = "跑车";}
public:string    m_House;private:string   m_Car;
};void friendVisit(People* p) {cout << "好朋友来访问你的" << p->m_House << endl;cout << "好朋友来访问你的" << p->m_Car << endl;//私有成员访问
}int main() {People p;friendVisit(&p);return 0;
}

3.2类作为友元

#include <iostream>
using namespace std;// 类作为友元
// 让一个类去访问另一个类的私有成员class People;//声明class PeopleFriend {
public:PeopleFriend() {}void visit(People* p);/*void visit(People* p) {cout << "好朋友来访问你的" << p->m_House << endl;cout << "好朋友来访问你的" << p->m_Car << endl;//m_House，m_Car 还没执行到，不知道，放在后面实现}*/
};class People {friend class PeopleFriend;//访问私有
public:People() {m_House = "别墅";m_Car = "跑车";}
public:string    m_House;private:string    m_Car;
};//函数实现
void PeopleFriend::visit(People* p) {cout << "好朋友来访问你的" << p->m_House << endl;cout << "好朋友来访问你的" << p->m_Car << endl;
}int main() {People p;PeopleFriend pf;pf.visit(&p);return 0;
}

3.3成员函数作为友元

#include <iostream>
#include <string>
using namespace std;//  成员函数作为友元
// PeopleFriend 的某个函数能够访问  People 的私有成员变量class People;class PeopleFriend {
public:PeopleFriend() {}void visitAll(People* p);void visitPub(People* p);
};class People {// friend class PeopleFriend;friend void PeopleFriend::visitAll(People* p);
public:People() {m_House = "别墅";m_Car = "跑车";}
public:string     m_House;
private:string     m_Car;
};void PeopleFriend::visitAll(People* p) {cout << "好朋友访问了你的" << p->m_House << endl;cout << "好朋友访问了你的" << p->m_Car << endl;}
void PeopleFriend::visitPub(People* p) {cout << "好朋友访问了你的" << p->m_House << endl;//cout << "好朋友访问了你的" << p->m_Car << endl;//不可访问
}int main() {People p;PeopleFriend pf;pf.visitAll(&p);pf.visitPub(&p);return 0;
}

4、运算符重载

4.1概念

 参考网址：C++语法——详解运算符重载_c++运算符重载-CSDN博客

#include <iostream>
#include <string> //是一个类using namespace std;/*
+
4 + 5 = 9class A {
};A a;
A b;
a + b;*/
int main() {// 1、加法运算符int a = 520;int b = 1314;cout << a + b << endl;// 2、字符串拼接string c = "520";string d = "1314";cout << c + d << endl;//5201314  运算符重载string e = "我";string f = "爱你";cout << e + f << endl;return 0;
}

4.2 +号重载

重载形式：[返回值] operator[运算符] (参数...) { ... }；

#include <iostream>
using namespace std;/*
+
*/
// 复数类
class Complex {friend Complex operator+(Complex& a, Complex& b);friend Complex operator-(Complex& a, Complex& b);
public:Complex() : real(0), image(0) {}Complex(int real, int image) {this->real = real;this->image = image;}//复数相加函数Complex add(Complex& other) { Complex ret;ret.real = this->real + other.real;//this 是 指针  other 是 对象ret.image = this->image + other.image;return ret;}成员函数重载//Complex operator+(Complex& other) {//    Complex ret;//    ret.real = this->real + other.real;//    ret.image = this->image + other.image;//    return ret;//}// a + bivoid Print() {cout << real << '+' << image << 'i' << endl;}private:int   real;//实部int   image;//虚部
};//全局函数重载实现  需要两个对象
Complex operator+(Complex& a, Complex& b) {  //引入友元Complex ret;ret.real = a.real + b.real;ret.image = a.image + b.image;return ret;
}Complex operator-(Complex& a, Complex& b) {Complex ret;ret.real = a.real - b.real;ret.image = a.image - b.image;return ret;
}int main() {Complex a(10, 20);Complex b(5, 8);Complex c =a.add(b);c.Print();//15+28i//Complex c = a.operator+(b);//15+28i//Complex c1 = a + b;//函数名变成operator+实现  可以直接实现 成员函数//全局函数Complex c1 = a + b;Complex d = a - b;c1.Print();d.Print();//5+12ireturn 0;
}

4.3 左移重载

#include <iostream>
using namespace std;/*
左移运算符 ：<<  把对象输出来Complex c;
cout.operator<<(c)  实现// 成员函数重载
c.operator<<(cout)  cout是ostream对象
c << cout   这个不是我们想实现的
*/
// 复数类
class Complex {friend Complex operator+(Complex& a, Complex& b);friend Complex operator-(Complex& a, Complex& b);friend ostream& operator<<(ostream& cout, Complex a);
public:Complex() : real(0), image(0) {}Complex(int real, int image) {this->real = real;this->image = image;}/*Complex operator+(Complex& other) {Complex ret;ret.real = this->real + other.real;ret.image = this->image + other.image;return ret;}*/// a + bivoid Print() {cout << real << '+' << image << 'i' << endl;}private:int   real;int   image;
};Complex operator+(Complex& a, Complex& b) {Complex ret;ret.real = a.real + b.real;ret.image = a.image + b.image;return ret;
}Complex operator-(Complex& a, Complex& b) {Complex ret;ret.real = a.real - b.real;ret.image = a.image - b.image;return ret;
}//cout重载实现
ostream& operator<<(ostream& cout, Complex a) {//&不会调到拷贝构造函数 只有一个coutcout << a.real << '+' << a.image << 'i';return cout;//要有返回值<< endl才能实现
}int main() {Complex a(10, 20);Complex b(5, 8);// Complex c = a.operator+(b);Complex c = a + b;Complex d = a - b;//c.Print();//d.Print();// operator<<(cout, c)cout << c << endl << endl;//重载来实现Complex c的输出return 0;
}

有delete 任何地方的不能调用cout的拷贝构造函数。 

4.4 递增重载

 

#include <iostream>
using namespace std;/*
++前置 ++
后置 ++
*/class Complex {friend ostream& operator<<(ostream& c, const Complex& a);
public:Complex() : real(0), image(0) {}Complex(int real, int image) { //有参构造函数this->real = real;this->image = image;}Complex& operator++() { //前置 ++this->real += 1;return *this;  //返回Complex&，就可以用cout << ++(++a) << endl;}Complex operator++(int) { //后置++  加一个占位符 且必须是int 类型 Complex c = *this;  //要返回另一个对象 this->real += 1;return c;}private:int  real;int image;
};//复数的输出
ostream& operator<<(ostream& c, const Complex& a) { //c is coutc << a.real << '+' << a.image << 'i';return c;
}class A {};
A func1() {  // 模拟Complex operator++(int)return A();
}
void func2(const A& a) { //模拟ostream& operator<<(ostream& c, const Complex& a)}int main() {int x = 1;cout << ++(++x) << endl;//3cout << x << endl;//3Complex a(10, 10);cout << a << endl;//10+10i// ++a;cout << ++(++a) << endl;//12+10i// cout << a << endl;//11+10i  不加引用时 前置生成另一个对象cout << a << endl;//12+10i  加引用时cout << a++ << endl;//12+10icout << a << endl;//13+10i//func2(func1());//不加const错误 非常量引用的初始值必须为左值// cout << ((a++)++)++ << endl;不可以这样写cout << a << endl;//13+10iint b = 5;// cout << ((b++)++)++ << endl;不可以这样写cout << b << endl;return 0;
}

4,5 赋值重载

#include <iostream>
using namespace std;class Hero {
public:Hero() : m_Data(NULL) {}Hero(int data) {m_Data = new int;//内存申请*m_Data = data;}// 错误：double delete~Hero() {if (m_Data) {//感受内存泄露 if 不重载赋值号：会报错delete m_Data;//一个内存调用两次delete 不行m_Data = NULL;}}//解决Hero& operator=(Hero& h) {// m_Data = h.m_Data;//double free问题if (m_Data) {delete m_Data;m_Data = NULL;}// m_Data=NULL执行m_Data = new int;*m_Data = *h.m_Data;return *this;   //h3 = (h2 = h1);实现}int* m_Data;
};int main() {Hero h1(1);Hero h2(2);// if 不重载赋值号//  h1 = h2;//h2的m_Data会覆盖h1的m_Data ，内存相同 ，内存泄露Hero h3(3);cout << h1.m_Data << endl;cout << h2.m_Data << endl;h1 = h2;  // cout << h1.m_Data << endl;cout << h2.m_Data << endl;h3 = (h2 = h1);cout << h1.m_Data << endl;cout << h2.m_Data << endl;cout << h3.m_Data << endl;return 0;
}

4.6 关系运算符重载

#include <iostream>
using namespace std;class Point {  //点类
public:Point(int x, int y) : m_x(x), m_y(y) {}bool operator==(const Point& other) const {//函数const包含m_x 和 m_yreturn m_x == other.m_x && m_y == other.m_y;}bool operator<(const Point& other) const {int d = m_x * m_x + m_y * m_y;int otherd = other.m_x * other.m_x + other.m_y * other.m_y;return d < otherd;}bool operator>(const Point& other) const {if (*this == other) {return false;}if (*this < other) {return false;}return true;}
private:int m_x, m_y;
};int main() {Point a(1, 6);Point b(2, 5);if (a == b) { //一个类==要重载cout << "a 和 b 相等" << endl;}else if (a < b) {cout << "a 比 b 更加接近原点" << endl;}else if (a > b) {cout << "b 比 a 更加接近原点" << endl;//b 比 a 更加接近原点}return 0;
}

4.7 函数调用运算符重载

#include <iostream>
using namespace std;// ()
// add()class AddFunctor {
public:AddFunctor() {m_acc = 0;}int operator() (int a, int b) {m_acc++;return a + b + m_acc;}
private:int m_acc;
};int Add(int a, int b) {return a + b;
}int main() {AddFunctor add;//对象cout << add(5, 6) << endl;//仿函数  cout << add(5, 6) << endl;cout << add(5, 6) << endl; cout << add(5, 6) << endl;cout << add(5, 6) << endl;cout << Add(5, 6) << endl;//每次调用一样cout << Add(5, 6) << endl;cout << Add(5, 6) << endl;cout << Add(5, 6) << endl;cout << Add(5, 6) << endl;//12 13 14 15 16  11 11 11 11 11return 0;
}

5、继承

5.1 继承的语法 

#include <iostream>
using namespace std;/*
*       动物
*      /    \
*    猫      狗
*
* 继承的语法
* class 子类 : 继承方式 父类 {}
* 子类 -> 派生类
* 父类 -> 基类
*/class Animal {
public:void eat() {cout << "吃" << endl;  //猫，狗都吃，所以抽象在一个类}
};class Cat : public Animal {
public:void sayHi() {cout << "喵~" << endl;}
};class Dog : public Animal {
public:void sayHi() {cout << "汪汪汪~" << endl;}
};int main() {Cat c;Dog d;c.eat();d.eat();c.sayHi();d.sayHi();return 0;
}

5.2 继承的方式

#include <iostream>
using namespace std;/*
继承方式class 子类名 : 继承方式 父类名 {};公共 public
保护 protected
私有 private3 x 3 = 9父类权限|    public     |     protected      |   private
子类继承方式public     |    public     |     protected      |   无法访问protected  |   protected   |     protected      |   无法访问private    |    private    |      private       |   无法访问public:   类内可以访问，类外也可以访问
protected：  类内可以访问，类外不可访问，且子类可以访问
private：    类内可以访问，类外不可访问，且子类不可访问
*/class Animal {
public:int m_pub;
protected:int m_pro;
private:int m_pri;
};class Cat : public Animal {
public:Cat() {m_pub = 1;m_pro = 2;// m_pri = 3; 父类私有成员，子类公有继承，无法访问}
};class BossCat : public Cat {
public:BossCat() {m_pub = 1;m_pro = 2;    // 父类Cat中不是私有}
};void testCat() {Cat c;c.m_pub = 1;// c.m_pro = 2;   // 要么是私有，要么是保护
}//2
class Dog : protected Animal {
public:Dog() {m_pub = 1;m_pro = 2;// m_pri = 3; // 父类私有成员，子类保护继承，无法访问}
};class PoliceDog : public Dog {
public:PoliceDog() {m_pub = 1;    // 这个变量，在父类 Dog 中一定不是私有成员m_pro = 2;    // 这个变量，在父类 Dog 中一定不是私有成员}
};void testDog() {Dog d;// d.m_pub = 1;   // 要么是保护，要么是私有// d.m_pro = 2;   // 要么是保护，要么是私有
}//3
class Pig : private Animal {
public:Pig() {m_pub = 1;m_pro = 2;// m_pri = 3;   // 父类私有成员，子类私有继承，无法访问}
};class WildPig : public Pig {
public:WildPig() {// m_pub = 1;   // 该变量在父类 Pig 中是私有的// m_pro = 2;   // 该变量在父类 Pig 中是私有的}
};void testPig() {Pig p;// p.m_pub = 1;     // 要么是保护，要么是私有// p.m_pro = 2;     // 要么是保护，要么是私有
}int main() {return 0;
}

5.3 构造函数和析构函数顺序

#include <iostream>
using namespace std;/*
继承中，构造链里，先构造的后析构d -> c -> b -> a  d继承a..a b c d d c b a
*/class Animal {
public:Animal() {cout << "Animal 构造" << endl;}~Animal() {cout << "Animal 析构" << endl;}
};class Cat : public Animal {
public:Cat() {cout << "Cat 构造" << endl;}~Cat() {cout << "Cat 析构" << endl;}
};class BossCat : public Cat {
public:BossCat() {cout << "BossCat 构造" << endl;}~BossCat() {cout << "BossCat 析构" << endl;}
};void Test() {//Animal a;//Cat c;//先调父类的构造，再调自己BossCat b;
}int main() {Test();return 0;
}

5.4 同名属性的访问

#include <iostream>
using namespace std;//父类和子类变量名相同
class Animal {
public:Animal() {m_Data = 17891;}int m_Data;
};class Cat : public Animal {
public:Cat() {m_Data = 29812;}int m_Data;
};void Test() {Cat c;cout << c.m_Data << endl;//29812cout << c.Animal::m_Data << endl;//17891cout << &(c.m_Data) << endl;//0000003C3011F92Ccout << &(c.Animal::m_Data) << endl;//0000003C3011F928  不会覆盖
}int main() {Test();return 0;
}

5.5 同名函数访问

#include <iostream>
using namespace std;class Animal {
public:Animal() {}void eat() {cout << "动物吃东西" << endl;}
};class Cat : public Animal {
public:Cat() {}void eat() {// Animal::eat();//第一种cout << "猫吃东西" << endl;}
};int main() {Cat c;c.eat();//子类覆盖父类//c.Animal::eat();//第二种return 0;
}

5.6 多继承

#include <iostream>
using namespace std;class BaseA {
public:int m_A;int m_Base;BaseA() : m_A(0), m_Base(520) {}//初始化
};class BaseB {
public:int m_B;int m_Base;BaseB() : m_B(0), m_Base(1314) {}
};class BaseC {
public:int m_C;BaseC() : m_C(0) {}
};class Son : public BaseA, public BaseB, public BaseC {};int main() {Son s;s.m_A = 1;s.m_B = 2;s.m_C = 3;//s.m_Base = 8;//错误：不明确s.BaseA::m_Base = 8;s.BaseB::m_Base = 9;cout << &s.BaseA::m_Base << endl;//存在不同地址cout << &s.BaseB::m_Base << endl;cout << sizeof(s) << endl;//20 5个整型return 0;
}

6、多态

6.1 多态的语法

#include <iostream>
using namespace std;/*
静态多态：函数重载，运算符重载
动态多态：派生类和虚函数实现运行时的多态
*/class Animal {
public:// 虚函数virtual void eat() {cout << "动物在吃东西" << endl;}
};class Cat : public Animal {
public:void eat() {cout << "猫在吃东西" << endl;}
};class Pig : public Animal {
public:void eat() {cout << "猪在吃东西" << endl;}
};// main -> test -> eat -> Animal::eat
// 函数传参是个动物，但是传入不同的动物，会产生不同的行为，这就叫多态
void eat(Animal& a) {a.eat();
}void Test() {Cat c;Pig p;eat(c);//不加virtual，调用Animal的eat()eat(p);//加了  eat()猪在吃东西
}int main() {Test();return 0;
}

6.2 虚函数

#include <iostream>
using namespace std;class Animal {
public:virtual void eat() {cout << "动物在吃东西" << endl;}virtual void run() {cout << "动物在跑" << endl;}
};class Cat : public Animal {
public:void eat() {cout << "猫在吃东西" << endl;}
};void eat(Animal& a) {Animal b;a.eat();
}void Test() {Cat c;eat(c);cout << "Animal's size = " << sizeof(Animal) << endl;//不加virtual =1  加了=8->指针大小
}int main() {Test();return 0;
}

6.3 纯虚函数和抽象类

#include <iostream>using namespace std;class Animal { //有纯虚函数 是抽象类 无法实例化
public:virtual void eat() = 0;//纯虚函数，在子类实现
};class Cat : public Animal {
public:virtual void eat() {cout << "猫在吃东西" << endl;}
};int main() {Cat c;c.eat();return 0;
}

6.4 虚析构和纯虚析构

#include <iostream>
using namespace std;class BaseA {
public:BaseA() {}~BaseA() {cout << "BaseA 销毁了" << endl;}
};class SonA : public BaseA {
public:SonA() : m_Value(NULL) {m_Value = new int(10);//初始化 为10}~SonA() {cout << "SonA 销毁了" << endl;delete m_Value;}int* m_Value;
};class BaseB {
public:BaseB() {}/*virtual ~BaseB() {cout << "BaseB 销毁了" << endl;}*/virtual ~BaseB() = 0;//纯虚析构
};BaseB::~BaseB() {cout << "BaseB 销毁了" << endl;
}class SonB : public BaseB {
public:SonB() : m_Value(NULL) {m_Value = new int(10);}~SonB() {cout << "SonB 销毁了" << endl;delete m_Value;}int* m_Value;
};int main() {BaseA* a = new SonA();delete a;BaseB* b = new SonB();delete b;// BaseB x; 抽象类无法进行实例化return 0;
}