泛型编程.cpp

--程序设想----------------------------------------------------------------------

//输入个数不等的 参数列表 到 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;

};



------------------------------------------------------------------------

未完，待续......

------------------------------------------------------------------------