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++宏生成代码 （转）

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