c++ - 隐式转换没有发生

Question

我问的最后一个问题是我在试图理解另一件事时偶然发现的……我也无法理解(不是我的时代)。

这是一个相当长的问题陈述，但至少我希望这个问题可能对很多人有用，而不仅仅是我。

我的代码如下:

template <typename T> class V;
template <typename T> class S;

template <typename T>
class V
{
public:
 T x;

 explicit V(const T & _x)
 :x(_x){}

 V(const S<T> & s)
 :x(s.x){}
};

template <typename T>
class S
{
public:
 T &x;

 explicit S(V<T> & v)
 :x(v.x)
 {}
};

template <typename T>
V<T> operator+(const V<T> & a, const V<T> & b)
{
 return V<T>(a.x + b.x);
}

int main()
{
 V<float> a(1);
 V<float> b(2);
 S<float> c( b );

 b = a + V<float>(c); // 1 -- compiles
 b = a + c;           // 2 -- fails
 b = c;               // 3 -- compiles

 return 0;
}

表达式 1 和 3 完美运行，而表达式 2 无法编译。

如果我理解正确，会发生什么:

表达式 1

1. c 是隐式转换为 const通过使用标准转换序列(仅包含一个限定转换)。
2. V<float>(const S<T> & s)被称为时间 const V<float>生成的对象(我们称它为 t)。它已经是 const 限定的，因为它是一个时间值。
3. a 与 c 类似地转换为 const。
4. operator+(const V<float> & a, const V<float> & b)被调用，导致类型为 const V<float> 的时间我们可以称之为q。
5. 默认V<float>::operator=(const & V<float>)被称为。

我到这里还好吗？如果我犯了最细微的错误，请告诉我，因为我正在努力尽可能深入地了解隐式转换......

表达式 3

1. c 转换为 V<float> .为此，我们有一个用户定义的转换序列:
   1.1.第一次标准转换:S<float>至 const S<float>通过资格转换。
   1.2.用户定义的转换:const S<float>至 V<float>通过V<float>(const S<T> & s)构造函数。
   1.3秒标准转换:V<float>至 const V<float>通过资格转换。
2. 默认V<float>::operator=(const & V<float>)被称为。

表达式 2?

我不明白的是为什么第二个表达式有问题。为什么下面的顺序是不可能的？

1. c 转换为 V<float> .为此，我们有一个用户定义的转换序列:
   1.1.初始标准转换:S<float>至 const S<float>通过资格转换。
   1.2.用户定义的转换:const S<float>至 V<float>通过V<float>(const S<T> & s)构造函数。
   1.3.最终标准转换:V<float>至 const V<float>通过资格转换。
2. 步骤 2 到 6 与表达式 1 的情况相同。

在阅读了 C++ 标准之后，我虽然:'嘿!也许问题与 13.3.3.1.2.3 有关!其中指出:

If the user-defined conversion is specified by a template conversion function, the second standard conversion sequence must have exact match rank.

但事实并非如此，因为资格转换具有完全匹配排名......

我真的不知道...

好吧，不管你有没有答案，感谢你阅读到这里:)

Answer 1

正如 Edric 所指出的，在模板参数推导过程中不考虑转换。在这里，您有两个上下文，其中模板参数 T 可以从参数的类型中推导出来:

template<class T>
v<T> operator+(V<T> const&, V<T> const&);
               ~~~~~~~~~~~  ~~~~~~~~~~~~

但是您尝试使用 V<float> 调用此函数模板在左侧，在右侧有一个 S。模板参数推导导致左侧为 T=float，右侧会出现错误，因为没有 T，因此 V<T>等于 S<T> .这符合模板参数推导失败的条件，模板将被忽略。

如果你想允许转换，你的 operator+ 不应该是一个模板。有以下技巧:您可以将其定义为 V 的类模板内的内联友元:

template<class T>
class V
{
public:
   V();
   V(S<T> const&); // <-- note: no explicit keyword here

   friend V<T> operator+(V<T> const& lhs, V<T> const& rhs) {
      ...
   }
};

这样，运算符就不再是模板了。因此，不需要模板参数推导，您的调用应该有效。运算符是通过 ADL(参数相关查找)找到的，因为左侧是 V<float>。 .右侧已正确转换为 V<float>

也可以禁用特定参数的模板参数推导。例如:

template<class T>
struct id {typedef T type;};

template<class T>
T clip(
   typename id<T>::type min,
   T value,
   typename id<T>::type max )
{
   if (value<min) value=min;
   if (value>max) value=max;
   return value;
}

int main() {
   double x = 3.14;
   double y = clip(1,x,3); // works, T=double
}

即使第一个和最后一个参数的类型是 int，在模板参数推导过程中也不会考虑它们，因为 id<T>::type不是所谓的*可推导上下文。所以，只根据第二个参数推导出T，结果T=double，没有矛盾。