Pengendali terlampau beban C++ dan fungsi terlampau beban

Fungsi berlebihan dalam C++

Dalam skop yang sama, anda boleh mengisytiharkan beberapa fungsi dengan nama yang sama dengan fungsi yang serupa, tetapi parameter formal fungsi ini dengan nama yang sama (merujuk kepada nombor, jenis atau susunan parameter) mestilah berbeza. Anda tidak boleh membebankan fungsi hanya dengan membezakan jenis pulangan.

Dalam contoh berikut, fungsi nama yang sama print() digunakan untuk mengeluarkan jenis data yang berbeza:

#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;
}

Apabila kod di atas disusun dan dilaksanakan, ia akan Menghasilkan keputusan berikut:

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

Operator Overloading dalam C++

Anda boleh mentakrifkan semula atau melebihkan kebanyakan operator terbina dalam C++. Ini membolehkan anda menggunakan jenis pengendali tersuai.

Operator terlampau beban ialah fungsi dengan nama khas Nama fungsi terdiri daripada operator kata kunci dan simbol operator yang akan terlebih muatan. Seperti fungsi lain, pengendali terlebih beban mempunyai jenis pemulangan dan senarai parameter.

Box operator+(const Box&);

Mengisytiharkan bahawa pengendali penambahan digunakan untuk menambah dua objek Kotak dan mengembalikan objek Kotak terakhir. Kebanyakan pengendali terlampau beban boleh ditakrifkan sebagai fungsi bukan ahli biasa atau sebagai fungsi ahli kelas. Jika kita mentakrifkan fungsi di atas sebagai fungsi bukan ahli kelas, maka kita perlu lulus dua parameter untuk setiap operasi, seperti yang ditunjukkan di bawah:

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

Contoh berikut menunjukkan konsep operator lebih muatan menggunakan fungsi ahli . Di sini, objek diluluskan sebagai parameter dan sifat objek diakses menggunakan operator ini seperti yang ditunjukkan di bawah:

#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;
      }
      // 重载 + 运算符，用于把两个 Box 对象相加
      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;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
};
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   Box Box3;                // 声明 Box3，类型为 Box
   double volume = 0.0;     // 把体积存储在该变量中
 
   // Box1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // Box2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // Box1 的体积
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // Box2 的体积
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // 把两个对象相加，得到 Box3
   Box3 = Box1 + Box2;

   // Box3 的体积
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan Keputusan berikut:

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

Operator Lebih Muatan/Operator Tidak Lebih Muatan

Berikut ialah senarai operator lebih muatan:

Berikut ialah Senarai pengendali tidak lebih muatan daripada pengendali:

Contoh Operator Lebih Muatan

Berikut menyediakan contoh pelbagai operator lebih muatan untuk membantu anda memahami konsep lebihan beban.