Especificações do modelo

O template declaração especifica um conjunto de classes parametrizadas ou funções.

template < template-parameter-list > declaration

Comentários

O lista de parâmetros de modelo é uma lista separada por vírgulas dos parâmetros de modelo, que pode ser de tipos (no formulário classeidentificador, typenameidentificador, ou modelo < lista de parâmetros de modelo > classe identificador) ou parâmetros de não-tipo a ser usado no corpo do modelo.A sintaxe para um parâmetro de modelo é um destes procedimentos:

parameter-declaration
class identifier [ = typename ] 
typename identifier [ = typename ]
template < template-parameter-list > class [identifier][= name]

Você pode instanciar um modelo de classe muito como você poderia criar uma instância de uma classe normal, mas você deve incluir os argumentos de modelo dentro de colchetes angulares (< >).Esses argumentos de modelo podem ser qualquer tipo, se a lista de argumentos de modelo contém a classe ou typename palavra-chave ou um valor do tipo apropriado se o argumento é um argumento de tipo não.Nenhuma sintaxe especial é necessário para chamar um modelo de função, embora os colchetes angulares e argumentos de modelo podem ser necessários se os parâmetros do modelo não podem ser deduzidos dos argumentos para a função.

O lista de parâmetros de modelo é uma lista de parâmetros usados pela função do modelo que especifica quais partes do código a seguir irão variar.Por exemplo:

template< class T, int i > class MyStack...

Nesse caso, o modelo pode receber um tipo (class T) e um parâmetro constante (int i).O modelo usará o tipo de T e o inteiro a constante i na instanciação.Dentro do corpo da MyStack declaração, você deve consultar a T identificador.

Uma declaração de modelo em si não gera código; Ele especifica uma família de classes ou funções, um ou mais dos quais serão gerado quando referido por outro código.

Declarações de modelo têm global, o namespace ou o escopo de classe.Eles não podem ser declarados dentro de uma função.

O exemplo a seguir ilustra a declaração, a definição e a instanciação de um modelo de classe com um parâmetro de tipo T e um parâmetro de modelo de tipo não i.

// template_specifications1.cpp
template <class T, int i> class TestClass 
{
public:
   char buffer[i];
   T testFunc(T* p1 );
};

template <class T, int i>
T TestClass<T,i>::testFunc(T* p1) 
{
    return *(p1++)
};

// To create an instance of TestClass
TestClass<char, 5> ClassInst;
int main()
{
}

Argumentos de tipo non modelo

Parâmetros do modelo de tipo não devem ser do integral, enumeração, ponteiro, referência ou ponteiro para o tipo de membro e devem ser constantes em tempo de compilação.Eles podem ser qualificados como tipos const ou volátil.Não são permitidos valores como parâmetros de modelo de ponto flutuante.Objetos de classe, struct ou tipo de união não são permitidos como parâmetros de tipo não modelo, embora os ponteiros para esses objetos são permitidos.Arrays passaram como parâmetros do modelo de tipo não são convertidos em ponteiros.As funções transmitidas como parâmetros de tipo não são tratadas como ponteiros de função.Literais de seqüência de caracteres não são permitidos como parâmetros de modelo.

Usando typename em uma declaração de modelo

O TypeName palavra-chave pode ser usado na lista de parâmetros de modelo.As seguintes declarações de modelo são idênticas:

template< class T1, class T2 > class X...
template< typename T1, typename T2 > class X...

Argumentos padrão para parâmetros de modelo

Modelos de classe podem ter argumentos do padrão especificados usando o = sinal seguido o tipo padrão ou valor.Os modelos de função não podem ter argumentos padrão.Para obter mais informações, consulte Argumentos padrão para modelos de classe .:

template<typename Type> class allocator {};
template<typename Type, 
   typename Allocator = allocator<Type> > class stack 
{
};
stack<int> MyStack;

Reutilização dos parâmetros de modelo

Parâmetros do modelo podem ser reutilizados na lista de parâmetros de modelo.Por exemplo, o código a seguir é permitido:

// template_specifications2.cpp

class Y 
{
};
template<class T, T* pT> class X1 
{
};
template<class T1, class T2 = T1> class X2 
{
};

Y aY;

X1<Y, &aY> x1;
X2<int> x2;

int main()
{
}

Modelos como parâmetros de modelo

Parâmetros do modelo podem ser modelos.Essa construção significa que se o argumento deve ser um modelo, não uma classe construído a partir do modelo.No exemplo a seguir, o nome A do modelo de parâmetro para um parâmetro de modelo do modelo pode ser omitido, pois não é possível que ele pode ser usado.

// template_specifications3.cpp
#include <stdio.h>

template <class T> struct str1
{
   T t;
};

template <template<class A> class T> struct str2
{
    T<int> t;
};

int main()
{
    str2<str1> mystr2;
    mystr2.t.t = 5;
    printf_s("%d\n", mystr2.t.t);
}

Saída

5

Referências como parâmetros de modelo

Visual Studio.NET 2003 introduziu a capacidade de usar as referências como parâmetros de tipo não modelo.Isso não era permitido nas versões anteriores.

// references__supported_as_nontype_template_parameters.cpp
#include <stdio.h>

extern "C" int printf_s(const char*,...);
template <int & ri> struct S
{
   S()
   {
      printf_s("ri is %d\n", ri);
   }

   ~S()
   {
      printf_s("ri is %d\n", ri);
   }
};

int i = 1;

int main()
{
   S<i> s;
   i = 0;
}

Saída

ri is 1
ri is 0

Instâncias do modelo aninhado

As versões do Visual Studio antes para o Visual Studio 2005 de exigiam inserida nesse espaço em branco entre listas de parâmetros do modelo quando instâncias do modelo aninhado foram declaradas.A sintaxe a seguir agora é permitida:

// template_specifications4.cpp 

template <typename T> 
class A
{
};

template <int n> 
class B 
{
};

int main() 
{
   A<B<22>>();
}

Consulte também

Referência

Palavras-chave C++

Outros recursos

Modelos