c++ - 在模板类中使用两个类型转换运算符时出现问题

Question

我定义了一个模板类，其中我定义了两个类型转换运算符

template <class base_t>
struct subclass {

  base_t base;

  //any function which defined for 'base_t' can be used with 'subclass<base_t>'
  operator base_t&() {
    return base;
  }

  //I want 'subclass<base_t>' can be converted to any class which 'base_t' can
  //I want this operator is called only if 'target_t' is not 'base_t'
  template <class target_t>
  operator target_t&() {
    return (target_t)base;
  }

};

类(class)看起来不错，但是当我尝试转换 subclass<int> 时出现问题至 int .例如:

typedef subclass<int> foo_t;
foo_t foo = {1234};
cout << foo << endl; //Error here: ambiguous; This line is compiled only if I delete 'template<class target_t> operator target_t&()'

请告诉我怎么做

编辑

如果我不定义模板，一切正常。但是，如果我定义一个 subclass< subclass<int> > ，我可以将其转换为 subclass<int>但我无法将其转换为 int

typedef subclass<int> level1;
typedef subclass<level1> level2;
level1 a = {1234};
level2 b = {a};
cout << a << endl;
cout << b << endl; //Error! Because the compiler doesn't provide a type-cast from level2 to int

Answer 1

您尝试做的事情毫无意义。

我们有subclass<int> .它可以转换为 int& ，还有很多其他的引用类型。 char& . bool& . double& .歧义源于以下事实:operator<< 的所有各种重载。采用任何非模板参数的是具有等效转换序列的可行重载候选者。此外，您可能根本不想进行任何这些转换。

你想要的是只是 base& operator :

template <class base_t>
struct subclass {
    base_t base;

    operator base_t&();
};

这就是您真正需要的。这为您提供了对您正在存储的类型的隐式引用，并且您也可以对它进行基类引用:

subclass<Derived> obj;
Base& base = obj; // totally OK with just that one operator

我没看出模板有什么问题operator T&解决。

However, when I define, subclass < subclass<int> > and it can converted to subclass<int> but can't be converted to int

首先，subclass<subclass<int>>可以转换为subclass<int>& , 不是 subclass<int> .也就是说，如果我们希望它起作用，我们可以为这种情况专门添加一个转换运算符。首先，添加一个类型特征来查找最嵌套的类型是什么:

template <class base_t>
struct subclass;

template <typename T>
struct nested { using type = T; };

template <typename T>
struct nested<subclass<T>> : nested<T> { };

然后定义一个模板operator嵌套案例的转换:

template <typename T, 
          typename = std::enable_if_t<std::is_same<T, typename nested<base_t>::type>::value>>
operator T&() {
    return base;
}

我们将其设为模板，以便在我们只有一个 subclass 的情况下不会出现模棱两可的重载深的。有了这个，这两个工作:

subclass<subclass<subclass<int>>> s{{{4}}};
int& i = s;

subclass<int> s2{5};
int& i2 = s2;