Menambah atau mengurangi nilai variabel tepat satu adalah operasi yang begitu sering dipakai sehingga C++ memberinya operator khusus: ++ (increment) dan -- (decrement). Menariknya, masing-masing punya dua bentuk — prefix yang ditulis di depan variabel (++i) dan postfix yang ditulis di belakang (i++) — dan keduanya berbeda perilaku bila nilai hasilnya dipakai dalam ekspresi. Pada Chapter ini kita membedakan keduanya dengan bukti output, melihat kapan bentuk mana yang lebih tepat, dan menguji bahwa ++ juga bekerja pada tipe double serta (sebagai pratinjau) pada pointer.

Satu Operator, Dua Bentuk #

Kedua bentuk sama-sama mengubah isi variabel satu langkah; perbedaannya ada pada nilai yang dihasilkan ekspresinya. Prefix ++i menghasilkan nilai baru setelah kenaikan, sedangkan postfix i++ menghasilkan nilai lama sebelum kenaikan. Bentuk ++i juga setara dengan i += 1 yang kita pelajari pada Chapter Operator Penugasan — compound assignment memang bekerja dengan pola yang sama.

cpp 
#include <iostream>

int main() {
    int i = 5;
    std::cout << "i mulai dari " << i << "\n\n";

    // Prefix ++i: naikkan dulu, lalu hasilkan nilai baru
    std::cout << "++i menghasilkan " << ++i << "\n";
    std::cout << "i sekarang     " << i << "\n\n";

    // Postfix i++: hasilkan nilai lama dulu, lalu naikkan
    std::cout << "i++ menghasilkan " << i++ << "\n";
    std::cout << "i sekarang     " << i << "\n\n";

    // -- dan -- bekerja dengan pola yang sama
    int j = 3;
    std::cout << "--j menghasilkan " << --j << "\n";
    std::cout << "j-- menghasilkan " << j-- << "\n";
    std::cout << "j sekarang     " << j << "\n\n";

    // Beda perilaku saat nilainya dipakai/diambil salinannya
    int stokLama = 10;
    int salinanPrefix = ++stokLama;    // stokLama jadi 11, salinan 11
    int salinanPostfix = stokLama++;   // salinan 11, stokLama jadi 12
    std::cout << "salinanPrefix  = " << salinanPrefix << "\n";
    std::cout << "salinanPostfix = " << salinanPostfix << "\n";
    std::cout << "stokLama       = " << stokLama << "\n\n";

    // ++ bekerja juga pada floating-point: naik 1.0
    double suhu = 2.5;
    suhu++;
    std::cout << "suhu++         = " << suhu << "\n";

    return 0;
}

Output yang Dihasilkan:

text 
i mulai dari 5

++i menghasilkan 6
i sekarang     6

i++ menghasilkan 6
i sekarang     7

--j menghasilkan 2
j-- menghasilkan 2
j sekarang     1

salinanPrefix  = 11
salinanPostfix = 11
stokLama       = 12

suhu++         = 3.5

Mari kita bedah bagian pentingnya:

  1. Baris 10-11 (++i): kenaikan terjadi dulu, i menjadi 6, lalu ekspresi menghasilkan nilai baru itu — sehingga tercetak 6 dan baris berikutnya menegaskan i memang 6.
  2. Baris 14-15 (i++): sebaliknya, ekspresi menghasilkan nilai lama 6, baru setelah itu i naik menjadi 7. Inilah inti perbedaan prefix dan postfix.
  3. Baris 18-20 (--j dan j--): decrement menurunkan satu langkah dengan pola identik. Ekspresi --j menghasilkan 2, lalu j-- menghasilkan 2 juga (nilai saat itu) sebelum j berakhir di 1.
  4. Baris 24-27: saat hasilnya disimpan ke variabel lain, urutan terasa nyata. ++stokLama menyimpan 11 ke salinanPrefix; satu baris di bawahnya stokLama++ menyimpan nilai saat itu (11) ke salinanPostfix, lalu stokLama berakhir 12.
  5. Baris 30-32 (suhu++): pada double, ++ menambah 1.0, sehingga 2.5 menjadi 3.5.

Kapan Pakai Prefix, Kapan Postfix #

Kaidah praktisnya: pakai prefix (++i) secara default. Ketika nilai hasil ekspresi tidak dipakai — misalnya pernyataan ++i; berdiri sendiri — prefix dan postfix hasil akhirnya sama, tetapi prefix menuliskan maksud kita lebih lurus tanpa nuansa “nilai lama” yang tidak pernah dipakai. Postfix dipilih justru saat kita butuh nilai lamanya dalam ekspresi yang sama, misalnya memberi nomor urut sebelum menaikkan penghitung.

Perlu diingat, i++ yang nilainya tidak dipakai bukanlah bug; banyak programmer C++ yang memilihnya karena kebiasaan dari gaya C. Yang penting adalah konsisten dan tidak mencampur operasi lain dalam ekspresi yang sama dengan ++.

++ pada Tipe Lain: Double dan Pointer #

Pada double, ++ menambah tepat 1.0, seperti terlihat pada 2.5 yang menjadi 3.5 di output program. Pemakaian ini sah, walaupun dalam praktik kenaikan 1.0 pada bilangan riil jarang dibutuhkan dibanding menuliskan suhu += 0.5; untuk langkah yang lebih bermakna.

Operator ++ juga punya peran penting pada pointer, yaitu memindahkan pointer ke elemen berikutnya — dan di situ prefix/postfix kembali berbeda perilaku persis seperti pada int. Karena pointer belum kita bahas, potongan berikut cukup dibaca sebagai pratinjau, bukan materi yang wajib dikuasai sekarang:

cpp Pratinjau: ++ pada pointer 
// Akan dibahas tuntas pada Section Pointer dan Reference,
// Chapter Pointer Arithmetic.
int nilai[3] = {10, 20, 30};
int* p = nilai;   // p menunjuk elemen pertama (10)
p++;              // p kini menunjuk elemen kedua (20) — bukan byte berikutnya

Yang menarik dari potongan di atas: p++ memajukan pointer sebesar ukuran satu elemen, bukan satu byte. Perilaku semacam ini disebut pointer arithmetic dan diuraikan tuntas pada Section Pointer dan Reference.

Kita baru menggeser nilai satu langkah. Chapter berikutnya turun ke level paling bawah: operator bitwise yang bekerja per bit, termasuk &, |, ^, ~, dan pasangan geser <</>>.