Generische Funktionen (C++/CLI)
Eine generische Funktion ist eine Funktion, die mit Typparametern deklariert wird. Beim Aufruf werden anstelle der Typparameter die tatsächlichen Typen verwendet.
Alle Plattformen
Hinweise
Dieses Feature gilt nicht für alle Plattformen.
Windows-Runtime
Hinweise
Dieses Feature wird im Windows-Runtime nicht unterstützt.
Anforderungen
Nicht zutreffend.
Übersicht: Common Language Runtime (CLR)
Eine generische Funktion ist eine Funktion, die mit generischen Typparametern deklariert wird. Beim Aufruf werden anstelle der Typparameter die tatsächlichen Typen verwendet.
Syntax
generic-declaration:
generic < generic-parameter-list >optconstraint-clause-list function-definition
generic-parameter-list:
generic-parameter
generic-parameter-list , generic-parameter
generic-parameter:
attributesopt class identifier
attributesopt typename identifier
constraint-clause-list:
constraint-clause-listopt constraint-clause
constraint-clause:
where identifier : constraint-item-list
constraint-item-list:
constraint-item
constraint-item-list , constraint-item
constraint-item:
type-id
ref class
ref struct
value class
value struct
gcnew ( )
generic-id:
generic-name < generic-argument-list >
generic-name:
identifier
operator-function-id
generic-argument-list:
generic-argument
generic-argument-list , generic-argument
generic-argument:
type-id
Parameter
generic-parameter-list
Eine durch Trennzeichen getrennte Liste von optional zugeordneten generischen Typparameterbezeichnern.
attributes
(Optional) Zusätzliche deklarative Informationen. Weitere Informationen zu Attributen und Attributklassen finden Sie unter Attribute.
constraint-clause-list
Diese optionale Liste gibt Einschränkungen für die Typen an, die als Typargumente verwendet werden können. Es verwendet das in Constraints für generische Typparameter (C++/CLI) angegebene Formular.
function-definition
Eine Definition einer Methode oder eigenständigen Funktion. Die Funktion verfügt möglicherweise nicht über einen virtual Modifizierer, der nicht zulässig ist, da virtuelle Methoden möglicherweise nicht generisch sind. Der Textkörper der Funktion kann auf die generischen Typparameterbezeichner verweisen. Die Funktion kann eine operator Funktion sein.
generic-id
Wenn Sie eine Instanz einer generischen Funktion aufrufen, geben Sie die Typen an, die zum Implementieren in der generic-argument-list. Diese Liste entspricht dem generic-parameter-list, und muss die Einschränkungen der optionalen constraint-clause-list.
generic-name
Eine generische Funktion kann einen identifier Namen haben, oder es kann eine operator Funktion sein.
Hinweise
Generische Funktionen sind Funktionen, die mit einem oder mehreren generischen Typparametern deklariert werden. Sie können Methoden in einer class oder structeigenständigen Funktionen sein. Eine einzelne generische Deklaration deklariert implizit eine Gruppe von Funktionen, die sich nur in der Ersetzung der tatsächlichen Typen für den generischen Typparameter unterscheiden.
Ein class oder struct Konstruktor kann nicht mit generischen Typparametern deklariert werden.
Beim Aufruf wird der generische Typparameter durch einen tatsächlichen Typ ersetzt. Der tatsächliche Typ kann explizit in gewinkelten Klammern angegeben werden, wobei eine Syntax verwendet wird, die einem Funktionsvorlagenaufruf ähnelt. Beim Aufruf ohne die Typparameter versucht der Compiler, den tatsächlichen Typ aus den im Funktionsaufruf übergebenen Parametern abzuleiten. Der Compiler meldet einen Fehler, wenn das beabsichtigte Typargument nicht von den verwendeten Parametern abgeleitet werden kann.
Anforderungen
Compileroption: /clr
Beispiele
Das folgende Codebeispiel veranschaulicht eine generische Funktion.
// generics_generic_function_1.cpp
// compile with: /clr
generic <typename ItemType>
void G(int i) {}
ref struct A {
generic <typename ItemType>
void G(ItemType) {}
generic <typename ItemType>
static void H(int i) {}
};
int main() {
A myObject;
// generic function call
myObject.G<int>(10);
// generic function call with type parameters deduced
myObject.G(10);
// static generic function call
A::H<int>(10);
// global generic function call
G<int>(10);
}
Generische Funktionen können basierend auf Signatur oder Arität, der Anzahl der Typparameter für eine Funktion, überladen werden. Generische Funktionen können auch mit nicht gleichnamigen generischen Funktionen überladen werden, sofern sich die Funktionen in einigen Typparametern unterscheiden. Folgende Funktionen können beispielsweise überladen werden:
// generics_generic_function_2.cpp
// compile with: /clr /c
ref struct MyClass {
void MyMythod(int i) {}
generic <class T>
void MyMythod(int i) {}
generic <class T, class V>
void MyMythod(int i) {}
};
Das folgende Beispiel verwendet eine generische Funktion, um das erste Element in einem Array zu suchen. Es deklariert MyClass, die von der Basisklasse MyBaseClass erbt. MyClass enthält die generische Funktion MyFunction, die innerhalb der Basisklasse eine andere generische Funktion aufruft: MyBaseClassFunction. In main wird die generische Funktion MyFunction mithilfe von unterschiedlichen Typargumenten aufgerufen.
// generics_generic_function_3.cpp
// compile with: /clr
using namespace System;
ref class MyBaseClass {
protected:
generic <class ItemType>
ItemType MyBaseClassFunction(ItemType item) {
return item;
}
};
ref class MyClass: public MyBaseClass {
public:
generic <class ItemType>
ItemType MyFunction(ItemType item) {
return MyBaseClass::MyBaseClassFunction<ItemType>(item);
}
};
int main() {
MyClass^ myObj = gcnew MyClass();
// Call MyFunction using an int.
Console::WriteLine("My function returned an int: {0}",
myObj->MyFunction<int>(2003));
// Call MyFunction using a string.
Console::WriteLine("My function returned a string: {0}",
myObj->MyFunction<String^>("Hello generic functions!"));
}
My function returned an int: 2003
My function returned a string: Hello generic functions!