Einschränkungen für generische Typparameter (C++/CLI)
Klicken Sie im generischen Typ oder in Methodendeklarationen können Sie einen Typparameter mit Einschränkungen qualifizieren.Eine Einschränkung ist eine Anforderung, die Typen verwenden, z. B. Typargumente erfüllen müssen.Zum Beispiel könnte es sich um eine Einschränkung, dass das Typargument eine bestimmte Schnittstelle implementieren oder von einer bestimmten Klasse erben muss.
Einschränkungen sind optional. eine Einschränkung für einen Parameter angegeben ist nicht zum Einschränken dieses Parameters auf Object.
where type-parameter: constraint list
Parameter
Typparameter
Einer der Typparameter eingeschränkt werden.Einschränkungsliste
Einschränkungsliste ist eine durch Trennzeichen getrennte Liste von Einschränkungen spezifikationen.Die Liste kann die vom Typparameter Schnittstellen implementiert werden, enthalten.Die Liste kann auch eine Klasse enthalten.Damit das Typargument erfüllt eine Basisklasse KEY-Einschränkung, muss es der gleichen Klasse wie die Einschränkung sein oder von der Einschränkung abgeleitet werden.
Sie können gcnew() auch angeben, dass das Typargument angeben müssen einen öffentlichen parameterlosen Konstruktor verfügen. ref class oder zum Angeben des Typarguments muss ein Referenztyp, einschließlich alle Klassen, Schnittstellen, Delegaten oder Arraytyp sein. value class oder zum Angeben des Typarguments muss ein Werttyp sein.Ein beliebiger Werttyp außer NULL-Werte zulassen <T> kann angegeben werden.
Sie können einen generischen Parameter als Einschränkung.Das Typargument, das für den Typ angegeben ist, den Sie einschränken, muss vom Typ der Einschränkung sein oder berechnen.Dies wird als nackte Typeinschränkung aufgerufen.
Hinweise
Die Einschränkungsklausel besteht aus Where , das von einem Typparameter aus einem Doppelpunkt (:) und wird gefolgt von der Einschränkung, die die Art der Einschränkung für den Typparameter angegeben wird.Where ist ein kontextbezogenes Schlüsselwort. Weitere Informationen finden Sie im Thema Kontextbezogene Schlüsselwörter (Komponentenerweiterungen für C++) .Mehrere WHERE-Klauseln mit einem Leerzeichen.
Einschränkungen für den Typparameter angewendet, um Einschränkungen für Typen, die als Argumente für einen generischen Typ oder eine Methode verwendet werden können.
Klassen- und Schnittstelleneinschränkungen geben an, dass der Argumenttyp von einer bestimmten Klasse erben oder sein oder eine bestimmte Schnittstelle implementieren müssen.
Die Verwendung von Einschränkungen zu einem generischen Typ oder eine Methode ermöglicht es Code in diesem Typ oder Methode, um die bekannten Funktionen der eingeschränkten Typen zu nutzen.Beispielsweise können Sie eine generische Klasse deklarieren, dass der Typparameter die <T> IComparable Schnittstelle implementiert:
// generics_constraints_1.cpp
// compile with: /c /clr
using namespace System;
generic <typename T>
where T : IComparable<T>
ref class List {};
Diese Einschränkung ist es erforderlich, dass ein Typargument, das fürT verwendet wird, IComparable<T> zur Kompilierzeit implementiert.Es können auch Schnittstellenmethoden, wie CompareTo, aufgerufen werden.Es wird keine Umwandlung wird in einer Instanz des Typparameters benötigt, um Schnittstellenmethoden aufgerufen werden soll.
Statische Methoden in der Klasse des Typarguments können nicht vom Typparameter bezeichnet werden. Sie können nur durch den tatsächlichen benannten Typs aufgerufen werden.
Eine Einschränkung kann kein Werttyp, einschließlich integrierter Datentypen wie int oder Doublesein.Da Werttypen können keine abgeleiteten Klassen verfügen nur eine Klasse vorhanden, kann die Einschränkung zu erfüllen.In diesem Fall können die generische Typparameter mit dem neu geschrieben werden, der vom jeweiligen Werttyp ersetzt wird.
Einschränkungen sind in einigen Fällen erforderlich, da der Compiler nicht die Verwendung von Methoden oder andere Features eines unbekannten Typs zulässig, es sei denn, die Einschränkungen bedeuten, dass der unbekannten Typ Methoden oder Schnittstellen unterstützt.
Mehrere Einschränkungen für den gleichen Typparameter können in einer durch Trennzeichen getrennten Liste angegeben werden
// 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 {};
Wenn mehrere Typparameter verwenden Sie eine WHERE-Klausel für jeden Typparameter.Beispiele:
// 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 {};
Weitere Einschränkungen zusammenfassen, im Code gemäß den folgenden Regeln:
Wenn mehrere Einschränkungen aufgeführt sind, werden die Einschränkungen in beliebiger Reihenfolge aufgeführt werden.
Einschränkungen können Klassentypen, wie abstrakte Basisklassen werden.Einschränkungen können jedoch nicht Werttypen oder versiegelte Klassen handeln.
Einschränkungen können nicht selbst Typparameter sein, aber sie können die Typparameter in einen offenen konstruierten Typ.Beispiele:
// 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{};
Beispiel
Das folgende Beispiel veranschaulicht die Verwendung der Einschränkungen, um Instanzmethoden für Typparameter aufzurufen.
// 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");
}
Wenn ein generischer Typparameter als Einschränkung verwendet wird, wird es eine nackte Typeinschränkung aufgerufen.Nackte Typeinschränkungen sind nützlich, wenn eine Memberfunktion mit seinem eigenen Typparameter dass Parameter für den Typparameter des enthaltenden Typs einschränken müssen.
Im Folgenden Beispiel wird eine T nackte Typeinschränkung im Kontext der Add-Methode.
Nackte Typeinschränkungen können in generischen Klassendefinitionen ebenfalls verwendet werden.Die Nützlichkeit einer nackten Typeinschränkungen mit generischen Klassen ist eingeschränkt, da der Compiler keine Funktion über eine nackte Typeinschränkung davon ausgehen kann nur dadurch, dass er von Objectberechnet.Verwenden Sie nackte Typeinschränkungen auf generischen Klassen in Szenarien, in denen Sie eine Vererbungsbeziehung zwischen zwei Typparametern erzwungen werden soll.
// 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 {};