（六）C++之转换函数与模板

一.标准转换函数

reinterpret_cast
reinterpret_cast（expression）
将一个类型的指针转换为另一个类型的指针，它也允许从一个指针转换为整数类型
const_cast
const_cast< new type>( expression)
const指针与普通指针间的相互转换，注意：不能将非常量指针变量转换为普通变量
static_cast
static_cast(expression)
主要用于基本类型间的相互转换，和具有继承关系间的类型转换
dynamic_cast
dynamic_cast(expression)
只有类中含有虚函数才能用dynamic_cast；仅能在继承类对象间转换
dynamic_cast具有类型检查的功能，比static_cast更安全

#include <stdio.h>
#include <iostream>
#include <typeinfo>

using namespace std;

class A{
public:
	virtual void show()
	{
		cout<<"aaaaaaa"<<endl;
	}
};

class B:public A{
public:
	void show()
	{
		cout<<"bbbbbbbbbbbbaaaaaaa"<<endl;
	}

};

int main()
{
#if 0
	int a;

//	char *p = (char*)&a;
	char *p = reinterpret_cast<char *>( &a );
#endif

#if 0
	const int b = 100;
	int *q = const_cast<int*>( &b );
#endif

#if 0
	A a;	
	B &p = static_cast<B &>( a );
#endif
	try{

		A a;	
		B &p = dynamic_cast<B &>( a );
	}
	catch(bad_cast e)
	{
		cout<<e.what()<<endl;
	}
}

二.自定义转换函数

成员转换函数： 
class  A{
public:
	A(int x):data(x){ }
	operator int() const{      //无返回
		reutn data;
	}
Private:
	int data;
};

三.隐式转换（explicit）

#include <iostream>

using namespace std;

class mempool{
public:
	explicit mempool(int size){
		data = new char[size];	
		cout<< "cccccccccc" <<endl;
	}
	~mempool()
	{
		delete [] data;
	}

private:
	char *data;
};

int main()
{
//	mempool a(100);
	mempool a = 100;
}

四.模板
类型模板

模板函数
//template <typename  T>
template <class  T>
T  add<T  &a, T  &b>
{
	return  a+b;
}

模板类

template <class  T>
class  List{
public:
	List();
	~List();
private:
	T  arr[100];
	int num;
};

非类型模板

template <class  T,  int   SIZE>
class  List{
public:
	List();
	~List();
private:
	T  arr[SIZE];
	int num;
};

模板特化

特化
template <>
class  List{
public:
	List();
	~List();
private:
	int  arr[100];
	int num;
};

偏特化
template <class A, class B>
class C{
	A  a;
	B  b;
};
template <class  B>
class  C<int,  B>{
};

#include <stdio.h>
#include <iostream>

using namespace std;

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

double add(double a, double b)
{
	return a+b;
}
#endif

template<typename XXX>
XXX add(XXX a, XXX b)
{
	return a+b;
}

template <>
bool add(bool a, bool b)
{
	if(a == true && b == true)
		return true;
	return false;
}

int main()
{
	cout<< add(1, 2) <<endl;
	cout<< add(1.1, 2.3) <<endl;
	cout<< add(true, false) <<endl;
	cout<< add(true, true) <<endl;
}