My C++面向对象笔记

4.类和对象

4.2 对象的初始化和清理

4.2.1 构造和析构函数

构造函数语法：类名(){}
析构函数语法：~类名(){}

class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};

void test01()
{
	Person p;
}

int main() {
	
	test01();

	system("pause");

	return 0;
}

4.2.2 构造函数的分类和调用

1.构造函数的分类

• 构造函数(有参/无参)
• 拷贝构造函数语法:
  //拷贝构造(将所有属性克隆)
  Person(const Person &p){age = p.age;}

2.构造函数的调用

• 括号法

Person p1;        //默认构造
Person p2(10);  //有参函数
Person p3(p2);  //拷贝函数

• 显示法

Person p1;
Person p2 = Person(10);  //有参构造
Person p3 = Person(p2); //拷贝构造

Person(10);  //匿名对象(执行结束后,立即回收) 

4.2.3 什么时候用到拷贝构造函数

• 初始化新对象

Person p1(20);
Person p2(p1);  //拷贝构造新对象

• 值传递给函数传参

void doWork1(Person p) {}  //调用函数时,值传递,自动拷贝一个新对象传递

• 值方式返回局部对象

//值为返回值,手动拷贝成一个新对象返回
Person doWork2(){
	Person p1; return p1;
}  

4.2.4 构造函数调用规则

• 默认情况下，c++编译器至少给一个类添加3个函数

  1．默认构造函数(无参，函数体为空)

  2．默认析构函数(无参，函数体为空)

  3．默认拷贝构造函数，对属性进行值拷贝

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

• 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

4.2.5 深拷贝和浅拷贝

• 浅拷贝(编译器默认的拷贝构造函数)的问题:堆区内存重复释放导致崩溃.
• 深拷贝：在堆区重新申请空间，进行拷贝操作

//重载拷贝构造函数
Person(const Person &p){
	m_Height = new int(*p.m_Height);    
}

4.2.6列表初始化

Person{
	//列表初始化所有对象属性
	Person():m_A(10),m_B(10),m_C(10){        //将10传入m_A......
	
	}
	int m_A;int m_B;int m_C;
}

4.2.7类对象作为类成员

• C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员

例如：

class A {}
class B
{
    A a；
}

• 构造的顺序是 ：先调用对象成员的构造，再调用本类构造,析构顺序与构造相反。

4.2.8静态成员(共享)

• 加static,成为静态成员
• 静态成员变量
  1.所有对象共享同一份数据
  2.在编译阶段分配内存
  3.只能类内声明,只能类外初始化
• 静态成员访问方式
  1.通过对象
  2.通过类名

Person::a = 100;

• 静态成员函数
  1.所有对象共享一个函数
  2.只能访问静态变量

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

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

4.3.2 this指针

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

Person(int age){
	this->age = age;
}

//返回对象本身
Person& PersonAddPerson(Person p){
		this->age += p.age;
		return *this;
	}

4.3.3 空指针

• C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
• 如果用到this指针，需要加以判断保证代码的健壮性

4.3.4 const修饰成员

常函数：

• 成员函数后加const后我们称为这个函数为常函数
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

• 声明对象前加const称该对象为常对象
• 常对象只能调用常函数

4.4 友元(访问private)

4.3.1全局函数做友元

• 全局函数友元语法:复制黏贴函数声明,前加friend关键字

class Building{
	//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
	friend void goodGay(Building * building);
}

4.3.2类做友元

• 友元类语法:复制黏贴类声明,前加friend

class Building{
	//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
	friend class goodGay;
}

4.3.3成员函数做友元

class Building
{
	//告诉编译器  goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
	friend void goodGay::visit();
}

4.5运算符重载(将普通数据拓展到对象类型)

4.5.1加号重载

• 作用：实现两个自定义数据类型相加的运算
• 成员函数实现 + 号运算符重载

Person operator+(const Person& p) {
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
}
Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)

• 全局函数实现 + 号运算符重载

Person operator+(const Person& p1, const Person& p2) {
	Person temp(0, 0);
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
Person p3 = p1 +p2;

4.5.2左移重载

• 作用：可以输出自定义数据类型
• 全局函数实现左移重载

costream& operator<<(costream& out, Person& p) {
	cout << "a:" << p.m_A << " b:" << p.m_B;
	return cout;  //链式编程
}

cout<<p<<endl;

4.5.3递增重载

• 不想搞

4.5.4 赋值重载

• 如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

//重载赋值运算符 
	Person& operator=(Person &p)
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;

//赋值重载调用
p3 = p2 = p1;

4.5.5 关系运算符重载

• 可以让两个自定义类型对象进行对比操作

bool operator==(Person &p){
	if(this->name == p.m_Name && this->m_Age  == p.m_Age)
		return true;
	return false;	
}

cout<<p1 == p2;

4.5.6函数调用运算符重载

• 函数调用运算符 () 也可以重载
• 由于重载后使用的方式非常像函数的调用，因此称为仿函数
• 仿函数没有固定写法，非常灵活

class MyAdd{
public:
	int operator()(int v1, int v2){
		return v1 + v2;
	}
};

void test02(){
	MyAdd add;
	int ret = add(10, 10);
	cout << "ret = " << ret << endl;

	//匿名对象调用  
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

4.6 继承

4.6.1 继承的语法

• 继承的好处:减少重复代码
• 语法: == class 子类 : 继承方式 父类 ==

class Java : public BasePage{}；
class Python ： public BasePage{};

4.6.2 继承方式

• 父类的私有内容,所有继承方式都不可访问.
• 公共继承:子类继承的属性权限不变
• 保护继承:子类继承的属性变为保护级
• 私有继承:子类继承的属性变为私有级
  

4.6.3 继承中的对象模型

• 子类拥有所有父类的非静态成员
• 父类中的private成员在子类中被隐藏,但存在
• 利用cmd查看对象模型
  1.跳转盘符 (F:)
  2.跳转文件路径 (cd 具体路径)
  3.查看命令(c1 /d1 reportSingleLayout类名 文件名)

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

• 代码略
• 总结：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

4.6.5 继承中同名成员

• 访问子类同名成员时,直接访问
• 访问父类同名成员时,需要加作用域::访问

//Son类继承Base父类
class Son : public Base
Son s;

//调用同名成员属性
cout<<"子类中的a="<<s.a<<endl;
cout<<"父类中的a="<<s.Base::a<<endl;

//调用同名成员函数
s.func();  //直接调用子类的
s.Base::func();  //加作用域调用父类的

4.6.6 继承同名静态成员

• 与非静态成员处理方式一致,加作用域访问父类的静态成员
• 1.同名静态成员属性

class Base{
public:
	static int m_a;

	staitc ovid func(){}
}
int Base:: m_a = 100;

class Son : Base{
public:
	static int m_a;

	staitc ovid func(){}
}
int Son::m_a = 200;

//方法一通过对象访问
void test01(){
	cout<<"访问Son下a值"<<s.m_a<<endl;
	cout<<"访问父类下a值"<<s.Base::m_a<<endl;
}

//方法二通过类名访问
void test02(){
	cout<<"访问Son下a值"<<Son::m_a<<endl;
	cout<<"访问父类下a值"<<Son::Base::m_a<<endl;
}

• 2.同名静态函数

//通过对象访问
void test01(){
	Son s;
	s.func();
	s.Base::func();
}

//通过类访问
void test02(){
	Son::func();
	Son::Base::func();
}

4.6.7 多继承语法

• 多继承即认多个爹(💩)
• 多继承语法:class 子类 : 继承方式 父类1 , 继承方式 父类2 …
• 多继承二义性:当父类中出现重名成员,需加作用域区分

class Son:public Base1,public Base2{}

cout<<s.Base1::m_a<<endl;
cout<<s.Base2::m_a<<endl;

4.6.8 菱形继承

• 菱形继承的概念:
  1.两个派生类继承同一个基类
  ​ 2.又有某个类同时继承者两个派生类
  ​ 3.这种继承被称为菱形继承，或者钻石继承
  

• 菱形继承的问题
  1.羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
  2.草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

• 问题2解决方法

//当菱形继承时,用作用域区分父类的相同数据
cout<<st.Sheep::m_age<<endl;
cout<<st.Tuo::m_age<<endl;

• 问题1解决方法

//利用虚继承解决二义性(继承指针，通过偏移量找到唯一数据)
class Sheep:virtual public Animal{};

class Tuo ：virtual public Animal{};

class SheepTuo:public Sheep,public Tuo{};

4.7 多态(一个接口,多个输出)

4.7.1 多态的基本概念

• 多态的分类
  1.静态多态:函数,运算符重载属于静态多条,复用函数名
  2.动态多态:派生类和虚函数实现

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

• 动态多态的满足条件
  1.有继承关系
  2.子类重写父类的虚函数

• 动态多态使用

//利用虚函数创建多态
class Animal{
	void vitrual speak() = 0;
};
//利用父类的引用或指针接受子类对象
void doSpeak(Animal &animal){      //Animal animal = new Cat;
	animal.speak();
}

• 动态多态底层原理
  虚函数指针(vfptr)指向被覆盖的子类中的虚函数表(vftable),调用子类函数

4.7.2多态案例1(计算器)

//前面略去定义父类的抽象函数和子类的重写

int main() {
	//加法计算器
	Calculator* c = new Calplus;
	c->num1 = 10; c->num2 = 20;
	cout<<c->docal()<<endl;

	//减法计算器
	c = new Calsub;
	c->num1 = 20; c->num2 = 10;
	cout<<c->docal()<<endl;
	delete c;
	return 0;
}

4.7.3纯虚函数和抽象类

• 纯虚函数
  父类中虚函数无意义,因此可将虚函数改写为纯虚函数
  纯虚函数语法: virtual 返回值类型 函数名 (参数列表) =0;

• 当类有纯虚函数时,这个类也称抽象类

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

4.7.4虚析构和纯虚析构

• 多态使用时,子类属性开辟到堆区,那么父类指针释放时无法调用子类析构代码
  解决方法:将父类中的析构函数改为虚析构或纯虚析构
  虚析构语法：

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

• 纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

• 总结：

​ 1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

​ 2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

​ 3. 拥有纯虚析构函数的类也属于抽象类

4.8 文件操作

4.8.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	二进制方式

注意： 文件打开方式可以配合使用，利用|操作符

**例如：**用二进制方式写文件 ios::binary | ios:: out

4.8.2 读文件

• 文件步骤：

1. 包含头文件

   #include <fstream>

2. 创建流对象

   ifstream ifs;

3. 打开文件并判断文件是否打开成功

   ifs.open(“文件路径”,打开方式);

4. 读数据

   四种方式读取

5. 关闭文件

   ifs.close();

• 四种读取方式

//创建输入流
ifstream ifs;
	ifs.open("test.txt", ios::in);

	if (!ifs.is_open())   //利用is_open函数判断读取是否成功
	{
		cout << "文件打开失败" << endl;
		return;
	}
	
//第一种(全部读取)
char buf[1024] = {0};
while(ifs>>buf){
	cout<<buf<<endl;
}

//第二种(逐行读取)
char buf[1024]= {0};
while(ifs.getline(buf,sizeof(buf)){
	cout<<buf<<endl;
}

//第三种(通过string读取)
string buf;
while(getline(ifs,buf)){
	cout<<buf<<endl;
}