Funkcje ogólne (C++/CLI)

Funkcja ogólna to funkcja zadeklarowana z parametrami typu. Po wywołaniu typy rzeczywiste są używane zamiast parametrów typu.

Wszystkie platformy

Uwagi

Ta funkcja nie ma zastosowania do wszystkich platform.

Środowisko wykonawcze systemu Windows

Uwagi

Ta funkcja nie jest obsługiwana w środowisko wykonawcze systemu Windows.

Wymagania

Nie dotyczy.

środowiska uruchomieniowe w trakcie wykonania

Funkcja ogólna to funkcja zadeklarowana z parametrami typu ogólnego. Po wywołaniu typy rzeczywiste są używane zamiast parametrów typu.

Składnia

generic-declaration:
  generic< generic-parameter-list > constraint-clause-list_Zdecydować function-definition

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

generic-parameter:
  attributes_Zdecydować class identifier
  attributes_Zdecydować typename identifier

constraint-clause-list:
  constraint-clause-list_Zdecydować 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

Parametry

generic-parameter-list
Rozdzielana przecinkami lista opcjonalnych identyfikatorów parametrów typu ogólnego.

attributes
(Opcjonalnie) Dodatkowe informacje deklaratywne. Aby uzyskać więcej informacji na temat atrybutów i klas atrybutów, zobacz atrybuty.

constraint-clause-list
Ta opcjonalna lista określa ograniczenia dotyczące typów, które mogą być używane jako argumenty typu. Przyjmuje ona postać określoną w ograniczeniach dotyczących parametrów typu ogólnego (C++/CLI).It takes the form specified in Constraints on generic type parameters (C++/CLI).

function-definition
Definicja metody lub funkcji autonomicznej. Funkcja może nie mieć virtual modyfikatora, który nie jest dozwolony, ponieważ metody wirtualne mogą nie być ogólne. Treść funkcji może odwoływać się do identyfikatorów parametrów typu ogólnego. Funkcja może być funkcją operator .

generic-id
Podczas wywoływania wystąpienia funkcji ogólnej należy określić typy używane do zaimplementowania go w obiekcie generic-argument-list. Ta lista odpowiada elementowi generic-parameter-listi musi spełniać ograniczenia opcjonalnego constraint-clause-listelementu .

generic-name
Funkcja ogólna może mieć identifier jako nazwę lub może być funkcją operator .

Uwagi

Funkcje ogólne to funkcje zadeklarowane przy użyciu co najmniej jednego parametru typu ogólnego. Mogą to być metody w class funkcjach autonomicznych lub lub struct. Pojedyncza deklaracja ogólna niejawnie deklaruje rodzinę funkcji, które różnią się tylko w podstawieniu innego rzeczywistego typu dla parametru typu ogólnego.

Konstruktor class lub struct może nie być zadeklarowany z parametrami typu ogólnego.

Po wywołaniu parametr typu ogólnego jest zastępowany przez rzeczywisty typ. Rzeczywisty typ może być jawnie określony w nawiasach kątowych przy użyciu składni podobnej do wywołania szablonu funkcji. W przypadku wywołania bez parametrów typu kompilator podejmie próbę wyłudzenia rzeczywistego typu z parametrów podanych w wywołaniu funkcji. Kompilator zgłasza błąd, jeśli nie można wywołać zamierzonego argumentu typu z użytych parametrów.

Wymagania

Opcja kompilatora: /clr

Przykłady

Poniższy przykładowy kod przedstawia funkcję ogólną.

// 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);
}

Funkcje ogólne mogą być przeciążone na podstawie sygnatury lub arity, liczby parametrów typu w funkcji. Ponadto funkcje ogólne mogą być przeciążone funkcjami niegeneryjnymi o tej samej nazwie, o ile funkcje różnią się w niektórych parametrach typu. Na przykład następujące funkcje mogą być przeciążone:

// 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) {}
};

W poniższym przykładzie użyto funkcji ogólnej, aby znaleźć pierwszy element w tablicy. Deklaruje element MyClass, który dziedziczy z klasy MyBaseClassbazowej . MyClass zawiera funkcję ogólną , MyFunctionktóra wywołuje inną funkcję ogólną, MyBaseClassFunction, w klasie bazowej. W mainsystemie funkcja MyFunctionogólna , jest wywoływana przy użyciu różnych argumentów typu.

// 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!

Zobacz też

Rozszerzenia składników dla platformy .NET i platformy uniwersalnej systemu Windows
Typy ogólne