Class template

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate. La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui. Click here for the English version of this page

A class template defines a family of classes.

[modifica] Sintassi

[modifica] Spiegazione

declaration defines or declares a class (including struct and union), a member class or member enumeration type, a function or member function, a static data member of a class template, or a type alias. It may also define a modello di specializzazione. This page focuses on class templates.

parameter-list is a non-empty comma-separated list of the template parameters, each of which is either non-type parameter, a type parameter, a template parameter, or a parametro confezione of any of those. This page focuses on the parameters that are not parameter packs.

[modifica] Non-type template parameter

type is one of the following types (optionally cv-qualified, the qualifiers are ignored)

• integral type
• enumeration
• pointer to object or to function
• lvalue reference to object or to function
• pointer to member object or to member function
• std::nullptr_t (dal C++11)

Array and function types may be written in a template declaration, but they are automatically replaced by pointer to data and pointer to function as appropriate.

When the name of a non-type template parameter is used in an expression within the body of the class template, it is an unmodifiable prvalue unless its type was an lvalue reference type.

[modifica] Type template parameter

[modifica] Template template parameter

[modifica] Class template instantiation

A class template by itself is not a type, or an object, or any other entity. No code is generated from a source file that contains only template definitions. In order for any code to appear, a template must be instantiated: the template arguments must be provided so that the compiler can generate an actual class (or function, from a function template).

[modifica] Explicit instantiation

An explicit instantiation definition forces instantiation of the class, struct, or union they refer to. It may appear in the program anywhere after the template definition, and for a given argument-list, is only allowed to appear once in the program.

An explicit instantiation declaration (an extern template) prevents implicit instantiations: the code that would otherwise cause an implicit instantiation has to use the explicit instantiation definition provided somewhere else in the program.

[modifica] Implicit instantiation

When code refers to a template in context that requires a completely defined type, or when the completeness of the type affects the code, and this particular type has not been explicitly instantiated, implicit instantiation occurs. For example, when an object of this type is constructed, but not when a pointer to this type is constructed.

This applies to the members of the class template: unless the member is used in the program, it is not instantiated, and does not require a definition.

template<class T> struct Z {
    void f() {}
    void g(); // never defined
}; // template definition
template struct Z<double>; // explicit instantiation of Z<double>
Z<int> a; // implicit instantiation of Z<int>
Z<char>* p; // nothing is instantiated here
p->f(); // implicit instantiation of Z<char> and Z<char>::f() occurs here.
// Z<char>::g() is never needed and never instantiated: it does not have to be defined

[modifica] Non-type template parameters

The following limitations apply when instantiating class templates that have non-type template parameters:

• For integral and arithmetic types, the template argument provided during instantiation must be a constant expression.
• For pointers to objects, the template arguments have to designate the address of an object with static storage duration and a linkage (either internal or external), or a constant expression that evaluates to the appropriate null pointer value.
• For pointers to functions, the valid arguments are pointers to functions with linkage (or constant expressions that evaluate to null pointer values).
• For lvalue reference parameters, the argument provided at instantiation cannot be a temporary, an unnamed lvalue, or a named lvalue with no linkage.
• For pointers to members, the argument has to be a pointer to member expressed as &Class::Member or a constant expression that evaluates to null pointer value.

In particular, this implies that string literals, addresses of array elements, and addresses of non-static members cannot be used as template arguments to instantiate templates whose corresponding non-type template parameters are pointers to data.

[modifica] Esempio

template<typename T>
struct S {
    template<typename U> void foo(){}
};
 
template<typename T>
void bar()
{
    S<T>s;
    s.foo<T>(); // error: < parsed as less than operator
    s.template foo<T>(); // OK
}

[modifica] Non-type template parameters

#include <iostream>
 
// simple non-type template parameter
template<int N>
struct S {
    int a[N];
};
 
template<const char*>
struct S2 {};
 
// complicated non-type example
template <
    char c, // integral type
    int (&ra)[5], // lvalue reference to object (of array type)
    int (*pf)(int), // pointer to function
    int (S<10>::*a)[10] // pointer to member object (of type int[10])
> struct Complicated {
    // calls the function selected at compile time
    // and stores the result in the array selected at compile time
    void foo(char base) {
        ra[4] = pf(c - base);
    }
};
 
//  S2<"fail"> s2; // Error: string literal cannot be used
char okay[] = "okay"; // static object with linkage
// S2< &okay[0] > s2; // Error: array element has no linkage
S2<okay> s2; // works
 
int a[5];
int f(int n) { return n;}
int main()
{
    S<10> s; // s.a is an array of 10 int
    s.a[9] = 4;
 
    Complicated<'2', a, f, &S<10>::a> c;
    c.foo('0');
 
    std::cout << s.a[9] << a[4] << '\n';
}

42

[modifica] Vedi anche

• <div class="t-tr-text"> funzione di modello di dichiarazione

  Original:

  function template declaration

  The text has been machine-translated via [http://translate.google.com Google Translate].
  You can help to correct and verify the translation. Click [http://en.cppreference.com/w/Cppreference:MachineTranslations here] for instructions.
  dichiara un modello di funzione
  Original:

  funzione di modello di dichiarazione

  Original:

  function template declaration

  The text has been machine-translated via [http://translate.google.com Google Translate].
  You can help to correct and verify the translation. Click [http://en.cppreference.com/w/Cppreference:MachineTranslations here] for instructions.

  </div> declares a function template

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• <div class="t-tr-text"> modello di specializzazione

  Original:

  template specialization

  The text has been machine-translated via [http://translate.google.com Google Translate].
  You can help to correct and verify the translation. Click [http://en.cppreference.com/w/Cppreference:MachineTranslations here] for instructions.
  definisce un modello esistente per un tipo specifico
  Original:

  modello di specializzazione

  Original:

  template specialization

  The text has been machine-translated via [http://translate.google.com Google Translate].
  You can help to correct and verify the translation. Click [http://en.cppreference.com/w/Cppreference:MachineTranslations here] for instructions.

  </div> defines an existing template for a specific type

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• <div class="t-tr-text"> parametri confezioni

  Original:

  parameter packs

  The text has been machine-translated via [http://translate.google.com Google Translate].
  You can help to correct and verify the translation. Click [http://en.cppreference.com/w/Cppreference:MachineTranslations here] for instructions.
  permette l'utilizzo di elenchi di tipi in (dal C++11) modelli
  Original:

  parametri confezioni

  Original:

  parameter packs

  The text has been machine-translated via [http://translate.google.com Google Translate].
  You can help to correct and verify the translation. Click [http://en.cppreference.com/w/Cppreference:MachineTranslations here] for instructions.

  </div> allows the use of lists of types in templates (dal C++11)

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.