11.2 Deduced Contexts

Ru-Brd

11.2 Deduced Contexts

Parameterized types that are considerably more complex than T can be matched to a given argument

type. Here are a few examples that are still fairly basic:

 template<typename T>  void f1(T*);  template<typename E, int N>  void f2(E(&)[N]);  template<typename T1, typename T2, typename T3>  void f3(T1 (T2::*)(T3*));  class S {    public:      void f(double*);  };  void g (int*** ppp)  {      bool b[42];      f1(ppp);  // deduces  T  to be  int**      f2(b);  // deduces  E  to be  bool  and  N  to be  42      f3(&S::f);  // deduces  T1 = void  ,  T2=S  , and  T3 = double  } 

Complex type declarations are built from more elementary constructs (pointer, reference, array, and function declarators; pointer-to-member declarators; template-ids; and so forth), and the matching process proceeds from the top-level construct and recurses through the composing elements. It is fair to say that most type declaration constructs can be matched in this way, and these are called deduced contexts . However, a few constructs are not deduced contexts:

• Qualified type names . A type name like Q<T>::X will never be used to deduce a template parameter T , for example.

• Nontype expressions that are not just a nontype parameter. A type name like S<I+1> will never be used to deduce I , for example. Neither will T be deduced by matching against a parameter of type int(&)[sizeof(S<T>)] .

These limitations should come as no surprise because the deduction would, in general, not be unique (or even finite), although qualified type names are sometimes easily overlooked. A nondeduced context does not automatically imply that the program is in error or even that the parameter being analyzed cannot participate in type deduction . To illustrate this, consider the following, more intricate example:

  // details/fppm.cpp  template <int N>  class X {    public:      typedef int I;      void f(int) {      }  };  template<int N>  void fppm(void (X<N>::*p)(X<N>::I));  int main()  {      fppm(&X<33>::f);  // fine:  N  deduced to be  33  } 

In the function template fppm() , the subconstruct X<N>::I is a nondeduced context. However, the member-class component X<N> of the pointer-to-member type is a deducible context, and when the parameter N , which is deduced from it, is plugged in the nondeduced context, a type compatible with that of the actual argument &X<33>::f is obtained. The deduction therefore succeeds on that argument-parameter pair.

Conversely, it is possible to deduce contradictions for a parameter type entirely built from deduced contexts. For example, assuming suitably declared class templates X and Y :

 template<typename T>  void f(X<Y<T>, Y<T> >);  void g()  {      f(X<Y<int>, Y<int> >());  // OK  f(X<Y<int>, Y<char> >());  // ERROR: deduction fails  } 

The problem with the second call to the function template f() is that the two arguments deduce different arguments for the parameter T , which is not valid. (In both cases, the function call argument is a temporary object obtained by calling the default constructor of the class template X .)

Ru-Brd