目录
一、继承
作用：减少重复代码
1.继承的基本语法
class 子类：继承方式 父类
子类也称为派生类：包含两大部分：一类是从基类继承过来的，一类是自己增加的成员
父类也成为基类
2.继承方式
公共继承、保护继承、私有继承
3.继承中构造和析构顺序
先构造父类，再构造子类，析构的顺序相反。
4.继承同名成员处理方式
当子类与父类出现同名的成员，访问子类同名成员：直接访问、访问父类同名成员：需加作用域。
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
m_a = 100;
}
void func()
{
cout << "Base下func" << endl;
}
void func(int a)
{
cout << "Base下func(int a)" << endl;
}
int m_a;
};
class Son :public Base
{
public:
Son()
{
m_a = 200;
}
void func()
{
cout << "Son下func" << endl;
}
int m_a;
};
void test1()//同名成员属性
{
Son s;
cout <<"Son 下 m_A=" << s.m_a <<endl;
cout <<"Base下 m_A=" << s.Base::m_a << endl;
}
void test2()//同名成员函数
{
Son s;
s.func();
s.Base::func();//注：如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
//如果想访问父类中被隐藏的同名成员函数，需加作用域
s.Base::func(100);
}
int main()
{
test1();
test2();
system("pause");
return 0;
}5.继承同名静态成员处理方式
静态成员和非静态成员出现同名，处理方式一致。
void test()
{
//通过对象访问
Son s;
cout << "Son下m_a=" << s.m_a << endl;
cout << "Base下m_a=" << s.Base::m_a << endl;
//通过类名访问
cout << "Son下m_a=" << Son::m_a << endl;
cout << "Son下m_a=" << Son::Base::m_a << endl;
//第一个：代表通过类名访问、第二个：代表访问父类作用域下
}6.多继承语法
c++允许一个类继承多个类
语法：class 子类：继承方式 父类1，继承方式 父类2...
多继承可能会引发父类中有同名成员出现，需要加作用域区分
7.菱形继承
两个派生类继承同一个基类
又有某个类同时继承这两个派生类
二、多态
1.多态的基本概念
（1）多态分为两类
静态多态：函数重载和运算符重载属于静态多态，复用函数名：函数地址早绑定(运行阶段确定函数地址)
动态多态：派生类和虚函数实现运行时多态：函数地址晚绑定（运行阶段确定函数地址）
（2）多态满足条件：有继承关系、子类重写父类中的虚函数
（3）多态使用：父类指针或引用指向子类对象
2.多态案例——计算器类
实现两个操作数进行计算的计算器类
#include<iostream>
using namespace std;
//实现计算器抽象类
class Calculator
{
public:
virtual int getResult()
{
return 0;
}
int m_Num1;
int m_Num2;
};
//加法计算器类
class AddCalculator:public Calculator
{
public:
int getResult()
{
return m_Num1+m_Num2;
}
};
//减法计算器类
class SubCalculator :public Calculator
{
public:
int getResult()
{
return m_Num1 - m_Num2;
}
};
//乘法计算器类
class MulCalculator :public Calculator
{
public:
int getResult()
{
return m_Num1 * m_Num2;
}
};
void test1()
{
//父类指针或引用指向子类对象
Calculator *c=new AddCalculator;
c->m_Num1 = 10;
c->m_Num2 = 10;
cout << c->m_Num1 << "+" << c->m_Num2 << "=" << c->getResult() << endl;
//堆区数据用完后记得销毁
delete c;
}
int main()
{
test1();
system("pause");
return 0;
}3.纯虚函数和抽象类
（1）在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数。
（2）纯虚函数语法：virtual 返回值类型 函数名 （参数列表）=0；
（3）当类中有了纯虚函数，这个类也成为抽象类。
抽象类特点：无法实例化对象；子类必须重写抽象类中的纯虚函数，否则也属于抽象类.
#include<iostream>
using namespace std;
class Base
{
public:
virtual void func() = 0;
};
class Son :public Base
{
public:
void func() {};//子类必须重写父类中的纯虚函数，否则也无法实例化对象
};
void test1()
{
//父类指针或引用指向子类对象
Base *base=new Son;
base->func();
}
int main()
{
test1();
system("pause");
return 0;
}4.多态案例——制作饮品
案例描述：制作饮品的大致流程为：煮水、冲泡、倒入杯中、加入辅料；提供抽象制作饮品基类，提供子类制作咖啡和茶叶。
#include<iostream>
using namespace std;
class AbstractDrinking
{
public:
virtual void Boil() = 0;
virtual void Brew() = 0;
virtual void PourInCup() = 0;
virtual void PutSomething() = 0;
void makeDrink()
{
Boil();
Brew();
PourInCup();
PutSomething();
}
};
class Coffee :public AbstractDrinking
{
public:
virtual void Boil()
{
cout << "煮农夫山泉" << endl;
}
virtual void Brew()
{
cout << "冲泡咖啡" << endl;
}
virtual void PourInCup()
{
cout << "倒入杯中" << endl;
}
virtual void PutSomething()
{
cout << "加入糖和牛奶" << endl;
}
};
class Tea :public AbstractDrinking
{
public:
virtual void Boil()
{
cout << "煮矿泉水" << endl;
}
virtual void Brew()
{
cout << "冲泡茶叶" << endl;
}
virtual void PourInCup()
{
cout << "倒入杯中" << endl;
}
virtual void PutSomething()
{
cout << "加入枸杞" << endl;
}
};
void doWork(AbstractDrinking* abs)//AbstractDrinking* abs=new Coffee
{
abs->makeDrink();
delete abs;
}
void test1()
{
doWork(new Coffee);
}
int main()
{
test1();
system("pause");
return 0;
}5.虚析构和纯虚析构
（1）多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
（2）解决方式：将父类中的析构函数改为虚析构或者纯虚析构
（3）虚析构和纯虚析构共性：可以解决父类指针释放子类对象、都需要具体的函数实现
虚析构和纯虚析构区别：如果是纯虚析构，该类属于抽象类，无法实例化对象
（4）虚析构语法：virtual ~类名（）{}
纯虚析构语法：：virtual ~类名（）=0；
类名：：~类名（）{}
#include<iostream>
using namespace std;
#include<string>
class Animal
{
public:
Animal()
{
cout << "Animal构造函数调用" << endl;
}
virtual ~Animal()//虚析构：可以解决父类指针释放子类对象时不干净的问题
{
cout << "Animal析构函数调用" << endl;
}
virtual void speak() = 0;
};
class Cat :public Animal
{
public:
Cat(string name)
{
m_name =new string(name);
cout << "Cat构造函数调用" << endl;
}
void speak()
{
cout <<*m_name << "小猫在说话" << endl;
}
~Cat()
{
if (m_name != NULL)
{
cout << "Cat析构函数调用" << endl;
delete m_name;
m_name = NULL;
}
}
string* m_name;
};
void test1()
{
Animal* animal = new Cat("Tom");//父类指针指向子类对象
animal->speak();
delete animal;
}
int main()
{
test1();
system("pause");
return 0;
}6.多态案例——电脑组装
电脑主要组成部件为CPU、显卡、内存条
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作
#include<iostream>
using namespace std;
#include<string>
class CPU
{
public:
virtual void calculate() = 0;
};
class VideoCard
{
public:
virtual void diaplay() = 0;
};
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;
}
//提供工作的函数
void Work()
{
//让零件工作起来，调用接口
m_cpu->calculate();
m_vc->diaplay();
m_mem->storage();
}
//提供析构函数释放3个电脑零件
~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;
}
}
private:
CPU* m_cpu;
VideoCard* m_vc;
Memory* m_mem;
};
//具体零件厂商
class IntelCpu :public CPU
{
void calculate()
{
cout << "Intel的CPU开始计算了" << endl;
}
};
class IntelVideoCard :public VideoCard
{
void diaplay()
{
cout << "Intel的显卡开始了" << endl;
}
};
class IntelMemory :public Memory
{
void storage()
{
cout << "Intel的内存条开始了" << endl;
}
};
class LenovoCpu :public CPU
{
void calculate()
{
cout << "Intel的CPU开始计算了" << endl;
}
};
class LenovoVideoCard :public VideoCard
{
void diaplay()
{
cout << "Intel的显卡开始了" << endl;
}
};
class LenovoMemory :public Memory
{
void storage()
{
cout << "Intel的内存条开始了" << endl;
}
};
void test01()
{
//第一台电脑零件
CPU* intelCpu = new IntelCpu;
VideoCard* intelcard = new IntelVideoCard;
Memory* intelmem = new IntelMemory;
//创建第一台电脑
Computer* computer1 = new Computer(intelCpu, intelcard, intelmem);
computer1->Work();
delete computer1;
}
int main()
{
test01();
system("pause");
return 0;
}三、文件操作
（1）程序运行时产生的数据都属于临时数据，程序一旦结束都会被释放，通过文件可以将数据持久化。
（2）c++中对文件操作需要包含头文件<fstream>
（3）文件类型分为两种：文本文件（ASCII码形式存储）、二进制文件（二进制形式存储）
（4）操作文件的三大类：ofstream(写操作）ifstream(读操作) fstream(读写操作)
1.文本文件
（1）写文件
写文件步骤如下：
a.包含头文件 #include<fstream>
b.创建流对象 ofstream ofs;
c.打开文件 ofs.open("文件路径",打开方式);
d.写数据 ofs<<"写入的数据";
e.关闭文件 ofs.close();
文件打开方式
（2）读文件
读文件步骤如下：
a.包含头文件 #include<fstream>
b.创建流对象 ifstream ifs;
c.打开文件并判断文件是否打开成功 ifs.open("文件路径"，打开方式)
d.读数据 四种方式读取
e.关闭文件 ifs.close();
2.二进制文件
以二进制的方式对文件进行读写操作，打开方式要指定为ios::binary
教程地址：黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili
扫一扫
4033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
