C++泛型编程学习：让我们习惯在底层用C++宏生成代码 （转）

--程序设想----------------------------------------------------------------------
//输入个数不等的 参数列表 到 JoinString 里，将每个参数转换成一个字符串，再将其串起来返回。

string JoinString( 参数列表... )
{
    转换;
    返回参数列表组合成的字符串;
}

--继续优化----------------------------------------------------------------------
//使用模板可以省去不同的类型转换函数,但不同类型的T转换方法不同，又引入模板特化问题。

template < typename T >
string JoinString( const T& value )
{
    返回结果;
}

--简单垫片----------------------------------------------------------------------
//写这样的函数: string Desc( 类型 ){ 返回描述的字符串 } ，然后对不同的类型提供这个函数的重载。
（PS：boost是一个优秀的C++程序库，它的主页是：http://www.boost.org）

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

string Desc( int a )
{
    ostringstream ostr;
    ostr << a;
    return ostr.str();
}

string Desc( double dd )
{
    ostringstream ostr;
    ostr << dd;
    return ostr.str();
}

void print( string str )
{
    cout << str << endl;
}

void main()
{
    print( Desc(100) );
    print( Desc(12.4) );
}

--我的垫片----------------------------------------------------------------------
//基于boost::lexical_cast，它可以实现内置类型到字符串的转换。

template < typename T >
inline std::string GetString( const T& value )
{
    std::string strResult;
    strResult = boost::lexical_cast< std::string >(value);
    return strResult;
}

#ifndef HERO_BUILD_NOT_WITH_OGRE
template <>
inline std::string GetString( const Ogre::Vector3& value )
{
    std::ostringstream ostr;
    ostr << value;
    return ostr.str();
}
#endif

--拼接函数----------------------------------------------------------------------
//我们可能需要处理一个接受字符串的函数，
//然后我们在模板函数中使用GetString<T>(value)获取模板参数的字符串值并传递给我们的真正的处理函数。

template <typename T >
class Join_Handler
{
    public:
        typedef T            value_type;
        typedef T&           reference_type;
    public:
        Join_Handler( reference_type value ):m_objValue(value)
        {
        }
    public:
        template < typename T1 >
        inline T& SmartWrite( const T1& t1 )
        { 
            return m_objValue.SmartWirte<T1>( t1 );
        }
        private:
            reference_type m_objValue;
};

// 可以通过特化更多的Join_Handler来支持更多的PIPE。
template <>
class Join_Handler< std::string >
{
    public:
        typedef std::string         value_type;
        typedef value_type&         reference_type;
    public:
        Join_Handler( reference_type str ) : m_strPipe(str)
        {
        }
    public:
        template < typename T1 >
        inline std::string& SmartWrite( const T1& t1 )
        {
            m_strPipe.append( Hero::GetString<T1>(t1) );
            return m_strPipe;
        }
    private:
        reference_type     m_strPipe;
};

参考文档：

让我们习惯在底层用C++宏生成代码 （转）

------------------------------------------------------------------------
未完，待续......
------------------------------------------------------------------------