C++ 类模板中的转换运算符

我有两个类模板

TemplateA

和

TemplateB

。现在，我想在

TemplateB

中定义一个转换运算符，以便允许从

TemplateB

到

TemplateA

的隐式类型转换。但是，以下代码会产生编译错误：

struct ClassA {};

template<typename T>
struct TemplateA {
  T val;
};

template<typename T>
struct TemplateB {
  T val;

  template<typename ValT>
  operator TemplateA() const {
    TemplateA<ValT> a;
    a.val = val;
    return a;
  }
};

int main() {
  TemplateB<ClassA> b;
  TemplateA<ClassA> a = b;
  return 0;
}

---

模板参数构成类型定义的一部分，因此在转换运算符中不能忽略它：

template<typename ValT>
  operator TemplateA<ValT>() const {
    TemplateA<ValT> a;
    a.val = val;
    return a;
  }

模板
运算符TemplateA（）常量{
模板a；
a、 val=val；
返回a；
}

这有助于理解编译器将模板类型附加到模板的计算类型。因此，您的代码将生成类似于

操作符TemplateA_ClassA（）const

的内容，用于将

TemplateB_ClassA

转换为

TemplateA_ClassA

我想在

TemplateB

中定义一个转换运算符，以允许从

TemplateB

到

TemplateA

的隐式类型转换

这不需要转换函数模板。普通转换函数将执行以下操作：

operator TemplateA<T>() const {
    TemplateA<T> a;
    a.val = val;
    return a;
}

运算符TemplateA（）常量{
模板a；
a、 val=val；
返回a；
}

仅当您希望允许从

TemplateB

转换到

TemplateA

时，才需要模板。此外，如果您选择，还可以以其他方式定义转换-您可以添加一个[非模板]转换函数，而不是将[非模板]转换函数添加到

TemplateB

将构造函数转换为

模板a

：

template<typename T>
struct TemplateB {
    T val;
};

template<typename T>
struct TemplateA {
    T val;

    TemplateA() = default;

    // converting constructor
    TemplateA(TemplateB<T> const& t)
    : val(t.val)
    { }
};

模板
结构模板B{
T值；
};
模板
结构模板{
T值；
TemplateA（）=默认值；
//转换构造函数
模板A（模板B const&t）
：val（t.val）
{ }
};

template<typename T>
struct TemplateB {
    T val;
};

template<typename T>
struct TemplateA {
    T val;

    TemplateA() = default;

    // converting constructor
    TemplateA(TemplateB<T> const& t)
    : val(t.val)
    { }
};