多态和模板

多态

函数重写（名字遮蔽）：在子类中定义与父类相同的函数
函数重写只发生在父类和子类之间
多态：一种代码写法，多种表现（输出）形式
解决方法：
c++通过virtual关键字对多态进行支持
使用virtual声明的函数被重写后即可展现多态特性

多态成立的条件：
1、要有继承
2、要有虚函数重写
3、用父类指针指向了子类对象

静态联编和动态联编：
1、联编是指一个程序模块，代码之间互相关联的过程。
2、静态联编，是程序的匹配，连接在编译阶段实现，也称为早期匹配。重载函数使用静态联编
3、动态联编是指程序联编推迟到运行时进行，所以又称为晚期联编（迟绑定）。switch语句和if语句是动态联编的例子

#include<iostream>
using namespace std;

class A
{
public:
	virtual void print()
	{
		cout << "AAAAAA" << endl;
	}
};

class B:public A
{
public:
	void print()
	{
		cout << "BBBBBB" << endl;
	}
};

int main()
{
	A* pa = new A;
	pa->print();

	pa = new B;
	pa->print();//在编译时确定，称之为静态联编
	return 0;
}

虚析构函数：
在什么情况下应该声明为虚函数
构造函数不能是虚函数，建立一个派生类对象时，必须从类层次的跟开始，沿着继承路径，逐个调用基类的构造函数
析构函数是可以是虚的。虚析构函数用于指引delete运算符正确析构动态对象
虚析构函数：通过父类释放子类对象

#include<iostream>
using namespace std;

class A
{
public:
	A(int l);
	virtual ~A();
protected:
	int m_len;
};

A::A(int l)
{
	cout << "A的构造函数被调用" << endl;
	m_len = l;
}
A::~A()
{
	cout << "A的析构函数被调用" << endl;
}

class Array :public A
{
public:
	Array(int l);
	~Array();
private:
	char* m_data;
};
Array::Array(int l) :A(l)
{
	cout << "Array 析构函数被调用！" << endl;
	m_data = new char[m_len + 1];
}
Array::~Array()
{
	cout << "Array的析构函数被调用！" << endl;
	delete m_data;//不用virtual，造成子类的指针没有办法被释放！
}


int main()
{
	A* pa = new Array(10);
	delete pa;

	return 0;
}

析构函数为什么一定要声明为虚函数：
因为当基类的指针指向子类的对象时，基类指针释放时是不会调用子类的析构函数的，会导致子类的指针没有办法被释放

多态的实现原理：
当类中声明虚函数时，编译器会在类中生成一个虚函数表
虚函数表是一个存储类成员函数指针的数据结构
虚函数表是由编译器自动生成与维护的
virtual成员函数会被编译器放入虚函数表中
当存在虚函数时，每个对象中都有一个指向虚函数表的指针（c++编译器给父类对象，子类对象提前布局vptr指针；当进行函数调用时，c++编译器不需要区分子类对象或者父类对象，只需要再base指针中，找vptr指针即可）
VPTR一般作为类对象的第一个成员

在效率上，虚函数的效率要低的多

构造函数中调用虚函数能否实现多态：
构造的顺序是先构造父类，再构造子类。
当调用父类的构造函数的时候。虚函数指针vfptr指向父类的虚函数表
当父类构造完后，调用子类的构造函数时，虚函数指针vfptr指子类的虚函数表
结论：构造函数中无法实现多态

#include<iostream>

using namespace std;

class A
{
public:
	A();
	virtual void show();//添加一个虚函数表指针
public :
	int m_a;
};

A::A()
{
	m_a = 1;
	show();
}
void A::show()
{
	cout << "AAAAAA"<<endl;
}

class B :virtual public A//+virtual or 不加
{
public:
	void show();
	int m_b;
};
void B::show()
{
	cout << "BBBBBB" << endl;
}
int main()
{
	A a;
	B b;
	//cout << &a << endl;
	//cout << &a.m_a << endl;
	cout << sizeof(A) << endl;
	cout << sizeof(B) << endl;
	cout << &b << endl;
	cout << &b.m_b << endl;
	cout << &b.m_a << endl;

	A* pa = &b;
	cout << pa << endl;
	cout << pa + 1 << endl;

	return 0;
}

纯虚函数：
纯虚函数是一个在基类中说明的虚函数，在基类中没有定义，要求任何派生类都定义自己的版本
纯虚函数为各派生类提供一个公共界面（接口的封装和设计，软件的模块功能划分）
纯虚函数说明形式：
virtual 类型 函数名（参数表）=0；
一个只有纯虚函数的基类称为抽象类

抽象类：
含有纯虚函数的类
抽象类不能用于直接创建对象实例，可以声明抽象类的指针和引用
可使用指向抽象类的指针支持运行时多态性
派生类中必须实现基类中的纯虚函数，否则它仍将被看做一个抽象类

#include<iostream>
using namespace std;

class A    //抽象类
{
public:
	A();
	virtual void print() = 0;//纯虚函数没有函数体
private:
	int m_a;
};

class B :public A
{
public:
	B(int b);
	void print();//派生类只有实现了纯虚函数才能实例化，否则就还是抽象类
private:
	int m_b;
};
B::B(int b)
{
	m_b = b;
}
void B::print()
{
	cout << "m_b=" << m_b << endl;
}
A::A()
{
	m_a = 1;
}

int main()
{
	//A a;//不能被实例化
	//A* a=new A;//可以定义一个指针或者引用，但不能指向别的
	//A* a;
	B b[5] = { B(1),B(2),B(3),B(4),B(5) };//派生类的对象数组
	A* pa = b;//如果派生类的大小和父类的大小不一样的时候，就不能用基类的指针指向子类的对象数组，因为步长不一样
	cout << sizeof(A) << endl;
	cout << sizeof(B) << endl;
	pa[2].print();
	cout << pa << endl;
	cout << b << endl;
	cout << pa + 1 << endl;
	cout << b + 1 << endl;
	return 0;
}

c++中没有Java的接口概念，抽象类可以模拟Java中的接口类。（接口和协议）
接口类只是一个功能说明，而不是功能实现

//类的函数不占用内存空间

模板

c++提供了函数模板：
所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表，这个通用的函数就称为函数模板。凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需要在模板中定义一次即可，在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能

c++提供了两种模板机制：函数模板和类模板
类属——类型参数化，又称为参数模板
使得程序（算法）可以从逻辑功能上抽象，把被处理的对象（数据）类型作为参数传递
总结：
模板把函数或类要处理的数据类型参数化，表现为参数的多态性，称为类属。
模板用于表达逻辑结构相同，但具体数据元素类型不同的数据对象的通用行为。

函数模板定义形式
template<类型形式参数表>
类型形式参数的形式：
typename T1,typename T2,…typename Tn
或者 class T1,class T2,…class Tn
函数模板声明
template<类型形式参数表>
类型 函数名（形式参数表）
{
语句序列
}
函数模板定义由模板说明和函数定义组成
模板说明的类属参数必须在函数定义中至少出现一次
函数参数表中可以使用类属类型参数，也可以使用一般类型参数

函数模板机制：
编译器并不是把函数模板处理成能够处理任意类的函数
编译器从函数模板通过具体类型产生不同的函数
编译器会对函数模板进行两次编译
在声明的地方对模板代码本身进行编译；在调用的地方对参数替换后的代码进行编译

#include<iostream>
using namespace std;

int add(int a, int b)
{
	return a + b;
}

float add(float a, float b)
{
	return a + b;
}

char add(char a, char b)
{
	return a + b;
}
int main()
{

	return 0;
}

#include<iostream>
using namespace std;

template<typename T >
T add(T a, T b)
{
	return a + b;
}
int main()
{
	cout << add(1, 2) << endl;//隐式调用
	cout << add(1.2f, 3.4f) << endl;
	cout << ('a', 'b') << endl;

	cout << add<int>(2, 2) << endl;//显式调用

	cout << add<int>(1, 1.2f) << endl;//一定要显式调用
	return 0;
}

函数模板和普通函数区别：
函数模板不允许自动类型转化
普通函数能够进行自动类型转换

在没有声明类型的时候，我们优先会调用普通函数；
当指定类型时，会优先使用模板

#include <iostream>

using namespace std;

void print(int x, int y)
{
	cout << "void print(int ,int)" << endl;
}

template<typename T>
void print(T x, T y)
{
	cout << "void print (T,T)" << endl;
}


int main()
{
	print(1, 2);//在没有声明类型的时候，我们优先会调用普通函数；当指定类型时，会优先使用模板
	return 0;
}

为什么要有类模板：
类模板用于实现类所需数据的类型参数化
类模板在表示如数组，表，图等数据结构显得特别重要，这些数据结构的表示和算法不受所包含的元素类型的影响

类模板在创建对象时一定要显式调用

#include<iostream>
 
using namespace std;

template<typename T>

class complex      //类模板
{
public:
	complex(T a, T b);
	void print();
	template<typename U>
	friend ostream& operator<<(ostream& out, complex<U>& c);
private:
	T m_a;
	T m_b;
};

template<typename U>
ostream& operator<<(ostream& out, complex<U>& c)
{
	cout << c.m_a << "+" << c.m_b <<"i"<< endl;
}
template<typename T>
complex<T>::complex(T a, T b)
{
	m_a = a;
	m_b = b;
}
template<typename T>
void complex<T>::print()
{
	cout << m_a << "+" << m_b << "i" << endl;
}

int main()
{
	complex<int>c(1, 2);//类模板在创建对象时一定要显式调用
	c.print();
	cout << c;
	return 0;
}

不同继承：

#include<iostream>

using namespace std;

template<typename T>
class A
{
public:
	A(T a);
protected:
	T m_a;
};
template<typename T>
A<T>::A(T a)
{
	m_a = a;
}

class B :public A<int>//显式继承：派生类是普通类
{
public:
	B(int b);
private:
	int m_b;
};

B::B(int b) :A<int>(1)
{
	m_b = b;
}
template<typename T,typename T1>
class C :public A<T>//派生类还是类模板
{
public:
	C(T1 c, T a);
	void print();
private:
	T m_c;
};
template<typename T, typename T1>
void C<T, T1>::print()
{
	cout << m_c << endl;
}

template<typename T, typename T1>
C<T, T1>::C(T1 c, T a) :A<T>(a)
{
	m_c = c;
}

int main()
{
	B b(1);
	C<int, double>c(1, 2.11);
	c.print();
	return 0;
}

类模板中的关键字：static

从类模板实例化的每个模板类都有自己的类模板数据成员，该模板类的所有对象共享一个static数据成员
和非模板类的static数据成员一样，模板类的static数据成员也应该在文件范围定义和初始化
每个模板类有自己的类模板的static数据成员副本

#include<iostream>

using namespace std;


template <typename T>
class A
{
public:
	static int count;
	A()
	{
		count++;
	}
private:
	T m_a;
};
template<typename T>

int A<T>::count = 0;

int main()
{
	A<int>a1;
	A<int>a2;
	A<int>a3;

	A<double> a4;
	A<double> a5;

	cout << a1.count << endl;   //不同数据类型之间的类的静态成员是不共享的！
	cout << a4.count << endl;

	cout << A<int>::count << endl;
	return 0;
}

模板是c++类型参数化的多态工具。c++提供函数模板和类模板
函数定义以模板说明开始。类属参数必须在模板定义中至少出现一次
同一个类属参数可以用于多个模板
类属参数可用于函数的参数类型，返回类型和声明中的变量
模板有编译器根据实际数据类型实例化，生成可执行代码，实例化的函数模板称为模板函数；实例化的类模板称为模板类
函数模板可以用多种方式重载
类模板可以在类层次中使用