Operator C++: aritmatika, perbandingan, logika, dan lainnya

Apa yang dilakukan operator

Operator adalah simbol yang melakukan aksi pada satu atau beberapa nilai, yang disebut operand. Kamu sebenarnya sudah memakai satu operator: = yang mengikat sebuah nilai ke variabel. C++ punya banyak operator untuk matematika, perbandingan, logika, dan manipulasi bit, plus beberapa bagian tajam yang sering menjebak pemula.

Di halaman sebelumnya kamu sudah melihat bagaimana const mengunci sebuah nilai. Operator adalah cara kamu menghitung nilai yang kamu simpan, baik konstan maupun tidak. Mari kita bahas kelompok operator yang akan kamu pakai setiap hari.

Operator aritmatika

Ada lima operator aritmatika: +, -, *, /, dan % (modulo, yaitu sisa hasil bagi):

#include <iostream>
using namespace std;

int main() {
    int a = 17, b = 5;

    cout << "sum:       " << a + b << "\n";
    cout << "difference: " << a - b << "\n";
    cout << "product:    " << a * b << "\n";
    cout << "quotient:   " << a / b << "\n";
    cout << "remainder:  " << a % b << "\n";

    return 0;
}

Jebakan terbesarnya ada di hasil bagi. 17 / 5 mencetak 3, bukan 3.4. Kalau kedua operand adalah integer, / melakukan pembagian integer dan membuang bagian pecahannya: hasilnya dipotong ke arah nol, bukan dibulatkan. Kalau kamu mau pecahan yang sebenarnya, minimal satu operand harus bilangan floating-point:

#include <iostream>
using namespace std;

int main() {
    int a = 17, b = 5;

    cout << a / b << "\n";          // 3  -> integer division
    cout << 17.0 / 5 << "\n";       // 3.4 -> 17.0 is a double
    cout << (double)a / b << "\n";  // 3.4 -> cast one operand first

    return 0;
}

Operator % hanya bekerja pada integer. Memakai % pada double akan menghasilkan error kompilasi. Untuk sisa bagi bilangan floating-point, pakai std::fmod dari <cmath>.

Operator penugasan dan operator gabungan

Satu tanda = berarti penugasan (assignment), bukan perbandingan. C++ menyediakan bentuk gabungan yang menyatukan sebuah operasi dengan penugasan, jadi kamu tidak perlu menulis nama variabel dua kali:

#include <iostream>
using namespace std;

int main() {
    int score = 10;

    score += 5;   // score = score + 5  -> 15
    score -= 3;   // 12
    score *= 2;   // 24
    score /= 4;   // 6
    score %= 4;   // 2

    cout << score << "\n";   // 2
    return 0;
}

Kesalahan klasik yang menyakitkan adalah menulis = padahal maksudnya == di dalam kondisi. if (x = 0) menugaskan 0 ke x lalu menguji hasilnya (yang bernilai false), bukannya membandingkan. Compiler modern memberi peringatan untuk hal ini kalau peringatan diaktifkan. Biarkan -Wall tetap menyala dan tanggapi peringatan itu dengan serius.

Operator perbandingan

Operator perbandingan mengajukan pertanyaan ya/tidak dan menghasilkan bool (true atau false):

#include <iostream>
using namespace std;

int main() {
    int x = 7, y = 10;

    cout << (x == y) << "\n";  // 0  (false)
    cout << (x != y) << "\n";  // 1  (true)
    cout << (x <  y) << "\n";  // 1
    cout << (x >= 7) << "\n";  // 1

    cout << boolalpha;          // print true/false instead of 1/0
    cout << (x < y) << "\n";    // true
    return 0;
}

Secara default cout mencetak bool sebagai 1 atau 0. Kirim boolalpha ke stream sekali saja, dan sisa output stream itu akan memakai kata true/false.

Ada jebakan halus: jangan merangkai perbandingan seperti 1 < x < 10. Ekspresi itu dibaca sebagai (1 < x) < 10. Perbandingan pertama menghasilkan bool (0 atau 1), lalu dibandingkan dengan 10, sehingga hasilnya hampir selalu true. Tulis 1 < x && x < 10 sebagai gantinya.

Operator logika dan short-circuit

&& (dan), || (atau), dan ! (bukan) menggabungkan ekspresi boolean. Dua yang pertama melakukan short-circuit: evaluasi berhenti begitu hasilnya sudah pasti.

#include <iostream>
using namespace std;

bool check(const char* label) {
    cout << "checked " << label << "\n";
    return true;
}

int main() {
    // Right side of && is skipped because the left is false:
    if (false && check("A")) {}

    // Right side of || is skipped because the left is true:
    if (true || check("B")) {}

    cout << "done\n";
    return 0;
}

Baik check("A") maupun check("B") tidak pernah dijalankan. Itulah short-circuit. Ini bukan sekadar optimasi, tapi juga alat. Kamu bisa menulis if (ptr != nullptr && ptr->ready) dengan aman karena bagian ptr->ready hanya dicapai saat ptr tidak null, sehingga kamu terhindar dari dereferensi pointer yang menggantung.

Increment dan decrement

++ menambah satu; -- mengurangi satu. Masing-masing punya bentuk prefix dan postfix, dan perbedaannya penting saat kamu memakai hasilnya:

#include <iostream>
using namespace std;

int main() {
    int i = 5;
    cout << ++i << "\n";  // increments to 6, then prints 6 (pre)

    int j = 5;
    cout << j++ << "\n";  // prints 5, THEN increments to 6 (post)
    cout << j   << "\n";  // 6

    return 0;
}

Kalau kamu hanya butuh efek sampingnya (misalnya di dalam for loop), pilih ++i. Untuk int biasa hasilnya sama saja, tapi untuk tipe yang lebih berat seperti iterator, post-increment harus menyalin nilai lamanya dulu, dan itu kerja yang sia-sia.

Satu peringatan lagi: jangan mengubah variabel yang sama dua kali dalam satu ekspresi, seperti i = i++ + 1; atau arr[i] = i++;. Urutan perubahan itu tidak ditentukan dan hasilnya adalah undefined behavior. Ubah setiap variabel paling banyak sekali per pernyataan.

Operator bitwise dan prioritas operator

Untuk pekerjaan tingkat rendah ada operator bitwise: & (and), | (or), ^ (xor), ~ (not), serta operator geser << dan >>.

#include <iostream>
using namespace std;

int main() {
    unsigned int flags = 0b0101;   // binary literal: 5

    cout << (flags & 0b0001) << "\n";  // 1  -> bit 0 is set
    cout << (flags | 0b0010) << "\n";  // 7  -> set bit 1
    cout << (flags ^ 0b0101) << "\n";  // 0  -> xor with itself
    cout << (flags << 1)      << "\n"; // 10 -> shift left, doubles it

    return 0;
}

Hati-hati: << dan >> juga merupakan operator stream pada cout. Di dalam baris cout kamu biasanya perlu tanda kurung di sekitar operasi geser bit, kalau tidak compiler akan membacanya sebagai penyisipan ke stream.

Terakhir, prioritas operator (precedence) menentukan mana yang diproses lebih dulu saat kamu mencampur operator. * dan / lebih kuat daripada + dan -, sama seperti di matematika, jadi 2 + 3 * 4 hasilnya 14. Perbandingan lebih lemah daripada aritmatika, dan logika &&/|| lebih lemah lagi. Kalau ragu, jangan menghafal seluruh tabelnya, tambahkan saja tanda kurung. (a + b) * c lebih jelas daripada mengandalkan pembaca mengingat aturannya.

Berikutnya: type casting

Di atas kamu sudah melihat bahwa (double)a / b memaksa sebuah integer masuk ke pembagian floating-point. Itulah cast, yaitu mengubah nilai dari satu tipe ke tipe lain secara sengaja. Di halaman berikutnya kita akan membahas alat konversi di C++, dari promosi implisit sampai static_cast, dan kapan masing-masing aman dipakai.