Modèles: Spécialisations de modèle de fonction: Déduction d'argument de modèle: -> quelqu'un peut-il donner d'autres exemples pour cette déclaration?

Question

Ceci est la déclaration de l'ISO C++ standard 14.8.2.4/3: Déduire arguments de modèle d'un 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. 

Salut à tous, j'ai essayé Déduire arguments de modèle prenant l'adresse d'un modèle fonction ainsi que la conversion Déduire arguments de modèle de fonction.

Dans le 4ème point .. je sais que le compilateur ne peut pas déduire la valeur d'un tableau principal lié à moins que la borne se réfère à un type de référence ou de pointeur. Les limites de tableau majeures ne font pas partie des types de paramètres de fonction.

Quelqu'un peut-on en mesure d'expliquer chacun et chaque point avec un exemple ... s'il vous plaît

Answer 1

Je ne sais pas ce que vous demandez, mais en ce qui concerne « Le Le compilateur ne peut pas en déduire la valeur d'un tableau majeur lié à moins que la lié se réfère à une référence ou un type de pointeur ", je pense qu'il doit y avoir une faute de frappe là-dedans.

L'exemple canonique de déduction de paramètre de modèle de type réseau, y compris lié, est

typedef ptrdiff_t Size; // For example. 

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

où Type et n sont déduit de la matrice fournie en argument réel

Vive & HTH.,

Answer 2

Quelques exemples:

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