C++ 核心编程

0.前言

最近在做算法移植的时候，发现自己对c++的知识忘得很多，于是就计划重新捡起来。
纸上得来终觉浅，绝知此事要躬行
一直都是我学习和工作的原则，我比较喜欢动手。
于是我把c++的基础知识一行行代码敲了一遍，无论多简单！

1.内存分区模型

c++内存分为4个区域：

• 代码区：存放函数体的二进制代码，由操作系统进行管理。

• 全局区：存放全局变量、静态变量、常量

• 栈区：由编译器自动分配释放，存放函数的参数值、局部变量等。

• 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

内存分区的意义：
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程。

1.1 程序运行前

在程序编译后，生产了exe可执行程序，未执行该程序前分为
代码区：

存放cpu执行的机器指令
1.共享：目的是对于频繁被执行的程序，只需内存中由一份代码即可。
2.只读：防止程序被随意修改指令

全局区：

全局变量包含常量区：字符串常量和其他常量
程序结束后，系统自己释放全局区的数据
const修饰的局部变量(局部常量),不放在全局区，而是放在栈区
int fun() {
 const int a =10;//局部常量
}

总结：

• c++在exe程序运行前分为全局区和代码区
• 代码区的特点是只读和共享
• 全局区中存放全局变量 静态变量 常量
• 常量区中存放const修饰的全局变量(即全局常量) 和 字符串常量

1.2 程序运行后

栈区
由编译器自动分配和释放，函数的参数，局部变量等
注意事项：不与返回局部变量的地址，栈区开辟的数据在函数结束后，编译器会自动释放

堆区
由程序员分别和释放，若程序员不释放，程序结束后，系统会自己释放，如果程序不结束，系统就永远不释放。

c++中主要用new在堆区申请内存

1.3 new的用法

new申请，务必使用delete释放

int *a = new int(10);
delete a;

int *b = new int [8];
delete [] b;//数组释放要加[]

---

2.引用

2.1 引用的基本使用

作用：给变量起别名
语法：数据类型 &别名 = 原名

int a =10;
int &b = a;
(本质上：int *const b = &a)

2.2 引用的注意事项

• 1.引用必须要初始化
  int &b;//错误
• 2.引用在初始化后，不可以改变

int a =10;
int &b = a;

int c =20;

b = c;//赋值操作，而不是更改引用

2.3 引用做函数参数

作用:函数传参时，可以利用引用的技术，让形参修饰实参
优点：可以简化指针修改实参

void swap(int &a,int &b) {
    int temp = a;
    a = b;
    b = temp;
}

2.4 引用做函数返回值

作用：引用可以作为函数的返回值

注意：不要返回局部变量的引用

用法：函数调用作为左值

int& fun()
{
  static int a =10;
  return a;
}

int &ref = fun();

fun()= 100;//函数调用可以作为左值 被赋值

2.5 引用的本质

本质：引用的本质在c++内部实现是一个指针常量（指向不变，里面的值可变）

//编译器发现这里是引用，转换位int * const ref = &a;
void func(int & ref) {
  ref = 100;//ref是引用，转换位*ref = 100
}

int main(){
  int a=10;

  int& ref = a;
  //自动转换为 int* const ref = &a;
  //指针常量是指向不可更改，值可改，也说明为什么引用不可更改

  ref = 20;//发现是引用，自动转换成 *ref =20
}

结论：c++途径用引用计数，因为语法方便，引用的本质是指针常量，但是所有指针的操作，编译器都帮我们做了

常量引用

作用：常量引用主要用来修饰形参，防止误操作
const int & a;

int &ref =10;//这是错误的，引用必须引用一块合法的内存,10在常量区，访问时必须加const

int &ref =10;//这是错误的，引用必须引用一块合法的内存


const int &ref =10；//合法
//加上const之后，编译器把代码修改成
/*
int temp =10;
const int &ref = temp;
*/

//常量引用使用场景：通常用来修饰形参，防止函数改值
void printValue(const int&a){
  //a=20；报错
  print("a=%d",a);
}

---

3.函数提高

---

3.1 函数的默认参数

在c++中，函数的形参是可以有默认值的。

语法： 返回值 函数名 (参数 = 默认值) { }

int func(int a,int b=1, int c =2) {

}

• 如果形参中某个位置有了默认参数，从这个位置往后，从左往右都必须有默认参数

• 如果函数声明有默认参数，函数实现就不能有默认参数，否则会报错：重定义默认参数

int fun2(int a =10);//声明
int func2(int a =10){//实现
}
这样会报错

3.2 函数占位参数

c++中的函数的形参是可以有占位参数的，用来做占位，调用函数时必须填补该位置。

语法： 返回值 函数名 （数据类型）{ }

//占位参数-第二个参数
void func(int a,int) {

}
//占位参数 还可以有默认参数
void func2(int = 10){

}

int main(){
 func(10,10);
}

3.3 函数重载

3.3.1 函数重载概述

作用：函数名可以相同，提高复用性

函数重载满足条件

• 同一个作用域下
• 函数名相同
• 函数参数 类型不同 或者 个数不同 或者 顺序不同

注意：函数返回值 不可以作为函数重载的条件

void fun();
void fun (int a,float b)
void fun (float b,int a)
//int  fun (float b,int a) 这个会报错，二义性

3.3.2 函数重载注意事项

• 引用作为重载条件

//1.引用作为重载条件
void func(int &a){ //int& a =10 ；不合法

}

void func(const int &a){const int &a = 10 合法

}
这两个是函数重载 int 和 const int算不同类型

int main(){
int a =10;
func(a);//此时调用第1个void func(int &a)，
//如果void func(int &a)没定义，就调用第2个
func(10);//此时调用第2个void func(const int &a)
}

• 函数重载碰到默认参数

void func(int a){ //int& a =10 ；不合法

}
void func(int a,int b =10){
}

fun(10);//这里编译器不知道调用哪个了

这里函数会出现二义性，会报错，
一般写函数重载时，就别写默认参数了

---

4.类和对象

---

万事万物皆为对象，包含属性和行为
c++面向对象的三大特性：封装、继承、多态

4.1 封装

4.4.1 封装的意义

封装是c++面向对象的三大特性之一
意义：

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制f

封装的意义1：
在设计类的时候，属性和行为写一起，表现事物

语法：class 类名{访问权限： 属性/行为}；

设计一个圆类

//圆周率
const double PI = 3.14；

class Circle
{
//访问权限
public:

//属性
int r;//半径

//行为
double calZC(){
  return 2*PI*r;
}


Circle c ;//对象
c.r = 10;
c.calZC（）；

}

封装的意义2：
将属性和行为加以权限控制

访问权限有3种
1.public：公共权限
成员 类内可以访问，类外可以
2.protected：保护权限
成员 类内可以访问，类外不可以
3.private：私有权限
成员 类内可以访问，类外不可以

4.1.2 struct 和 class区别

在c++中，struct和class的唯一区别：
默认访问权限不同

• struct 默认权限 公共
• class 默认权限 私有

class C1
{
  int a;//私有
}；

struct C2 {
int  a ;//公共
}

4.1.3 成员属性设置为 私有

• 优点1：：将所有的属性设置成私有，可以自己控制读写权限
• 优点2：对于写权限，可以检测数据的有效性

4.2 对象的初始化和释放

4.2.1 构造函数和析构函数

对象的初始化和释放是2个非常重要的安全问题。

对象没用初始状态，其后果是未知的
使用完对象没释放，也会造成安全难问题

• 构造函数：创建对象时，初始化属性
• 析构函数：销毁对象时，释放资源
  2个函数都是系统自动调用！

构造函数语法：类名(){ }
1.构造函数没有返回值，也不写void
2.函数名和类名相同
3.构造函数有参数，可以函数重载
4.创建对象时，自动调用一次构造函数

析构函数语法：
1.析构函数没有返回值，也不写void
2.析构函数与类名相同，在名称前加上~
3.析构函数没用参数，无法重载
4.对象销毁前会自动调用一次析构函数

Class p{
 //构造函数
 p(){ }
  //析构函数
~p(){
}
};

4.2.3构造函数的分类和调用

两种分类方式：
按照参数：有参构造和无参构造
按照类型：普通构造和拷贝构造

三种调用方式：
括号法
显示法
隐式转换法

class Person {
public:
  Person(){//无参构造
  }
  Person(int a){//有参构造
    age = a；
  }
//以上都是普通构造

  Person(const  Person &p){//拷贝构造
    age = p.age;
  }

private：
int age；
}


1.括号法
Person p1;
Person p2(10);
Person p3(p2);

2.显示法
Person p1;
Person p2  = Person(10);
Person p3 = Person(p2);

Person(6);//单独拿出来是 匿名对象
 特点：当前行执行结束后，系统会立即回收匿名对象

注意事项：
不要利用拷贝构造函数，初始化匿名对象
Person(p3);
编译器会认为Person(p3) == Person p3;



3.隐式转换法
Person p4 = 10;//相当于 Person p4 = Person(10);
Person p5 = p4;//相当于 Person p5 = Person(p4);

4.2.3 拷贝构造函数的调用时机

class Person{
public:
  Person(){
    无参构造
  }

  Person(int a ){
    有参构造
    age =a;
  }

  Person(const Person & p){
    拷贝构造
    age = p.age;
  }

  ~Person(){
    析构函数
  }

private:
int age;
}

三种情况：

• 使用一个已经创建完的对象来初始化一个新对象

void test(){
  Person p1(20);
  Person p2(p1);
}

• 值传递的方式给函数参数传值

void doWork(Person p){//这里相当于Person p = my_p
  
}
void test2(){
    Person my_p;
    doWork(my_p);
}
* 以值的方式返回局部对象
```c
Person doWork3(){
  Person p;
  return p;//这里执行完后会释放p，系统会拷贝一个临时p返回
}
void test(){
  Person p = doWrok3();
}

4.2.4 构造函数调用规则

默认情况下，c++编辑器会给一个类添加3个函数

1.默认构造函数(无参 函数体为空)
2.默认析构函数(无参 函数体为空)
3.默认拷贝构造函数(对所有属性进行值拷贝)

构造函数规则：

• 如果用户定义了有参构造，c++编辑器不在提共默认无参构造，但是会提供默认拷贝构造
• 如果用户定义拷贝构造函数，c++不会提供其他构造函数

  Person(const Person & p){
    拷贝构造
    age = p.age;
  }

4.2.5 深拷贝和浅拷贝

• 浅拷贝：值拷贝
• 深拷贝: 在堆区重新申请一块内存空间，进行拷贝操作

#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
class Person
{
public:
    Person()
    {
        cout<<"Person 默认构造函数"<<endl;
    }
    Person(int age,int height)
    {
        m_age = age;
        m_height = new int(height);
        cout<<"Person 有参构造函数"<<endl;
    }
    
    //浅拷贝：带来的问题就是堆区重复释放 
    Person(const Person &p)
    {
        cout<<"Person 浅拷贝构造函数调用"<<endl;
        m_age = p.m_age;
        m_height = p.m_height;
    }
    
    //深拷贝
    Person(const Person &p)
    {
        m_age = p.m_age;
        m_height = new int(*p.m_height);
    }    
    
    ~Person()
    {
        cout<<"Person 析构函数调用,m_height地址"<<m_height<<endl;
        if(m_height != nullptr)
        {
            cout<<"释放 person=%p"<<this<<" m_height ="<<*m_height<<endl;
            delete m_height;
            m_height = nullptr;
        }
        
    }

    int m_age;
    int *m_height;
};

void test()
{
    Person p1(18,180);
    cout<<"p1 ="<< (int*)&p1 << " "<<p1.m_age<<"  "<<*p1.m_height<<endl;
    Person p2(p1);
    cout<<"p2 ="<<(int*)&p2<< " "<<p2.m_age<<"  "<<*p2.m_height<<endl;
}

int main(int argc, char** argv) {
    test();
    return 0;
}

总结：如果成员变量有在堆区开辟内存的，一点要自己提供拷贝构造函数，防止浅拷贝代理的堆内存重复释放问题

4.2.6 初始化列表

作用
c++提供初始化列表的语法，用来初始化属性

语法：构造函数():属性1(值1)，属性2(值2)···{}

#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
class Person
{
public:
    Person():m_a(10),m_b(20)
    {
        
    }
    
    Person(int a,int b):m_a(a),m_b(b)
    {
        
    }   
    int m_a;
    int m_b;
};

int main(int argc, char** argv) {
    Person p;
    cout<<p.m_a<<" "<<p.m_b<<endl;
    Person p2(30,40);
    cout<<p2.m_a<<" "<<p2.m_b<<endl;
    return 0;
}

4.2.7 类对象作为类的成员

构造时：当其他类对象作为本类成员时，构造时先构造出其他类的对象，在构造自身
析构时：先析构自己，再析构其他类。(因为加载函数是栈的形式 后进先出)

class Phone
{
public:
    Phone(string name):name(name)
    {
        cout<<"Phone 有参构造函数调用"<<endl;
        //this.name = name;
    }
    
    ~Phone()
    {
        cout<<"Phone 析构函数调用"<<endl;     
    }
    string name;    
} ;

class Person
{
public:
    Person(string name,string p):name(name),p(p)
    {
        cout<<"Person 有参构造函数调用"<<endl;      
    }
    
    ~Person()
    {
        cout<<"Person 析构函数调用"<<endl;        
    }
    string name;
    Phone p;    
};

4.2.8 静态成员

在成员函数和成员变量前面加上static关键字，成为静态成员。

静态成员分为：

• 静态成员变量
  • 所有对象共享一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化

class A
{
public:
  static int m_a;//类内声明
}
int A::m_a = 100;//类外初始化 要去掉static

• 静态成员函数
  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量
  • 类外无法访问私有的成员函数或者变量

class Person
{
public:
    static void fun()
    {
        cout<<"静态成员函数"<<endl;
    //  m_a = 1;
        m_b = 2;
    }
    
    int m_a;
    static int m_b;

priviate:
static void fun2()//
{
}

} ;

void test()
{
    //1.通过对象调用 
    Person p;
    p.fun();
    //2.通过类名调用
    Person::fun();

//私有无法访问
//Person::fun2();
}

4.3 C++的对象模型和this指针

4.3.1 成员变量和成员函数分开存储

在c++中，类内的成员变量和成员函数是分开存储的，
只有非静态成员变量才属于类的对象上

• 空对象占用内存为1个字节
  c++编译器会给每个空对象分配一个字节空间，是为了区分空对象占用内存的位置。

class Person
{
    
} ;

void test()
{
    Person p;//空对象
    cout<<sizeof(p)<<endl;
}

• 只有非静态成员变量才属于类的对象上

class Person
{
    int a;//非静态成员变量 属于类的对象 此时p的内存为4 个字节
    
    static int b;//静态成员变量 不属于类对象上
    
    void fun();//非静态成员函数 不属于类对象上
    
    static void fun2();//静态成员函数 不属于类对象上 
    
} ;

void test()
{
    Person p;
    cout<<sizeof(p)<<endl;
}

4.3.2 this指针的概念

this指针指向被调用的成员函数所属的对象
谁调用this，this就指向哪个对象

this是隐含在非静态成员函数内的一种指针

this指针的用途：

• 当形参和成员变量同名时，可以用this指针来区分
• 在类的非静态成员函数中返回对象本身，可以用return *this

class Person
{
public:
    Person(int age)
    {
        this->age = age;
    }
    
//这里要返回Person&，如果返回Person，系统会创建一个临时变量返回
    Person& addAge(Person &p)
    {
        this->age += p.age;
         //this指向的是p2的指针，而*this指向的是p2对象本身
        return *this;
    }
    int age;
        
} ;

this指向的是p2的指针，而*this指向的是p2对象本身

4.3.3 空指针访问成员函数

c++中空指针也是可以调用成员函数的，
如果要用到this指针，要加以判断，保证代码的健壮性

class Person
{
public:
    void showName()
    {
        cout<<"this is Person class"<<endl;
    }   
    
    void showAge()
    {
        if(this == NULL)//增加健壮性 
            return;
        cout<<"age = "<<this->age<<endl;//p == null 这里直接访问会崩溃 
    }
    
    int age;
};

int main(int argc, char** argv) {
    Person *p =NULL;
    p->showName();
    p->showAge();
    return 0;
}

4.3.4 const修饰成员函数

常函数

• 成员函数后加const关键字，称为常函数
• 常函数内不可以修改成员属性
• 成员函数加上关键字mutable后，在常函数中就可以修改

常对象：

• 声明对象前加const称为常对象
• 常对象只能调用常函数（因为普通函数可以改成员变量，常对象不允许修改成员变量）

class Person
{
public:
    //常函数
    //在成员函数后面加const，修饰的是this指向，让指针指向的值也不可修改，这里 this =  const Person * const this  
    void showPerson() const
    {
        //this = (Person * const this) 的本质是 指针常量，，指针的指向是不可以修改，指向的内容可变 
        //this->m_a = 100;不允许改变 
        this->m_b =100; 
    } 
    
    void fun()
    {
        //这里面可以修改成员变量的值，如 m_a =10;
    } 
    
    int m_a;
    mutable int m_b;//mutable变量，即使在常函数中，也能修改值 
};

//常对象
void test()
{
    const Person p ;//对象面前加const，成为常对象
    //p.m_a = 100; 常对象不允许改任何值 
    p.m_b = 100;
    //常对象只能调用常函数
    p.showPerson(); 
    //p.fun();//常对象不可以调用普通成员函数，因为普通成员函数可以修改成员变量，常对象又不允许修改 
} 

---

4.4 友元

作用：
让一个函数或者类访问另一个类中的私有成员
友元的关键字friend

友元的三种实现：

• 全局函数做友元

class MyHome
{
    //全局函数做友元
    friend void  goodGay(MyHome &m);
public:
    MyHome():m_livingRoom("客厅"),m_bedRoom("卧室") 
    {
            
    }   
    string m_livingRoom;//客厅
     
private:
    string m_bedRoom;//卧室 
} ;

//全局函数
void goodGay(MyHome &m)//这里相当于 MyHome *const m = &mh; 
{
    cout<<"好基友正在访问:"<<m.m_livingRoom<<endl;
    cout<<"好基友正在访问:"<<m.m_bedRoom;
} 
int main(int argc, char** argv) {
    MyHome mh;
    goodGay(mh);
    return 0;
}

• 类做友元

class Home
{
public:
    friend class GoodGay;
    Home():m_livingRoom("客厅"), m_bedRoom("卧室")
    {
        
    }
public:
    string m_livingRoom;
private:
    string m_bedRoom;
};

class GoodGay
{
public:
    GoodGay()
    {
        h = new Home;
    }
    void visit()
    {
        cout<<"好基友正在访问:"<< h->m_livingRoom<<endl;
        cout<<"好基友正在访问:"<< h->m_bedRoom<<endl;
    }   
private:
    Home *h;
};

• 成员函数做友元

class GoodGay;

class Home
{
//成员函数做友元
    friend void GoodGay::visit(); 
public:
    Home():m_livingRoom("客厅"), m_bedRoom("卧室")
    {
        
    }
public:
    string m_livingRoom;
private:
    string m_bedRoom;
};

class GoodGay
{
public:
    GoodGay()
    {
        h = new Home;
    }
    void visit()
    {
        cout<<"好基友正在访问:"<< h->m_livingRoom<<endl;
        cout<<"好基友正在访问:"<< h->m_bedRoom<<endl;
    }
    
private:
    Home *h;
};

void test()
{
    GoodGay g;
    g.visit();
}

4.5 重载

ps:运算符重载跳过

4.6 继承

继承的好处
减少重复的代码

4.6.1 继承的基本语法

语法：
class 子类：继承方式 父类
子类也称为派生类
父类也成为基类

class BaspePage
{
public:
    void header()
    {
        cout<<"首页 公开课 登录 注册"<<endl;
    }
    void footer()
    {
        cout<<"帮助中心、加入我们"<<endl;
    }
} ;

class Jave : public BaspePage
{
public:
    void content()
    {
        cout<<"这是 JAVA 教程"<<endl;
    }   
};
int main(int argc, char** argv) {
    Jave j;
    j.header();
    j.content();
    j.footer();
    return 0;
}

4.6.2 继承的方式

继承的方式一共有三种：

• 公共继承
• 保护继承
• 私有继承

class Father
{
public:
    Father():a(1),b(1),c(1)
    {
        
    } 
public:
    int a;
protected:
    int b;
private:
    int c;  
};

class Son1:public Father
{
public:
    void fun()
    {
        a= 10; 
        b= 20;
        //c= 30;
    } 
};
void test01()
{
    Son1 s;
    s.a = 100;
    //s.b = 50; 保护权限类外无法访问 
}

4.6.3 继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？
私有成员也会被子类继承，只是被编译器隐藏了，无法访问

class Base
{
public:
    int a;
protected:
    int b;
private:
    int c;//私有成员也会被子类继承，只是被编译器隐藏了，无法访问 
};
class Son:private Base
{
public:
    int d;
};


int main(int argc, char** argv) {
    Son s;
    cout<<sizeof(s)<<endl;//size = 16 
    return 0;
}

4.6.4 继承中构造和析构的顺序

子类继承父类后，当创建子类对象时，也会调用父类的构造。

先构造父类，在构造子类，析构相反：先析构子类，再析构父类

class Base
{
public:
    Base()
    {
        std::cout<<"Base 的默认构造函数"<<endl;
    }
    ~Base()
    {
        std::cout<<"Base 的析构函数"<<endl;
    }   
};

class Son: public Base
{
public:
    Son()
    {
        std::cout<<"Son 的默认构造函数"<<endl;     
    }
    ~Son()
    {
        std::cout<<"Son 的析构函数"<<endl;       
    }
};

void test()
{
    Son s;
} 

4.6.5 继承中同名成员的处理方式

问题：当子类与父类出现同名成员，如何通过子类对象，访问子类或者父类的同名数据呢？

• 访问子类 同名成员，直接访问即可
• 访问父类 同名成员，需要加作用域

总结：

• 1.子类对象可以直接访问到子类中的同名成员
• 2.子类对象加作用域可以访问到父类同名成员
• 3.当子类和父类拥有同名的成员函数时，子类会隐藏父类中所有的同名函数，需要加作用域才可以访问父类的同名函数

class Base
{
public:
    Base()
    {
        m_a = 100;
    }   
    
    void fun()
    {
        cout<<"Base - fun()"<<endl;
    }
    void fun(int a)
    {
        cout<<"Base - fun(int a)"<<endl;
    }   
    
    int m_a;
};

class Son : public Base
{
public:
    Son()
    {
        m_a = 200;
    }
    
    void fun()
    {
        cout<<"Son - fun()"<<endl;
    }   
    
    int m_a;
    
};

void test()
{
    Son s;
    cout<<"Son  下的 m_a = "<<s.m_a<<endl;
    //通过子类对象访问父类中同名成员，需要加作用域Base 
    cout<<"Base 下的 m_a = "<<s.Base::m_a<<endl;   
}

void test2()
{
    Son s;
    s.fun(10);
    //通过子类对象访问父类中同名成员，需要加作用域Base 
    s.Base::fun();
    
    //当子类出现和父类同名的成员函数时，子类会隐藏掉父类所有的同名成员函数 
    //通过作用域才能访问到被隐藏的同名成员函数 
    s.Base::fun(10);    
} 

4.6.6 继承同名 静态成员 的处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

• 访问子类同名成员，直接访问即可
• 访问父类同名成员，需要加作用域

    //通过对象访问 
    Son s;
    cout<<s.m_a<<endl;
    cout<<s.Base::m_a<<endl;
    //通过类名访问 
    cout<<Son::m_a<<endl;
    //第一个：：代表通过类名方式访问，第二个：：代表访问父类作用域下
    cout<<Son::Base::m_a<<endl;

总结：同名静态成员的处理方式和非静态的完全一致，只不过有2种访问方式(通过对象和通过类名)

4.6.7 多继承语法

c++中运行一个类继承多个类

语法：class 子类：继承方式 父类 1，继承方式 父类 2 ···
多继承可能会引发父类中有同名成员出现，需要加作用域区分

c++开发中不建议用多继承

class A
{
public:
    A():m_a(100)
    {
        
    }
    int m_a;
};

class B
{
public:
    B():m_a(200)
    {
        
    }
    int m_a;
};

class C : public A, public B
{
public:
    C()
    {
        m_c = 300;
    }
    
    int m_c;
};
int main(int argc, char** argv) {
    C c;
    //当父类出现同名成员，需要加作用域区分
    cout<<c.A::m_a<<" "<<c.B::m_a<<" "<<c.m_c<<endl;
    return 0;
}

4.6.8 菱形继承

概念：
2个子类继承同一个父类
又有某个类统计继承2个子类
这种继承被称为菱形继承，或者钻石继承

class Animal
{
public:
    int m_Age;
};
//继承前面加virtual关键字，变为虚继承
//此时公共父类Animal称为虚基类 
class Sheep : virtual public Animal{};//羊
class Camel : virtual public Animal{};//骆驼
class Alpaca : public Sheep , public Camel{};//羊驼 
int main() {
    Alpaca a;
    a.Sheep::m_Age = 100;
    a.Camel::m_Age = 200;
    cout<<"a.Sheep::m_Age ="<<a.Sheep::m_Age<<endl;
    cout<<"a.Camel::m_Age ="<<a.Camel::m_Age<<endl;
    cout<<"am_Age ="<<a.m_Age<<endl;//三个打印都是200，数据只有一份
    return 0;
}

总结：

• 菱形继承带来主要问题是 子类继承多份相同的数据，导致资源浪费。
• 利用 虚继承 解决菱形继承问题
• 虚继承的本质是继承指针，通过指针去访问同一份数据(m_Age)

4.7 多态

多态是C++面向对象的三大特性之一

4.7.1 多态的基本概念

多态分为2类：

• 静态多态：函数重载和运算符重载 属于静态多态，复用函数名
• 动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态的区别：

• 静态多态的函数地址早绑定 - 编译阶段确定函数地址
• 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

静态多态

class Animal
{
public:
    void speak()
    {
        cout<<"动物在说话"<<endl; 
    }   
} ;
class Cat : public Animal
{
public:
    //重写： 函数返回值 参数列表完全相同
    void speak()
    {
        cout<<"猫在说话"<<endl;
    }
};
//地址早绑定 在编译阶段确定函数地址
//无论传什么，都只会调用父类的函数 
void doSpeak(Animal &a)
{
    a.speak();
}

void test()
{
    Cat c;
    doSpeak(c);
}

int main(int argc, char** argv) {
    test();//输出结果：动物在说话 
    return 0;
}

动态多态

class Animal
{
public:
    //加上virtual，变成虚函数，就可以晚绑定 ，子类的函数可加virtual 或者不加
    virtual void speak()
    {
        cout<<"动物在说话"<<endl; 
    }   
} ;

重写： 函数返回值 参数列表完全相同
重载：函数参数列表不同，返回值相同

总结：
动态多态的满足条件

• 1.有继承关系
• 2.子类重写父类的虚函数

动态多态的使用
父类的指针或者引用，执行子类对象

class A
{
public:
   int fun(){}
}
这里 sizeof(A)= 1 
class A
{
public:
   virtual int fun(){}
}
这里 sizeof(A)= 4,因为加上 virtual ，fun就变成了一个指针(指针都是4个字节)vfptr:虚函数指针

4.7.2 多态案例-计算器

普通代码实现计算器

//普通代码实现计算器
class NomalCal
{
public:
    int getResutl(int oper)
    {
        switch(oper)
        {
            case '+' :
                return m_a + m_b;
                break;
            case '-' :
                return m_a - m_b;
                break;
            case '*' :
                return m_a * m_b;
                break;
            //如果想扩展功能：除法，需要修改源码
            //开发中提倡开闭原则：对扩展进行开放，对修改进行关闭 
            default:
                return 0;           
        }   
    }   
    int m_a;
    int m_b;
} ;

void test1()
{
    NomalCal nc;
    nc.m_a = 10;
    nc.m_b = 10;
    cout<<nc.m_a<< " + " <<nc.m_b<<" = "<<nc.getResutl('+')<<endl;
}

多态实现计算器

//多态实现
class BaseCal
{
public:
    virtual int getResult(){return 0;}
    int m_a;
    int m_b;
} ;

class AddCal : public BaseCal
{
    int getResult()
    {
        return m_a+m_b;
    }   
};

有其他功能继续添加：比如减法

void test2()
{
    //多态使用条件：父类指针或者引用指向之类对象 
    BaseCal *bc = new AddCal;
    bc->m_a = 20;
    bc->m_b = 10;
    cout<<bc->m_a<< " + " <<bc->m_b<<" = "<<bc->getResult()<<endl;
    delete bc;//记得释放 
}

多态的优点：

• 代码结构清晰
• 可读性强
• 利于前期和后期的扩展以及维护，符合开闭原则

4.7.3 纯虚函数和抽象类

在多态中，通常父类中的虚函数是毫无意义的，主要调用子类的重写的函数。

因此可以把虚函数改为纯虚函数

语法：virtual 返回值类型 函数名(参数列表) = 0

当类中只要有1个纯虚函数，也把类称为抽象类

抽象类的特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

class Base//抽象类：类中只要有一个纯虚函数 
{
public:
    //纯虚函数 
    virtual void fun() = 0; 
} ;
class Son : public Base
{
public:
    virtual void fun(){}
};

4.7.4 多态案例2-制作饮品

1.茶的抽象类

class AbsDrinKing
{
public:
    //1.煮水 
    virtual void boil() = 0;
    //2.冲泡
    virtual void brew() = 0;
    //3.倒入杯中
    virtual void pourInCup() = 0; 
    //4.加入辅料
    virtual void putSomething() = 0;
    
    void makeDrink()
    {
        boil();
        brew();
        pourInCup();
        putSomething();
    } 
};

2.做咖啡

class CofferDrink : public AbsDrinKing
{
    //1.煮水 
    virtual void boil()
    {
        cout<<"煮咖啡"<<endl;
    };
    //2.冲泡
    virtual void brew()
    {
        cout<<"泡咖啡"<<endl;
    }
    //3.倒入杯中
    virtual void pourInCup()
    {
        cout<<"把咖啡倒入杯中"<<endl;
    } 
    //4.加入辅料
    virtual void putSomething()
    {
        cout<<"加入糖"<<endl;
    }
};

3.做奶茶同理
省略···
4.制作函数

void doWork(AbsDringKing *abs)
{
  abs->makeDrink();
}

4.7.5 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。

解决方式：将父类的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象的问题
• 都需要有具体的函数实现

虚析构和纯虚析构的区别：

• 如果是纯虚析构，则该类属于抽象类，无法实例化对象，而虚析构可以！

虚析构语法：
virtual 类名(){ }

纯虚析构语法:
virtual 类名() = 0;
类外还要写实现
类名：：~类名(){ }

可能出现内存泄漏

解决办法：
1.父类析构函数加上virtual，变成虚析构

class Animal
{
public:
    Animal(){cout<<"Animal 构造函数调用"<<endl;}
    virtual ~Animal(){cout<<"Animal 虚析构函数调用"<<endl;}//虚析构
    virtual void speak() = 0; 
};

2.纯虚析构

class Animal
{
public:
    Animal(){cout<<"Animal 构造函数调用"<<endl;}
    virtual ~Animal() = 0;//纯虚析构 
    virtual void speak() = 0; 
};
Animal::~ Animal()
{
    //如果父类也申请的堆区内存，可以在这里释放 
    cout<<"Animal 纯虚析构函数调用"<<endl;
} 

总结：

• 1.虚析构和纯虚析构是用来解决 通过父类指针 释放子类对象的情况
• 2.如果子类中没有堆区数据，可以不写虚析构或者纯虚析构
• 3.拥有纯虚函数的类也属于抽象类

4.7.6 多态案例3-电脑组装

//抽象零件
//1.抽象CPU
class CPU
{
public: 
    virtual void cal() = 0;
};
//2.抽象显卡
class VideoCard
{
public: 
    virtual void display() = 0;
};
//3.抽象内存
class Memory
{
public: 
    virtual void storage() = 0; 
} ;

//电脑类
class Computer
{
public:
    Computer(CPU *cpu,VideoCard *vc,Memory * mem)
    {
        m_cpu = cpu;
        m_vc = vc;
        m_mem = mem;
        cout<<"Computer 构造函数"<<endl;
    }
    
    ~ Computer()
    {
        if(m_cpu!=NULL)
        {
            delete m_cpu;
            m_cpu = NULL;
        }
        if(m_vc!=NULL)
        {
            delete m_vc;
            m_vc = NULL;
        }
        if(m_mem!=NULL)
        {
            delete m_mem;
            m_mem = NULL;
        }
        cout<<"Computer 析构函数 释放资源"<<endl; 
    } 
    
    void doWork()
    {
        //父类指针调用子类对象
        m_cpu->cal();
        m_vc->display();
        m_mem->storage();
    }
private:
    CPU *m_cpu;
    VideoCard *m_vc;
    Memory *m_mem;
};

//intel 电脑 
class IntelCPU : public CPU
{
public:
    void cal(){cout<<"Intel cpu 工作了"<<endl;}
};
class IntelVideoCard : public VideoCard
{
public:
    void display(){cout<<"Intel 显卡 工作了"<<endl;;}    
};
class IntelMemory : public Memory
{
public:
    void storage(){cout<<"Intel 内存 工作了"<<endl;} 
};
//苹果电脑省略***
void test()
{
    //第一台电脑
    IntelCPU * ic = new IntelCPU;
    IntelVideoCard *ivc = new IntelVideoCard;
    IntelMemory *imem = new IntelMemory;

    Computer *com1 = new Computer(ic,ivc,imem);
    com1->doWork();
    delete com1; 
} 

int main(int argc, char** argv) {
    test();
    return 0;
}

---

5.文件操作

文件类型分为2类：
1.文本文件：文本以ASCII码形式存储在计算机中
2.二进制文件：文本以二进制形式存储在计算机中

头文件：<fstream>

操作文件的三大类：
1.ofstream：写操作
2.ifstream：读操作
3.fstream：读写操作

5.1文本文件

5.1.1 写文件

写文件步骤：
1.包含头文件
#include <fstream>
2.创建流对象
ofstream ofs;
3.打开文件
ofs.open("文件路径"，打开方式)
4.写数据
ofs<<"数据"；
5.关闭文件
ofs.close();

文件的打开方式：

打开方式	解释
ios::in	读
ios::out	写
ios::ate	初始位置：文件尾
ios::app	追加方式写文件
ios::trunc	如果文件存在，先删除 再创建
ios::binary	二进制形式

//文本文件 写文件
void test()
{
    ofstream ofs;
    ofs.open("test.txt",ios::out);
    ofs<<"张三 18";
    ofs.close(); 
} 

5.1.2 读文件

读文件步骤：
1.包含头文件
#include <fstream>
2.创建流对象
ifstream ifs;
3.打开文件
ifs.open("文件路径"，打开方式)
4.写数据
四种方式读取；
5.关闭文件
ifs.close();

void test()
{
    ifstream ifs;
    ifs.open("test.txt",ios::in);
    if(!ifs.is_open())
    {
        cout<<"文件打开失败"<<endl;
        return;
    }
    //方式1：读数据
//  char buf[1024] = {0};
//  while(ifs >> buf) 
//  {
//      cout<<buf<<endl;
//  }
    //方式2：读数据
//  char buf[1024] = {0};
//  while(ifs.getline(buf,sizeof(buf)))
//  {
//      cout<<buf<<endl;
//  } 
    //方式3：读数据
//  string buf;
//  while(getline(ifs,buf))
//  {
//      cout<<buf<<endl;
//  }
    //方式4：读数据
    char c;
    while((c = ifs.get())!=EOF)
    {
        cout<<c;
    }
    ifs.close();
}

5.2 二进制文件

以二进制的方式对文件进行读写操作，
打开方式要指定为ios::binary

5.2.1 二进制方式写文件

class Person
{
public:
    char m_Name[64];
    int m_age;  
} ;

void test()
{
    //1.引入头文件 #include <fstream>
    
    //2.创建流对象
    ofstream ofs;//或者ofs("person.txt",ios::out|ios::binary); 
    //3.打开文件
    ofs.open("person.txt",ios::out|ios::binary);
    //4.写文件 
    Person p = {"张三",18};
    ofs.write((const char*)&p,sizeof(Person));
    //5.关闭文件
    ofs.close(); 
}

5.2.2 二进制方式读文件

二进制方式读文件主要利用流对象的成员函数read
函数原型：istream& read(char *buffer,int len);

class Person
{
public:
    char m_Name[64];
    int m_age;  
} ;

void test()
{
    //1.引入头文件
    
    //2.创建流对象
    ifstream ifs;
    //3.打开文件
    ifs.open("person.txt",ios::in);
    if(!ifs.is_open())
    {
        cout<<"文件打开失败！"<<endl;
        return;
    }
    // 4.读文件
    Person p;
    ifs.read((char *)&p,sizeof(Person)); 
    cout<<p.m_age<<" "<<p.m_Name<<endl;      
}

继续当一名咸鱼(￣︶￣)!

Stay hungry，Stay foolish！