C ++ Overloading (Operator dan Fungsi)

C ++ memungkinkan Anda menentukan lebih dari satu definisi untuk a function nama atau operator dalam ruang lingkup yang sama, yang disebut function overloading dan operator overloading masing-masing.

Deklarasi yang kelebihan beban adalah deklarasi yang dideklarasikan dengan nama yang sama dengan deklarasi yang dideklarasikan sebelumnya dalam lingkup yang sama, kecuali bahwa kedua deklarasi tersebut memiliki argumen yang berbeda dan definisi (implementasi) yang jelas berbeda.

Ketika Anda menelepon yang kelebihan beban function atau operator, kompilator menentukan definisi yang paling tepat untuk digunakan, dengan membandingkan tipe argumen yang Anda gunakan untuk memanggil fungsi atau operator dengan tipe parameter yang ditentukan dalam definisi. Proses memilih fungsi atau operator kelebihan beban yang paling tepat disebutoverload resolution.

Fungsi Overloading di C ++

Anda dapat memiliki beberapa definisi untuk nama fungsi yang sama dalam lingkup yang sama. Definisi fungsi harus berbeda satu sama lain dengan jenis dan / atau jumlah argumen dalam daftar argumen. Anda tidak bisa membebani deklarasi fungsi yang hanya berbeda menurut tipe kembalian.

Berikut adalah contoh fungsi yang sama print() sedang digunakan untuk mencetak tipe data yang berbeda -

#include <iostream>
using namespace std;
 
class printData {
   public:
      void print(int i) {
        cout << "Printing int: " << i << endl;
      }
      void print(double  f) {
        cout << "Printing float: " << f << endl;
      }
      void print(char* c) {
        cout << "Printing character: " << c << endl;
      }
};

int main(void) {
   printData pd;
 
   // Call print to print integer
   pd.print(5);
   
   // Call print to print float
   pd.print(500.263);
   
   // Call print to print character
   pd.print("Hello C++");
 
   return 0;
}

Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Operator Overloading di C ++

Anda dapat menentukan ulang atau membebani sebagian besar operator bawaan yang tersedia di C ++. Dengan demikian, programmer dapat menggunakan operator dengan tipe yang ditentukan pengguna juga.

Operator kelebihan beban adalah fungsi dengan nama khusus: kata kunci "operator" diikuti dengan simbol operator yang ditentukan. Seperti fungsi lainnya, operator yang kelebihan beban memiliki tipe kembalian dan daftar parameter.

Box operator+(const Box&);

mendeklarasikan operator penjumlahan yang bisa digunakan adddua objek Box dan mengembalikan objek Box terakhir. Kebanyakan operator yang kelebihan beban dapat didefinisikan sebagai fungsi non-anggota biasa atau sebagai fungsi anggota kelas. Jika kita mendefinisikan fungsi di atas sebagai fungsi non-anggota dari sebuah kelas maka kita harus memberikan dua argumen untuk setiap operan sebagai berikut -

Box operator+(const Box&, const Box&);

Berikut adalah contoh untuk menunjukkan konsep operator over loading menggunakan fungsi anggota. Di sini sebuah objek dikirimkan sebagai argumen yang propertinya akan diakses menggunakan objek ini, objek yang akan memanggil operator ini dapat diakses menggunakanthis operator seperti yang dijelaskan di bawah ini -

#include <iostream>
using namespace std;

class Box {
   public:
      double getVolume(void) {
         return length * breadth * height;
      }
      void setLength( double len ) {
         length = len;
      }
      void setBreadth( double bre ) {
         breadth = bre;
      }
      void setHeight( double hei ) {
         height = hei;
      }
      
      // Overload + operator to add two Box objects.
      Box operator+(const Box& b) {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
      
   private:
      double length;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};

// Main function for the program
int main() {
   Box Box1;                // Declare Box1 of type Box
   Box Box2;                // Declare Box2 of type Box
   Box Box3;                // Declare Box3 of type Box
   double volume = 0.0;     // Store the volume of a box here
 
   // box 1 specification
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // box 2 specification
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // volume of box 1
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // volume of box 2
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:
   Box3 = Box1 + Box2;

   // volume of box 3
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

Operator Overloadable / Non-overloadable

Berikut adalah daftar operator yang bisa kelebihan beban -

+	-	*	/	%	^
&	|	~	!	,	=
<	>	<=	> =	++	-
<<	>>	==	! =	&&	||
+ =	- =	/ =	% =	^ =	& =
| =	* =	<< =	>> =	[]	()
->	-> *	baru	baru []	menghapus	menghapus []

Berikut adalah daftar operator, yang tidak dapat kelebihan beban -

::

. *

.

?:

Contoh Overloading Operator

Berikut berbagai contoh kelebihan beban operator untuk membantu Anda memahami konsep tersebut.

Sr Tidak	Operator & Contoh
1	Operator Unary Overloading
2	Pembebanan Operator Biner
3	Overloading Operator Relasional
4	Kelebihan Operator Input / Output
5	++ dan - Operator Overloading
6	Overloading Operator Penugasan
7	Pemanggilan fungsi () Operator Overloading
8	Berlangganan [] Operator Berlebihan
9	Operator Akses Anggota Kelas -> Beban Berlebih