Restrições no genérico Digite parâmetros (C + + / CLI)
Em declarações de tipo genérico ou método , você pode qualificar um parâmetro de tipo com restrições.Uma restrição é um requisito que devem satisfazer a tipos usados como argumentos de tipo.Por exemplo, uma restrição pode ser que o argumento do tipo deve implementar uma determinada interface ou herdar de uma classede específica.
As restrições são opcionais. não especificar uma restrição em um parâmetro é equivalente a restrição de parâmetro para Object.
where type-parameter: constraint list
Parâmetros
tipo -parâmetro
Um dos parâmetros de tipo, para ser restrita.lista de restrição
lista de restrição é uma lista separada por vírgulas de especificações da restrição .A lista pode incluir interfaces a serem implementadas pelo parâmetrotipo.A lista também pode incluir uma classe.Para o tipo de argumento satisfazer umarestriçãode classe base, ele deve ser a mesma classe que a restrição ou derivar a partir da restrição.
Você também pode especificar gcnew() para indicar o tipo de argumento deve ter um público sem parâmetros construtor; ou ref class para indicar o tipo de argumento deve ser um tipo de referência, incluindo qualquer classe, interface, delegadoou tipo de matriz; ou value class para indicar o tipo de argumento deve ser um tipo de valor.Qualquer tipo de valor , exceto Nullable <T> pode ser especificado.
Você também pode especificar um parâmetro de genérico como uma restrição.O tipo de argumento fornecido para o tipo que são a restrição deve ser ou derivam do tipo da restrição.Isso é chamado uma restriçãode tipo nua.
Comentários
A cláusula restrição consiste em onde seguido de um tipo parâmetro, dois-pontos (:) e a restrição, que especifica a natureza da restrição sobre o tipo de parâmetro.onde é um contexto-sensível palavra-chave; consulte Palavras-chave Contextuais (Extensões de Componentes C++) para obter mais informações.Separe várias onde cláusulas com um espaço.
As restrições são aplicadas ao digitar parâmetros para colocar as limitações nos tipos que podem ser usados como argumentos para um tipo genérico ou o método.
Restrições de interface de classe e especificam que os tipos de argumento devem ser ou herdar de uma classe de especificado ou implementar uma determinada interface.
O aplicativo de restrições para um tipo genérico ou método permite que o código em desse tipo ou método para tirar proveito dos recursos conhecidos dos tipos restritos.Por exemplo, você pode declarar uma classe de genérica de modo que o parâmetro de tipo implementa o **IComparable <T>**interface:
// generics_constraints_1.cpp
// compile with: /c /clr
using namespace System;
generic <typename T>
where T : IComparable<T>
ref class List {};
Esta restrição requer que um tipo de argumento é usado para T implementa IComparable<T> em tempo de compilar .Ele também permite que os métodos de interface , como CompareTo, a ser chamado.Nenhuma conversão é necessária em uma instância do parâmetro de tipo para chamar métodos da interface .
Métodos estáticos no tipo de argumentoda classe não podem ser chamados através do parâmetrodo tipo; eles podem ser chamados somente por meio do tipo nomeado real.
Uma restrição não pode ser um tipo de valor, inclusive tipos internos, como int ou double.Desde que os tipos de valor não podem ter classes derivadas, somente uma classe nunca seria capaz de satisfazer a restrição.Nesse maiúsculas e minúsculas, a genérica pode ser regravada com o parâmetro de tipo substituído pelo específico do tipo de valor.
As restrições são necessários em alguns casos, desde que o compilador não permitirá o uso de métodos ou outros recursos de um tipo desconhecido, a menos que as restrições implicam que o tipo desconhecido oferece suporte a métodos ou interfaces.
Várias restrições para o mesmo parâmetro de tipo podem ser especificadas em uma lista separada por vírgulas
// generics_constraints_2.cpp
// compile with: /c /clr
using namespace System;
using namespace System::Collections::Generic;
generic <typename T>
where T : List<T>, IComparable<T>
ref class List {};
Com vários parâmetros de tipo, use um onde cláusula para cada tipo de parâmetro.Por exemplo:
// generics_constraints_3.cpp
// compile with: /c /clr
using namespace System;
using namespace System::Collections::Generic;
generic <typename K, typename V>
where K: IComparable<K>
where V: IComparable<K>
ref class Dictionary {};
Para resumir, use as restrições no seu código de acordo com as seguintes regras:
Se várias restrições estiverem listadas, as restrições podem ser listadas em qualquer ordem.
Restrições também podem ser tipos de classe , tais como classes base abstratas.No entanto, as restrições não podem ser tipos de valor ou classes lacradas.
Restrições não podem ser eles mesmos parâmetros de tipo, mas eles podem envolver os parâmetros de tipo em um tipo de em aberto construído.Por exemplo:
// generics_constraints_4.cpp // compile with: /c /clr generic <typename T> ref class G1 {}; generic <typename Type1, typename Type2> where Type1 : G1<Type2> // OK, G1 takes one type parameter ref class G2{};
Exemplo
O exemplo a seguir demonstra o uso de restrições para chamar métodos de instância em parâmetros de tipo.
// generics_constraints_5.cpp
// compile with: /clr
using namespace System;
interface class IAge {
int Age();
};
ref class MyClass {
public:
generic <class ItemType> where ItemType : IAge
bool isSenior(ItemType item) {
// Because of the constraint,
// the Age method can be called on ItemType.
if (item->Age() >= 65)
return true;
else
return false;
}
};
ref class Senior : IAge {
public:
virtual int Age() {
return 70;
}
};
ref class Adult: IAge {
public:
virtual int Age() {
return 30;
}
};
int main() {
MyClass^ ageGuess = gcnew MyClass();
Adult^ parent = gcnew Adult();
Senior^ grandfather = gcnew Senior();
if (ageGuess->isSenior<Adult^>(parent))
Console::WriteLine("\"parent\" is a senior");
else
Console::WriteLine("\"parent\" is not a senior");
if (ageGuess->isSenior<Senior^>(grandfather))
Console::WriteLine("\"grandfather\" is a senior");
else
Console::WriteLine("\"grandfather\" is not a senior");
}
Quando umparâmetro do tipo genéricoé usado como uma restrição, ela é chamada de tipo nua restrição. Restrições de tipo nua são úteis quando precisa de uma função de membro com seu próprio tipo de parâmetro restringir esse parâmetro para o tipo de parâmetro do tipo recipiente.
No exemplo a seguir, o t é uma restrição de tipo nua no contexto do métodoAdd.
Restrições de tipo nua também podem ser usadas em definições de classe de genéricos.A utilidade de restrições de tipo nua com classes genéricas é limitada porque o compilador pode assumir nada sobre uma restrição de tipo nua, exceto que ela deriva de Object.Use restrições de tipo nua em classes genéricas em cenários nos quais você deseja impor um relação de herança entre dois parâmetros de tipo.
// generics_constraints_6.cpp
// compile with: /clr /c
generic <class T>
ref struct List {
generic <class U>
where U : T
void Add(List<U> items) {}
};
generic <class A, class B, class C>
where A : C
ref struct SampleClass {};