Polimorfisme C ++

Dalam tutorial ini, kita akan belajar mengenai polimorfisme di C ++ dengan bantuan contoh.

Polimorfisme adalah konsep penting pengaturcaraan berorientasikan objek. Ini bermaksud lebih daripada satu bentuk. Artinya, entiti (fungsi atau pengendali) yang sama berperilaku berbeza dalam senario yang berbeza. Sebagai contoh,

The +operator dalam C ++ digunakan untuk melakukan dua fungsi tertentu. Apabila ia digunakan dengan nombor (bilangan bulat dan nombor titik terapung), ia melakukan penambahan.

 int a = 5; int b = 6; int sum = a + b; // sum = 11

Dan apabila kita menggunakan +operator dengan tali, ia melakukan penggabungan rentetan. Sebagai contoh,

 string firstName = "abc "; string lastName = "xyz"; // name = "abc xyz" string name = firstName + lastName;

Kita dapat menerapkan polimorfisme dalam C ++ dengan cara berikut:

  1. Fungsi berlebihan
  2. Pengendalian berlebihan
  3. Fungsi mengatasi
  4. Fungsi maya

Kelebihan Fungsi C ++

Dalam C ++, kita dapat menggunakan dua fungsi yang memiliki nama yang sama jika mereka memiliki parameter yang berbeza (baik jenis atau jumlah argumen).

Dan, bergantung pada jumlah / jenis argumen, fungsi yang berbeza dipanggil. Sebagai contoh,

 // C++ program to overload sum() function #include using namespace std; // Function with 2 int parameters int sum(int num1, int num2) ( return num1 + num2; ) // Function with 2 double parameters double sum(double num1, double num2) ( return num1 + num2; ) // Function with 3 int parameters int sum(int num1, int num2, int num3) ( return num1 + num2 + num3; ) int main() ( // Call function with 2 int parameters cout << "Sum 1 = " << sum(5, 6) << endl; // Call function with 2 double parameters cout << "Sum 2 = " << sum(5.5, 6.6) << endl; // Call function with 3 int parameters cout << "Sum 3 = " << sum(5, 6, 7) << endl; return 0; )

Pengeluaran

 Jumlah 1 = 11 Jumlah 2 = 12.1 Jumlah 3 = 18

Di sini, kami telah membuat 3 sum()fungsi yang berbeza dengan parameter yang berbeza (bilangan / jenis parameter). Dan, berdasarkan argumen yang disampaikan semasa panggilan fungsi, tertentu sum()dipanggil.

Ini adalah polimorfisme masa kompilasi kerana penyusun tahu fungsi mana yang harus dilaksanakan sebelum program disusun.

Untuk mengetahui lebih lanjut mengenai, kunjungi tutorial C ++ Function Overloading kami.

Beban Pengendali C ++

Di C ++, kita boleh membebani operator selagi kita beroperasi pada jenis yang ditentukan pengguna seperti objek atau struktur.

Kita tidak boleh menggunakan pengendali muatan untuk jenis asas seperti int, doubledan lain-lain

Overloading operator pada dasarnya adalah overloading fungsi, di mana fungsi operator yang berlainan mempunyai simbol yang sama tetapi operan yang berbeza.

Dan, bergantung pada operasi, fungsi operator yang berbeza dilaksanakan. Sebagai contoh,

 // C++ program to overload ++ when used as prefix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++() ( value = value + 1; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++()" function ++count1; count1.display(); return 0; )

Pengeluaran

 Kira: 6

Di sini, kami telah memuatkan ++operator yang berlebihan , yang beroperasi pada objek Countkelas (jumlah objek1 dalam kes ini).

Kami telah menggunakan operator yang kelebihan beban ini untuk secara langsung meningkatkan pemboleh ubah nilai objek count1 oleh 1.

Ini juga merupakan polimorfisme masa kompilasi .

Untuk mengetahui lebih lanjut, kunjungi tutorial Pemuatan Operator C ++ kami.

Fungsi C ++ Menimpa

Dalam warisan C ++, kita dapat mempunyai fungsi yang sama di kelas dasar dan juga kelas turunannya.

Apabila kita memanggil fungsi menggunakan objek dari kelas turunan, fungsi kelas turunan dijalankan dan bukan pada kelas dasar.

Jadi, fungsi yang berbeza dilaksanakan bergantung pada objek yang memanggil fungsi tersebut.

Ini dikenali sebagai fungsi mengatasi di C ++. Sebagai contoh,

 // C++ program to demonstrate function overriding #include using namespace std; class Base ( public: virtual void print() ( cout << "Base Function" << endl; ) ); class Derived : public Base ( public: void print() ( cout << "Derived Function" << endl; ) ); int main() ( Derived derived1; // Call print() function of Derived class derived1.print(); return 0; )

Pengeluaran

 Fungsi Berasal

Di sini, kami telah menggunakan print()fungsi di Basekelas dan fungsi yang sama di Derivedkelas

Apabila kita memanggil print()menggunakan Derivedobjek yang berasal1, ia akan mengatasi print()fungsi Basedengan menjalankan print()fungsi Derivedkelas.

Ini adalah polimorfisme runtime kerana panggilan fungsi tidak diselesaikan oleh penyusun, tetapi diselesaikan pada masa runtime.

Untuk mengetahui lebih lanjut, kunjungi tutorial Penggantian Fungsi C ++ kami.

Fungsi Maya C ++

Dalam C ++, kita mungkin tidak dapat mengganti fungsi jika kita menggunakan penunjuk dari kelas dasar untuk menunjuk ke objek dari kelas yang berasal.

Menggunakan fungsi maya di kelas asas memastikan bahawa fungsi dapat ditimpa dalam kes-kes ini.

Oleh itu, fungsi maya sebenarnya berada di bawah fungsi yang berlebihan . Sebagai contoh,

 // C++ program to demonstrate the use of virtual functions #include using namespace std; class Base ( public: virtual void print() ( cout << "Base Function" << endl; ) ); class Derived : public Base ( public: void print() ( cout << "Derived Function"

Output

 Derived Function

Here, we have used a virtual function print() in the Base class to ensure that it is overridden by the function in the Derived class.

Virtual functions are runtime polymorphism.

To learn more, visit our C++ Virtual Functions tutorial.

Why Polymorphism?

Polymorphism allows us to create consistent code. For example,

Suppose we need to calculate the area of a circle and a square. To do so, we can create a Shape class and derive two classes Circle and Square from it.

In this case, it makes sense to create a function having the same name calculateArea() in both the derived classes rather than creating functions with different names, thus making our code more consistent.

Artikel menarik...