Bagaimana untuk Membebankan Operator Penambahan ( ) untuk Kedua-dua Pra dan Selepas Kenaikan dalam C ?

Lebih muatan untuk Peningkatan Pra dan Selepas: Menyelesaikan Kekaburan

Pengendali boleh dibebankan dalam C untuk melanjutkan fungsi pengendali terbina dalam untuk jenis yang ditentukan pengguna. Satu kes penggunaan biasa ialah melebihkan operator kenaikan ( ) untuk kedua-dua operasi pra dan selepas kenaikan. Walau bagaimanapun, mencapai ini tanpa menghadapi isu kekaburan adalah satu cabaran.

Pendekatan Awal: Jenis Pulangan Sama

Dalam coretan kod yang disediakan, percubaan awal membebankan operator dengan jenis pulangan yang sama (int) untuk kedua-dua sebelum dan selepas kenaikan. Walau bagaimanapun, pendekatan ini gagal disebabkan oleh sebab-sebab berikut:

• Lebih Muatan Fungsi Berdasarkan Jenis Pemulangan:
  C tidak membenarkan lebihan fungsi berdasarkan jenis pemulangan semata-mata. Walaupun jenis hujah yang berbeza-beza boleh membezakan antara beban lampau, jenis pulangan yang berbeza sahaja tidak mencukupi.
• Kekaburan dalam Resolusi Lebihan:
  Apabila memanggil SampleObject, pengkompil tidak boleh menentukan beban lampau yang mana gunakan kerana kedua-duanya mengembalikan jenis yang sama. Kekaburan ini menyebabkan ralat masa kompilasi.

Penyelesaian: Terlalu Beban dengan Dummy Argument

Untuk menyelesaikan kekaburan ini, versi postfix operator telah terlebih dimuatkan dengan parameter int tiruan. Pengubahsuaian ini mencapai dua matlamat:

• Membezakan Postfix Overload:
  Parameter dummy menyediakan tandatangan unik untuk postfix overload, membezakannya daripada prefix overload.
• Memelihara Logik Penambahan:
  Beban awalan kekal tidak berubah, menambah tika semasa dan mengembalikan rujukan kepadanya. Lebihan postfix mencipta salinan sementara tika semasa, menambahnya dan mengembalikan nilai sebelum kenaikan.

Contoh Kod:

<code class="cpp">#include <iostream>

class CSample {
 public:
  int m_iValue;     // just to directly fetch inside main()
  CSample() : m_iValue(0) {}
  CSample(int val) : m_iValue(val) {}

  // Overloading ++ for Pre-Increment
  CSample& operator++() {
    ++m_iValue;
    return *this;
  }

  // Overloading ++ for Post-Increment
  CSample operator++(int) {
    CSample tmp(*this);
    operator++(); // prefix-increment this instance
    return tmp;   // return value before increment
  }
};

int main() {
  CSample obj1(5);
  std::cout << obj1.m_iValue << std::endl; // Output: 5

  // Pre-Increment
  ++obj1;
  std::cout << obj1.m_iValue << std::endl; // Output: 6

  // Post-Increment
  CSample obj2 = obj1++;
  std::cout << obj2.m_iValue << std::endl; // Output: 6
  std::cout << obj1.m_iValue << std::endl; // Output: 7

  return 0;
}</code>

Dengan melebihkan operator dengan hujah tiruan untuk versi postfix, kami menyelesaikan kekaburan dengan berkesan dan membolehkan kedua-dua kelakuan pra dan selepas kenaikan untuk jenis tersuai dalam C .

Atas ialah kandungan terperinci Bagaimana untuk Membebankan Operator Penambahan ( ) untuk Kedua-dua Pra dan Selepas Kenaikan dalam C ?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!