C++中的模板类&模板函数

template<typename T>
class POLYGON
{
public:
    POLYGON();
public:
    void convhull(std::vector<T> &input, std::vector<T> &result);
};

template<typename T>
class POLYGON
{
public:
    POLYGON();
	template<typename T1> void test(T1 a);
public:
    void convhull(std::vector<T> &input, std::vector<T> &result);
};

template<typename T>
class POLYGON
{
public:
    POLYGON();
    T pointFromVeh2grd(const T &ptVeh, const double &vehX, const double &vehY, const float &vehYaw){
        return ptGrd;
    }
	template<typename T1> void test(T1 a);
public:
    void convhull(std::vector<T> &input, std::vector<T> &result);
};

//在源文件中进行显式初始化及实现
//显式初始化
template class AXIS_CONVERT<int>;
template void AXIS_CONVERT::test<double>(double);
//函数功能实现
template<typename T> template<typename T1>
void AXIS_CONVERT<T>::test(T a)
{
    std::cout<<a<<std::endl;
}

#include <iostream>
#include <cstring>
//	函数模板
template <class T>
int compare(const T left, const T right)
{
    std::cout <<"in template<class T>..." <<std::endl;
    return (left - right);
}
//  一个特化的函数模版
template < >
int compare<const char*>(const char* left, const char* right)
{
    std::cout <<"in special template< >..." <<std::endl;
    return strcmp(left, right);
}
//  这个其实本质是函数重载
int compare(char* left, char* right)
{
    std::cout <<"in overload function..." <<std::endl;
    return strcmp(left, right);
}
int main( )
{
    compare(1, 4);
    const char *left = "abcdef";
    const char *right = "wild_wolf";
    compare(left, right);
    return 0;
}

#include <iostream>
#include <cstring>
#include <cmath>
#include"tt.h"
// general version
template<class T>
class Compare
{
public:
    static bool IsEqual(const T& lh, const T& rh)
    {
        std::cout << "in the general class..." << std::endl;
        return lh == rh;
    }
};
// specialize for float
template<>
class Compare<float>
{
public:
    static bool IsEqual(const float& lh, const float& rh)
    {
        std::cout << "in the float special class..." << std::endl;
        return std::abs(lh - rh) < 10e-3;
    }
};
// specialize for double
template<>
class Compare<double>
{
public:
    static bool IsEqual(const double& lh, const double& rh)
    {
        std::cout << "in the double special class..." << std::endl;
        return std::abs(lh - rh) < 10e-6;
    }
};
int main(void)
{
    Compare<int> comp1;
    std::cout << comp1.IsEqual(3, 4) << std::endl;
    std::cout << comp1.IsEqual(3, 3) << std::endl;
    Compare<float> comp2;
    std::cout << comp2.IsEqual(3.14, 4.14) << std::endl;
    std::cout << comp2.IsEqual(3, 3) << std::endl;
    Compare<double> comp3;
    std::cout << comp3.IsEqual(3.14159, 4.14159) << std::endl;
    std::cout << comp3.IsEqual(3.14159, 3.14159) << std::endl;
    std::cout << hh<string>()("11") << std::endl;
    system("pause");
    return 0;
}

#include<string>
using std::string;
template<typename key>
class hh
{
public:
	size_t operator()(const key& k) const {
		size_t hashVal = 0;
		key tmp = k;
		while (tmp > 0) {
			hashVal = 37 * hashVal + tmp % 10;
			tmp /= 10;
		}
		return hashVal;
	}
};
template<>
class hh<string>
{
public:
	 size_t operator()(const string& key) {
		size_t hashVal = 0;
		std::cout << key << std::endl;
		for (char ch : key) {
			std::cout << "hasVal: " << hashVal << std::endl;
			hashVal = 37 * hashVal + ch;
		}
		return hashVal;
	}
};