使用使用成员类型别名的构造函数推导出类模板参数

Question

所以显然这应该有效：

template<class T>
struct C {
   using value_type = T;
   C(value_type);
};

C c(1); // C<int>

就是这样（参见[over.match.class.deduct]/3 中的B 示例）：

template<class T>
struct D {
   template<class> using meow_t = T;

   template<class U>
   D(U, meow_t<U>);
};

D d(1, 'c'); // D<char>

请注意，由于参数是非推导上下文，因此看似等效的显式指南将不起作用：

template<class T>
C(typename C<T>::value_type) -> C<T>;

虽然希望至少第一个 sn-p 有效，但我还没有找到真正使其在当前有效的措辞工作草案。有谁知道它在哪里？

Answer 1

这不是严格意义上的答案，因为我认为这样的措辞实际上并不存在。这更像是与问题相关的信息的拼凑。

---

这是Core Issue 2。 Oulu 和 Issaquah 关于此功能的讨论清楚地表明，意图是查看 typedef 是有效的，但没有添加任何措辞来表明它应该如何工作 - 它只是。 .. 是。原样的措辞表明以下扣除指南：

template<class T>
struct C {
   using value_type = T;
   C(value_type);
};

应该是：

template <class T> C<T> foo(typename C<T>::value_type );

这将是一个非演绎的上下文并且失败，但[thread.lock.guard] 没有针对这种情况的明确演绎指南。

[over.match.best] 中的示例显然是为了表明 typedef 应该起作用，尽管该示例中的示例实际上都没有使用 #1 作为推导指南：

template <class T> struct A {
  using value_type = T;
  A(value_type);    // #1
  A(const A&);      // #2
  A(T, T, int);     // #3
  template<class U>
    A(int, T, U);   // #4
  // #5 is the copy deduction candidate, A(A)
};

A x(1, 2, 3);       // uses #3, generated from a non-template constructor

template <class T>
A(T) -> A<T>;       // #6, less specialized than #5

A a(42);            // uses #6 to deduce A<int> and #1 to initialize
A b = a;            // uses #5 to deduce A<int> and #2 to initialize

template <class T>
A(A<T>) -> A<A<T>>; // #7, as specialized as #5

A b2 = a;           // uses #7 to deduce A<A<int>> and #1 to initialize

Answer 2

我认为仔细阅读可以清楚地说明这一点：

函数参数的类型是构造函数的类型。

注意C<T>::value_type 不是一个类型，它是一个typedef-name。由于代入，构造函数参数的类型为T，等价的推导其实是

template <class T> C(T) -> C<T>;

在您的示例中，使用 C<T>::value_type 看起来好像存在与非推导上下文有关的问题，但实际上并不存在该问题，因为不涉及对推导函数参数的查找。