Kelebihan Beban Operator Kenaikan dan Penurunan (C++)

Operator kenaikan dan penurunan termasuk dalam kategori khusus karena ada dua varian masing-masing:

• Preincrement dan postincrement

• Pendahuluan dan postdecrement

Ketika Anda menulis fungsi operator yang kelebihan beban, akan berguna untuk menerapkan versi terpisah untuk versi awalan dan pascafiks operator ini. Untuk membedakan antara keduanya, aturan berikut diamati: Bentuk awalan operator dinyatakan sama persis dengan operator unary lainnya; formulir postfix menerima argumen tambahan jenis int.

Catatan

Saat menentukan operator yang kelebihan beban untuk bentuk postfix dari operator kenaikan atau penurunan, argumen tambahan harus berjenis int; menentukan jenis lain menghasilkan kesalahan.

Contoh berikut menunjukkan cara menentukan operator prefiks dan kenaikan postfix dan penurunan untuk Point kelas:

// increment_and_decrement1.cpp
class Point
{
public:
   // Declare prefix and postfix increment operators.
   Point& operator++();       // Prefix increment operator.
   Point operator++(int);     // Postfix increment operator.

   // Declare prefix and postfix decrement operators.
   Point& operator--();       // Prefix decrement operator.
   Point operator--(int);     // Postfix decrement operator.

   // Define default constructor.
   Point() { _x = _y = 0; }

   // Define accessor functions.
   int x() { return _x; }
   int y() { return _y; }
private:
   int _x, _y;
};

// Define prefix increment operator.
Point& Point::operator++()
{
   _x++;
   _y++;
   return *this;
}

// Define postfix increment operator.
Point Point::operator++(int)
{
   Point temp = *this;
   ++*this;
   return temp;
}

// Define prefix decrement operator.
Point& Point::operator--()
{
   _x--;
   _y--;
   return *this;
}

// Define postfix decrement operator.
Point Point::operator--(int)
{
   Point temp = *this;
   --*this;
   return temp;
}

int main()
{
}

Operator yang sama dapat didefinisikan dalam cakupan file (secara global) menggunakan prototipe fungsi berikut:

friend Point& operator++( Point& );      // Prefix increment
friend Point operator++( Point&, int );  // Postfix increment
friend Point& operator--( Point& );      // Prefix decrement
friend Point operator--( Point&, int );  // Postfix decrement

Argumen jenis int yang menunjukkan bentuk postfix dari operator kenaikan atau penurunan umumnya tidak digunakan untuk meneruskan argumen. Biasanya berisi nilai 0. Namun, dapat digunakan sebagai berikut:

// increment_and_decrement2.cpp
class Int
{
public:
    Int operator++( int n ); // Postfix increment operator
private:
    int _i;
};

Int Int::operator++( int n )
{
    Int result = *this;
    if( n != 0 )    // Handle case where an argument is passed.
        _i += n;
    else
        _i++;       // Handle case where no argument is passed.
    return result;
}

int main()
{
   Int i;
   i.operator++( 25 ); // Increment by 25.
}

Tidak ada sintaks untuk menggunakan operator kenaikan atau penurunan untuk meneruskan nilai-nilai ini selain pemanggilan eksplisit, seperti yang ditunjukkan dalam kode sebelumnya. Cara yang lebih mudah untuk mengimplementasikan fungsi ini adalah dengan membebani operator penambahan/penugasan (+=).

Baca juga

Kelebihan Beban Operator