C++ C++；模板法

我已经编写了STL basic_string类的简化版本：

template<typename chrT>
class strT
{
protected:

    chrT * m_pcBuf;

    size_t m_nLen;

public:

    strT( void );

    strT( const chrT * pcStr );

    strT( const strT<chrT> & rsStr );

    virtual ~strT( void );

    virtual inline size_t len( void ) const;

    virtual int cmp( const strT<chrT> & rsStr ) const;

    virtual inline const chrT & operator [] ( size_t nPos ) const;

    virtual inline chrT & operator [] ( size_t nPos );

    virtual bool & operator == ( const strT<chrT> & rsStr ) const;

    virtual bool & operator != ( const strT<chrT> & rsStr ) const;

    virtual bool & operator < ( const strT<chrT> & rsStr ) const;

    virtual bool & operator > ( const strT<chrT> & rsStr ) const;

    virtual bool & operator <= ( const strT<chrT> & rsStr ) const;

    virtual bool & operator >= ( const strT<chrT> & rsStr ) const;

    virtual inline strT<chrT> & operator = ( const strT<chrT> & rsStr );

    virtual inline operator chrT * ( void );

protected:

    void _alloc( size_t nLen );

    void _realloc( size_t nLen );

public:

    static const size_t none;
};

template<typename inchr, typename outchr>
strT<outchr> convert( const strT<inchr> & rsIn );

typedef strT<char> str;
typedef strT<wchar_t> wstr;

模板
类strT
{
受保护的：
chrT*m_pcBuf；
尺寸；
公众：
strT（无效）；
strT（常数chrT*pcStr）；
strT（常量strT和rsStr）；
虚拟strT（void）；
虚拟内联大小长度（void）常量；
虚拟整数cmp（常量strT和rsStr）常量；
虚拟内联常量chrT&operator[]（size\u t nPos）常量；
虚拟内联chrT&运算符[]（大小\u t nPos）；
虚拟布尔和运算符==（常量strT和rsStr）常量；
虚拟布尔和运算符！=（常量strT和rsStr）常量；
虚拟布尔和运算符<（常量strT和rsStr）常量；
虚拟布尔和运算符>（常量strT和rsStr）常量；
虚拟布尔和运算符=（常量strT和rsStr）常量；
虚拟内联strT和运算符=（常量strT和rsStr）；
虚拟内联运算符chrT*（void）；
受保护的：
空隙率（尺寸）；
空隙(大小);；
公众：
静态常量大小\u t无；
};
模板
strT转换（常量strT&rsIn）；
typedef-strT-str；
类型定义strT wstr；

目前，如果我想在char和wchar\u t之间进行转换，我只需执行以下操作：

int main( void )
{
    str as = "foo";
    wstr ws = convert<char, wchar_t>( as );
}

int main（无效）
{
str as=“foo”；
wstr ws=转换（as）；
}

但是我希望有一个模板方法来代替这个函数方法，允许进行这样的转换。这很可能是错误的，但以下是我想做的：

template<typename chrT>
class strT
{
    // ...

public:

    template<typename outchr>
    virtual strT<outchr> convert( void ) const;

    // ...
}

template<typename chrT, typename outchr>
strT<outchr> strT<chrT>::convert<outchr>( void ) const
{
    // ...
}

模板
类strT
{
// ...
公众：
模板
虚拟strT转换（void）常量；
// ...
}
模板
strT strT:：convert（void）const
{
// ...
}

然后：

int main( void )
{
    str as = "foo";
    wstr ws = as.convert<wchar_t>();
}

int main（无效）
{
str as=“foo”；
wstr ws=as.convert（）；
}

可以吗

谢谢你的帮助

---

PS：忘了提到我不想使用C++11功能。

这几乎是可能的-你可以有一个成员函数模板，但它不能是虚拟的。因此，如果这对您没问题，请从声明中删除

virtual

，您就可以完成设置了

要了解为什么成员函数模板不能是虚拟的，请考虑虚拟成员函数的最常见实现-虚拟函数表。这是一个函数指针表，为每个虚拟函数存储一个指针。一个虚拟成员函数模板需要存储多少个指针？一个用于

转换

，一个用于

转换

，一个用于

转换

，一个用于

转换

，一个用于

转换

，一个用于

---

问题是可以从模板实例化任意多个函数。无法为它们执行动态调度。（请注意，在所有其他动态分派实现中也会出现类似的问题-模板可能是无限多个函数）

为什么不添加模板构造函数呢

template<typename chrT>
class strT
{
public:
    template<typename otherT>
    strT(otherT* o) { ... }
}

模板
类strT
{
公众：
模板
strT（otherT*o）{…}
}

---

要实现转换，您可以针对

chrT

和

otherT

的不同可能性专门化构造函数。谢谢，这是编译器告诉我的。为什么不可能呢？这里我不了解泛型和虚拟之间的关系。谢谢，但这将决定对象构造时的转换输出类型，并且每个实例只允许一个目标类型，这不是我想要的。无论如何，谢谢你的回答！