Efficient implementation of dynamiccast with template function and specialization function

Catalog

One 、 summary

Two 、 template function

3、 ... and 、 Template specialization

1、 Full specialization

2、 Local specialization

Four 、dynamicCast Template implementation of

5、 ... and 、 Reference resources

---

One 、 summary

         A template is a parameterized polymorphic tool So called parameterized polymorphism , Refers to the processing of the program Object type parameterization , So that a piece of program code can be used to deal with many different types of objects . Using template programming , It can provide a code sharing mechanism for various programs with the same logic function and different data types . Templates include function templates （function template）、 Class template （class template）. This article mainly discusses function templates

Two 、 template function

         Function templates provide a unique piece of function code for all functions , Enhance the versatility of function design . The method of using function template is to explain the function template first , Then instantiate the corresponding template function to call and execute Function templates are not functions , Cannot be executed to replace the type parameter in the code to get the template function —— Instantiation , The instantiated template function is a real function , Can be executed .

         Before instantiation , First check the template code itself , Check whether the syntax is correct ; Syntax errors will be found here , If you omit a semicolon, etc . During instantiation , Check the template code , See if all calls are valid . Invalid calls will be found here , For example, the instantiation type does not support some function calls or operators . Ordinary functions only need to declare , You can compile successfully , For template compilation, you need to view the definition of the template ( The declaration and definition should be placed in the same .h file ）.

3、 ... and 、 Template specialization

1、 Full specialization

template <class T1,class T2>
void calc(T1 a, T2 a)
{
}

template <>
void calc(double a, double a)
{
}

2、 Local specialization

(1)、 Local specialization parameter

template <class T1,class T2>
void calc(T1 a, T2 b)
{
}

template <>
void calc(T1 a, double b)
{
}

(2)、 Local specialization to pointer type

template <class T1,class T2>
void calc(T1 a, T2 b)
{
}

template <class T1,class T2>
void calc(T1* a, T2 *b)
{
}

(3) Example

         Suppose we now have such a template function max：

template <typename T> const T& max(const T& a, const T& b) {

return a < b ? b : a;

}

         And now we're going to compare the size of the two strings , Such as ：

const char* str1 = "ttt"; const char* str2 = "ccc";

         At this point, if you follow the general instantiation , The comparison will be str1 and str2 Size , That is, compare the pointer value size , Not string size , So we need to implement the specialization of a template function , as follows ：

template<> const char* const& max(const char* const& a, const char* const& b) {

return strcmp(a, b) < 0 ? b : a;

}

Four 、dynamicCast Template implementation of

class A
{
public:
	virtual ~A(){}
	virtual int getType()
	{
		return 0;
	}
};

class B:public A
{
public:
	virtual int getType()
	{
		return 1;
	}
};
template <class Target, class Source> 
inline Target* dynamicCast(Source* x) 
{ 
	Target tmp = dynamic_cast<Target>(x); 
	return tmp; 
} 
template<>

inline B* dynamicCast(A* x) 
{ 
	if(x->getType()==1)
	{
		return (B*)(x);
	}
	return NULL; 
}
int _tmain(int argc, _TCHAR* argv[])
{

	A* a=new B();
	B*b=dynamicCast<B>(a);
	delete a;
	return 0;
}

5、 ... and 、 Reference resources

How will I reimplement dynamic_cast？ - VoidCC