Question

这是ISO C ++标准14.8.2.4 /第3版的声明：从类型中推导出模板参数

  A given type P can be composed from a number of other types, templates, 
  and non-type values:

    — A function type includes the types of each of the function parameters 
      and the return type.
    — A pointer to member type includes the type of the class object pointed 
      to and the type of the member pointed to.
    — A type that is a specialization of a class template (e.g., A<int>) 
      includes the types, templates, and non-type values referenced by the  
      template argument list of the specialization.
    — An array type includes the array element type and the value of the  
      array bound.

               In most cases, the types, templates, and non-type values that 
 are used to compose P participate in template argument deduction. That is,they
 may be used to determine the value of a template argument, and the value so 
 determined must be consistent with the values determined elsewhere. In certain  
 contexts, how ever, the value does not participate in type deduction, but 
 instead uses the values of template arguments that  were either deduced 
 elsewhere or explicitly specified. If a template parameter is used only in 
 nondeduced contexts and is not explicitly specified, template argument 
 deduction fails.

大家好，我尝试使用函数的地址推导模板参数模板以及Deducing转换函数模板参数。

在第4点..我知道编译器不能推导出主要数组绑定的值，除非绑定引用了引用或指针类型。主要数组边界不是函数参数类型的一部分。

任何人都可以用一个例子来解释每一点......

Answer 1

不确定你在问什么，但是关于“编译器不能推断出主要数组绑定的值，除非绑定引用了引用或指针类型”，我认为那里肯定会有一些错字。

从包含bound的数组类型中扣除模板参数的规范示例是

typedef ptrdiff_t Size;    // For example.

template< class Type, Size n >
Size countOf( Type (&)[n] ) { return n; }

其中Type和n是从作为实际参数提供的数组中推导出来的

干杯＆amp;第h。，

Answer 2

一些例子：

#include <string.h>
#include <ctype.h>
#include <utility>
#include <vector>

template <class R, class F, class S>
void function_pointer( R (*func)(F, S) );

template <class T, class Object>
void member_pointer( T Object::*);

template <class T, class U, template <class> class Alloc>
void a_vector(const std::vector<T, Alloc<U> >&);

template <class T, std::size_t N>
void array_ref(T (&)[N]);  //arrays decay to pointer when passed by value

template <class T, class U>
void types_must_agree(std::pair<T, U>, T (*) (U));

template <class T>
void non_deduced_context(typename std::pair<T, T>::first_type);

template <class T>
void non_deduced_context_deduced_from_another_argument(typename std::pair<T, T>::first_type, T);

int main()
{
    function_pointer(&strcmp);
    member_pointer(&std::pair<int, double>::first);
    a_vector(std::vector<int>());
    char c[10];
    array_ref(c);
    types_must_agree(std::pair<int, int>(), &isspace);
    non_deduced_context<int>(10);
    non_deduced_context_deduced_from_another_argument(10, 20);
}

模板：函数模板特化：模板参数推导： - ＆gt;任何人都可以告诉更多这个语句的例子吗？

2 个答案: