Templates :Function template specializations:Template argument deduction: -->can any one tell some more examples for this statement?

Question

This is the statement from ISO C++ Standard 14.8.2.4 / 3rd :Deducing template arguments from a type

  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.

Hi All,I tried Deducing template arguments taking the address of a function template as well as Deducing conversion function template arguments.

In the 4th point ..i know that The compiler cannot deduce the value of a major array bound unless the bound refers to a reference or pointer type. Major array bounds are not part of function parameter types.

Can any one able to explain each and every point with an example please...

Answer 1

Not sure what you're asking, but regarding "The The compiler cannot deduce the value of a major array bound unless the bound refers to a reference or pointer type", I think there must be some typo in there.

The canonical example of deduction of template parameter from array type including bound, is

typedef ptrdiff_t Size;    // For example.

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

where Type and n are deduced from the array supplied as actual argument

Cheers & hth.,

Answer 2

Some examples:

#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);
}