Fungsi generik (C++/CLI)

Fungsi generik adalah fungsi yang dideklarasikan dengan parameter jenis. Saat dipanggil, jenis aktual digunakan alih-alih parameter jenis.

Semua platform

Keterangan

Fitur ini tidak berlaku untuk semua platform.

Windows Runtime

Keterangan

Fitur ini tidak didukung di Windows Runtime.

Persyaratan

Tidak berlaku.

Runtime Bahasa Umum

Fungsi generik adalah fungsi yang dideklarasikan dengan parameter jenis generik. Saat dipanggil, jenis aktual digunakan alih-alih parameter jenis.

Sintaks

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

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

generic-parameter:
  attributes_Memilih class identifier
  attributes_Memilih typename identifier

constraint-clause-list:
  constraint-clause-list_Memilih 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
Daftar pengidentifikasi parameter jenis generik yang dipisahkan koma secara opsional.

attributes
(Opsional) Informasi deklaratif ekstra. Untuk informasi selengkapnya tentang atribut dan kelas atribut, lihat atribut.

constraint-clause-list
Daftar opsional ini menentukan batasan pada jenis yang dapat digunakan sebagai argumen jenis. Dibutuhkan formulir yang ditentukan dalam Batasan pada parameter jenis generik (C++/CLI).

function-definition
Definisi metode atau fungsi mandiri. Fungsi ini mungkin tidak memiliki virtual pengubah, yang tidak diizinkan karena metode virtual mungkin tidak umum. Isi fungsi dapat merujuk ke pengidentifikasi parameter jenis generik. Fungsi ini mungkin merupakan operator fungsi.

generic-id
Saat Anda memanggil instans fungsi generik, Anda menentukan jenis yang digunakan untuk mengimplementasikannya di generic-argument-list. Daftar ini sesuai dengan generic-parameter-list, dan harus memenuhi batasan opsional constraint-clause-list.

generic-name
Fungsi generik mungkin memiliki identifier sebagai namanya, atau mungkin merupakan operator fungsi.

Keterangan

Fungsi generik adalah fungsi yang dideklarasikan dengan satu atau beberapa parameter jenis generik. Mereka mungkin metode dalam class fungsi atau struct, atau mandiri. Deklarasi generik tunggal secara implisit menyatakan keluarga fungsi yang hanya berbeda dalam penggantian jenis aktual yang berbeda untuk parameter jenis generik.

Konstruktor class atau struct mungkin tidak dideklarasikan dengan parameter jenis generik.

Ketika dipanggil, parameter jenis generik digantikan oleh jenis aktual. Jenis aktual dapat ditentukan secara eksplisit dalam tanda kurung sudut menggunakan sintaks yang mirip dengan panggilan templat fungsi. Jika dipanggil tanpa parameter jenis, pengkompilasi akan mencoba menyimpulkan jenis aktual dari parameter yang disediakan dalam panggilan fungsi. Pengkompilasi melaporkan kesalahan jika argumen jenis yang dimaksudkan tidak dapat disimpulkan dari parameter yang digunakan.

Persyaratan

Opsi pengkompilasi: /clr

Contoh

Sampel kode berikut menunjukkan fungsi generik.

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

Fungsi generik dapat kelebihan beban berdasarkan tanda tangan atau aritas, jumlah parameter jenis pada fungsi. Selain itu, fungsi generik dapat kelebihan beban dengan fungsi non-generik dengan nama yang sama, selama fungsi berbeda dalam beberapa parameter jenis. Misalnya, fungsi berikut dapat kelebihan beban:

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

Contoh berikut menggunakan fungsi generik untuk menemukan elemen pertama dalam array. Ini menyatakan MyClass, yang mewarisi dari kelas MyBaseClassdasar . MyClass berisi fungsi generik, MyFunction, yang memanggil fungsi generik lain, MyBaseClassFunction, dalam kelas dasar. Dalam main, fungsi generik, MyFunction, disebut menggunakan argumen jenis yang berbeda.

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

Lihat juga

Ekstensi Komponen untuk .NET dan UWP
Generik