Generische Funktionen (C++/CLI)

  • Artikel

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>constraint-clause-listoptfunction-definition

generic-parameter-list:
  generic-parameter
  generic-parameter-list , generic-parameter

generic-parameter:
  attributesoptclassidentifier
  attributesopttypenameidentifier

constraint-clause-list:
  constraint-clause-listoptconstraint-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!

Siehe auch

Komponentenerweiterungen für .NET und UWP
Generics