Obecné funkce (C++/CLI)

Obecná funkce je funkce, která je deklarována s parametry typu. Při zavolání se místo parametrů typu použijí skutečné typy.

Všechny platformy

Poznámky

Tato funkce se nevztahuje na všechny platformy.

prostředí Windows Runtime

Poznámky

Tato funkce není v prostředí Windows Runtime podporovaná.

Požadavky

Nevztahuje se.

CLR (Common Language Runtime)

Obecná funkce je funkce deklarovaná pomocí parametrů obecného typu. Při zavolání se místo parametrů typu použijí skutečné typy.

Syntaxe

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

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

generic-parameter:
  attributes_volit class identifier
  attributes_volit typename identifier

constraint-clause-list:
  constraint-clause-list_volit 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
Čárkami oddělený seznam volitelně přiřazených identifikátorů parametrů obecného typu.

attributes
(Volitelné) Dodatečné deklarativní informace. Další informace o atributech a třídách atributů naleznete v tématu atributy.

constraint-clause-list
Tento volitelný seznam určuje omezení typů, které lze použít jako argumenty typu. Přebírá formulář zadaný v omezeních parametrů obecného typu (C++/CLI).

function-definition
Definice metody nebo samostatné funkce. Funkce nemusí mít virtual modifikátor, který není povolený, protože virtuální metody nemusí být obecné. Tělo funkce může odkazovat na identifikátory parametrů obecného typu. Funkce může být operator funkcí.

generic-id
Když vyvoláte instanci obecné funkce, zadáte typy použité k jeho implementaci v objektu generic-argument-list. Tento seznam odpovídá generic-parameter-listpožadavkům a musí splňovat omezení volitelného constraint-clause-list.

generic-name
Obecná funkce může mít identifier název nebo může být operator funkcí.

Poznámky

Obecné funkce jsou funkce deklarované pomocí jednoho nebo více obecných parametrů typu. Můžou se jednat o metody v samostatných class funkcích nebo structnebo v samostatných funkcích. Jedna obecná deklarace implicitně deklaruje řadu funkcí, které se liší pouze v nahrazení jiného skutečného typu parametru obecného typu.

A class nebo struct konstruktor nemusí být deklarován s parametry obecného typu.

Při zavolání se parametr obecného typu nahradí skutečným typem. Skutečný typ může být explicitně zadán v šikmých závorkách pomocí syntaxe podobné volání šablony funkce. Pokud je volána bez parametrů typu, kompilátor se pokusí odvodit skutečný typ z parametrů zadaných ve volání funkce. Kompilátor hlásí chybu, pokud zamýšlený argument typu nelze odvodit z použitých parametrů.

Požadavky

Možnost kompilátoru: /clr

Příklady

Následující ukázka kódu ukazuje obecnou funkci.

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

Obecné funkce mohou být přetíženy na základě podpisu nebo arity, počtu parametrů typu funkce. Obecné funkce mohou být také přetíženy ne generickými funkcemi se stejným názvem, pokud se funkce liší v některých parametrech typu. Například následující funkce mohou být přetíženy:

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

Následující příklad používá obecnou funkci k vyhledání prvního prvku v poli. Deklaruje MyClass, který dědí ze základní třídy MyBaseClass. MyClass obsahuje obecnou funkci, MyFunctionkterá volá jinou obecnou funkci , MyBaseClassFunctionv rámci základní třídy. V main, obecná funkce, MyFunctionje volána pomocí různých argumentů 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!

Viz také

Přípony komponent pro .NET a UPW
Obecné typy