C ++ Polimorfisme

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

Polimorfisme adalah konsep penting dari pemrograman berorientasi objek. Ini berarti lebih dari satu bentuk. Artinya, entitas yang sama (fungsi atau operator) berperilaku berbeda dalam skenario yang berbeda. Sebagai contoh,

The +operator dalam C ++ digunakan untuk melakukan dua fungsi tertentu. Ketika digunakan dengan angka (integer dan angka floating-point), itu melakukan penambahan.

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

Dan saat kita menggunakan +operator dengan string, ia melakukan penggabungan string. Sebagai contoh,

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

Kita dapat mengimplementasikan polimorfisme di C ++ menggunakan cara berikut:

  1. Fungsi kelebihan beban
  2. Operator kelebihan beban
  3. Fungsi menimpa
  4. Fungsi virtual

Fungsi C ++ Overloading

Di C ++, kita dapat menggunakan dua fungsi yang memiliki nama yang sama jika keduanya memiliki parameter yang berbeda (baik tipe maupun jumlah argumen).

Dan, bergantung pada jumlah / jenis argumen, fungsi yang berbeda 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; )

Keluaran

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

Di sini, kami telah membuat 3 sum()fungsi berbeda dengan parameter berbeda (jumlah / jenis parameter). Dan, berdasarkan argumen yang diteruskan selama pemanggilan fungsi, suatu tertentu sum()dipanggil.

Ini adalah polimorfisme waktu kompilasi karena kompilator mengetahui fungsi mana yang akan dijalankan sebelum program dikompilasi.

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

C ++ Operator Overloading

Di C ++, kita dapat membebani operator selama kita beroperasi pada tipe yang ditentukan pengguna seperti objek atau struktur.

Kita tidak bisa menggunakan operator overloading untuk jenis dasar seperti int, double, dll

Operator overloading pada dasarnya adalah fungsi overloading, dimana fungsi operator yang berbeda mempunyai simbol yang sama tetapi operan yang berbeda.

Dan, bergantung pada operannya, fungsi operator yang berbeda dijalankan. 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; )

Keluaran

 Hitung: 6

Di sini, kami telah membebani ++operator, yang beroperasi pada objek Countkelas (objek count1 dalam kasus ini).

Kami telah menggunakan operator kelebihan beban ini untuk secara langsung menaikkan variabel nilai dari objek count1 1.

Ini juga merupakan polimorfisme waktu kompilasi .

Untuk mempelajari lebih lanjut, kunjungi tutorial C ++ Operator Overloading kami.

C ++ Function Overriding

Dalam pewarisan C ++, kita dapat memiliki fungsi yang sama di kelas dasar serta kelas turunannya.

Saat kita memanggil fungsi menggunakan objek dari kelas turunan, fungsi dari kelas turunan dieksekusi alih-alih yang ada di kelas dasar.

Jadi, berbagai fungsi dijalankan tergantung pada objek yang memanggil fungsi tersebut.

Ini dikenal sebagai penggantian fungsi 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; )

Keluaran

 Fungsi Turunan

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

Saat kita memanggil print()menggunakan Derivedobjek turunan1, print()fungsi tersebut menggantikan fungsi Basedengan menjalankan print()fungsi Derivedkelas.

Ini adalah polimorfisme waktu proses karena pemanggilan fungsi tidak diselesaikan oleh kompilator, tetapi diselesaikan dalam waktu proses.

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

C ++ Fungsi Virtual

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

Menggunakan fungsi virtual di kelas dasar memastikan bahwa fungsi tersebut dapat diganti dalam kasus ini.

Jadi, fungsi virtual sebenarnya berada di bawah fungsi overriding . 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 yang menarik...