c++学习6

一.继承

1.菱形继承

子类的多个父类，继承了同一个类，被称为菱形继承；其底层的子类中继承的成员会继承多次。

2.虚进程

用于解决菱形继承中多份公共祖先的数据问题
在继承前面添加virtual关键词，子类虚继承父类，子类只会保存一份公共数据。

#include <iostream>
#include<string.h>
using namespace std;
class Animal
{
public:
	int data;
};
class Sheep :virtual public Animal{};
class Tuo :virtual public Animal{};
class SheepTuo :public Sheep,public Tuo{};
int main()
{
	SheepTuo ob;
	cout<<ob.data<<endl;
	return 0;
}

继承中尽量使用单继承

二.多态

静态多态：函数重载、运算符重载、重定义
动态多态：虚函数

1.虚函数

当父类指针指向子类空间地址，调用子类中重写的方法时，其方法是父类的方法，而不是子类的方法

class Animal
{
public:
	void speak(){
		cout<<"动物在说话"<<endl;
	}
};
class Dog:public Animal
{
public:
	void speak(){
		cout<<"狗在说话"<<endl;
	}
};
int main(){
	Animal *p = new Dog;
	p->speak();//动物在说话
	return 0;
}

虚函数就是为了解决这种父类指针能调用子类的数据


1.1 虚函数定义

class Animal
{
public:
	//子类重写父类的虚函数：函数名、返回值类型、参数类型个数顺序要一样
	virtual void speak(){
		cout<<"动物在说话"<<endl;
	}
};
class Dog:public Animal
{
public:
	virtual void speak(){
		cout<<"狗在说话"<<endl;
	}
};
class Cat:public Animal
{
public:
	void speak(){//可以不用写virtual
		cout<<"狗在说话"<<endl;
	}
};
int main(){
	Animal *p1 = new Dog;
	p1->speak();//狗在说话
	Animal *p2 = new Cat;
	p2->speak();//猫在说话
	return 0;
}

1.2 动态绑定机制

• 类中存在虚函数时，会产生一个虚函数指针，其指向一张虚函数表
• 如果这个类没有涉及到子类重写虚函数，这时虚函数表中记录的就是当前虚函数的入口地址，父类指针调用方法时还是父类的方法
• 当子类重写了虚函数，则会将虚函数地址覆盖虚函数表中的原来的地址

2.重载、重定义、重写

• 重载：同名、参数个数不同。函数返回值不能当作重载条件
• 重定义：继承中同名、参数个数不同函数
• 重写：在继承中同名函数、除了函数内容不同其他的都相同

3.纯虚函数

声明纯虚函数需要两个条件：

• 该类一定有被继承
• 子类一定会重写该函数

3.1纯虚函数的定义：

class Animal
{
public:
	virtual void speak() = 0;
}

当类中有纯虚函数，那么这个类就是抽象类：

• 抽象类不能实例化对象（Animal ob这是错误的）
• 抽象类必须被继承，且要重写父类的纯虚函数，否则子类也是抽象类
• 抽象类主要的目的是涉及类的接口

4.虚析构函数

virtual修饰构造函数，作用是通过释放父类指针来释放子类空间

5.纯虚析构函数

• 其纯虚析构函数不能被继承
• 必须要为纯虚析构函数提供一个函数体
• 纯虚析构函数必须在类外实现

class Animal
{
public:
	virtual void speak()=0;
	virtual ~Animal()=0;
};
class Dog:public Animal
{
public:
	void speak(){
		cout<<"狗在说话"<<endl;
	}
	~Dog(){}
};
Animal::~Animal(){
	cout<<"Animal的析构函数";
}
int main(){
	Animal *p = new Dog;
	p->speak();//动物在说话
	delete p;
	return 0;
}

三.模板

• c++有两个编程思想：
  面向对象编程：封装、继承、多态
  泛型编程思想：模板
• 模板的分类：函数模板、类模板
• 模板是将功能相同，类型不同的函数（类）的类型抽象成虚拟的类型，当调用函数（类实例化对象）的时候，编译器自动将虚拟的类型具体化， 这就是函数模板（类模板）。

1.函数模板

1.1 模板的定义
使用关键词template

//T只对当前函数有效
template<typename T>
void swapALL(T &a,T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}
int main(){
	int a = 10,b = 20;
	//函数被调用时会根据实参的类型，自动推导处T的类型
	swapAll(a1,b1);//20，10
	
	char a1 = 'a',b1 = 'b';
	swapAll(a1,b1);//b，a
}

函数模板会编译两次：
第一次：是对函数模板本身编译
第二次：是在函数调用时将T的类型具体化
使用函数模板是为了实现泛型，可以减轻编程的工作量，增强函数的重用性


1.2 注意点：

• 函数模板和普通函数相同时，优先调用普通模板
• 当要强制使用函数模板时需要使用<>：swapAll<>(a，b)；<>中可以添加基本类型，来强制定义其模板类型
• 函数模板自动类型推导时全部只能是同一个类型，且无法进行自动类型转换

1.3 函数的重载
可以通过改变函数模板参数的数量进行重载

1.4 函数模板的局限性
函数模板推导出T为数组或者自定义类型时，可能会出现运算符不识别，无法使用运算符实现预期的目标
解决方法一：运算符重载（推荐）

#include<iostream>
using namespace std;
class Data
{
	friend ostream& operator<<(ostream& out,Data ob);
private:
	int data;
public:
	Data(){}
	Data(int data){
		this->data = data;
	}
};
ostream& operator<<(ostream& out,Data ob)
{
	out<<ob.data;
	return out;
}

template<typename T>void myPrintAll(T a){
	cout<<a<<endl;
}
int main(){
	Data ob1(100);
	myPrintAll(ob1);
	return 0;
}

解决方法二：具体化函数模型

#include<iostream>
using namespace std;
template<typename T>void myPrintAll(T a){
	cout<<a<<endl;
}

class Data
{
	friend void myPrintAll<Data>(Data a);
private:
	int data;
public:
	Data(){}
	Data(int data){
		this->data = data;
	}
};
//具体化函数模板
template<> void myPrintAll<Data>(Data a){
	cout<<a<<endl;
}

int main(){
	Data ob1(100);
	myPrintAll(ob1);
	return 0;
}

该函数模板调用时会先寻找到函数模板，当遇到无法正常使用的运算符时，会去寻找具体化的函数模板

搞钱的第六天，加油