C++ Operatörleri: Aritmetik, Karşılaştırma, Mantıksal ve Daha Fazlası

Operatörler Ne Yapar

Operatör, operand adı verilen bir veya daha fazla değer üzerinde bir işlem gerçekleştiren bir semboldür. Aslında zaten birini kullanıyordun: bir değeri bir değişkene bağlayan =. C++ matematik, karşılaştırma, mantık ve bit işlemleri için zengin bir operatör seti ile gelir - ve yeni başlayanları tökezleten birkaç keskin köşeyle birlikte.

Önceki sayfada const'un bir değeri nasıl kilitlediğini gördün. Operatörler ise, sabit olsun ya da olmasın, sakladığın değerleri hesapladığın araçlardır. Her gün kullanacağın aileleri tek tek inceleyelim.

Aritmetik Operatörler

Beş aritmetik operatör şunlardır: +, -, *, / ve % (mod, bir bölmenin kalanı):

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

Büyük tuzak işte o bölümde yaşıyor. 17 / 5, 3.4 değil 3 yazdırır. Her iki operand da tam sayı olduğunda, / tam sayı bölmesi yapar ve kesirli kısmı atar - sıfıra doğru kırpar, yuvarlamaz. Gerçek bir kesir istiyorsan en az bir operand kayan noktalı olmalıdır:

#include <iostream>
using namespace std;

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

    cout << a / b << "\n";          // 3  -> tam sayı bölmesi
    cout << 17.0 / 5 << "\n";       // 3.4 -> 17.0 bir double'dır
    cout << (double)a / b << "\n";  // 3.4 -> önce bir operandı dönüştür

    return 0;
}

% operatörü yalnızca tam sayılarla çalışır. Bir double üzerinde % kullanmak derleme hatasıdır - kayan noktalı kalanlar için <cmath> içindeki std::fmod kullan.

Atama ve Bileşik Operatörler

Tek bir = atama yapar; karşılaştırma yapmaz. C++ sana, değişken adını tekrarlamamak için bir işlemi atama ile birleştiren bileşik biçimler sunar:

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

Klasik ve can sıkıcı bir hata, bir koşulun içinde == demek isterken = yazmaktır. if (x = 0), karşılaştırma yapmak yerine x'e 0 atar ve ardından sonucu (yanlış olan) test eder. Modern derleyiciler uyarıları açtığında bu konuda seni uyarır - -Wall'ı açık tut ve uyarıyı ciddiye al.

Karşılaştırma Operatörleri

Karşılaştırma operatörleri evet/hayır sorusu sorar ve bir bool (true veya false) üretir:

#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;          // 1/0 yerine true/false yazdır
    cout << (x < y) << "\n";    // true
    return 0;
}

Varsayılan olarak cout bir bool değerini 1 veya 0 olarak yazdırır. boolalpha'yı bir kez akışa ekle, o akışın geri kalanında true/false sözcüklerine geçer.

İnce bir tuzak: 1 < x < 10 gibi karşılaştırmaları zincirleme. Bu, (1 < x) < 10 olarak ayrıştırılır - ilk karşılaştırma bir bool (0 veya 1) üretir, ardından bu 10 ile karşılaştırılır, dolayısıyla tüm ifade neredeyse her zaman true olur. Bunun yerine 1 < x && x < 10 yaz.

Mantıksal Operatörler ve Kısa Devre

&& (ve), || (veya) ve ! (değil) mantıksal ifadeleri birleştirir. İlk ikisi kısa devre yapar: sonuç belli olur olmaz değerlendirme durur.

#include <iostream>
using namespace std;

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

int main() {
    // && operatörünün sağ tarafı atlanır çünkü sol taraf false:
    if (false && check("A")) {}

    // || operatörünün sağ tarafı atlanır çünkü sol taraf true:
    if (true || check("B")) {}

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

Ne check("A") ne de check("B") hiçbir zaman çalışır - işte bu kısa devredir. Bu yalnızca bir optimizasyon değil; bir araçtır. if (ptr != nullptr && ptr->ready) ifadesini güvenle yazabilirsin çünkü ptr->ready kısmına yalnızca ptr boş değilken ulaşılır, böylece sallantıdaki bir işaretçiye erişim önlenir.

Artırma ve Azaltma

++ bir ekler; -- bir çıkarır. Her birinin bir ön ek ve bir son ek biçimi vardır ve sonucu kullandığında fark önem kazanır:

#include <iostream>
using namespace std;

int main() {
    int i = 5;
    cout << ++i << "\n";  // 6'ya artırır, sonra 6 yazdırır (ön)

    int j = 5;
    cout << j++ << "\n";  // 5 yazdırır, SONRA 6'ya artırır (son)
    cout << j   << "\n";  // 6

    return 0;
}

Yalnızca yan etkiyi istediğinde (örneğin bir for döngüsünde) ++i'yi tercih et. Düz bir int için aynıdır, ama yineleyiciler gibi daha ağır türlerde son artırma önce eski değeri kopyalamak zorundadır ki bu boşa harcanan bir iştir.

Bir uyarı daha: aynı değişkeni tek bir ifade içinde iki kez değiştirme, örneğin i = i++ + 1; veya arr[i] = i++;. Bu güncellemelerin sırası belirsizdir ve sonuç tanımsız davranıştır. Her değişkeni ifade başına tek bir değişiklikle sınırla.

Bit Düzeyi Operatörler ve Öncelik

Düşük seviyeli işler için bit düzeyi operatörler vardır: & (ve), | (veya), ^ (xor), ~ (değil) ve kaydırma operatörleri << ile >>.

#include <iostream>
using namespace std;

int main() {
    unsigned int flags = 0b0101;   // ikili sabit: 5

    cout << (flags & 0b0001) << "\n";  // 1  -> bit 0 ayarlı
    cout << (flags | 0b0010) << "\n";  // 7  -> bit 1'i ayarla
    cout << (flags ^ 0b0101) << "\n";  // 0  -> kendisiyle xor
    cout << (flags << 1)      << "\n"; // 10 -> sola kaydırır, değeri ikiye katlar

    return 0;
}

Dikkat: << ve >> aynı zamanda cout üzerindeki akış operatörleridir. Bir cout satırının içinde, bir bit kaydırması etrafında genellikle parantez gerekir, aksi takdirde derleyici bunu bir akışa ekleme olarak okur.

Son olarak, öncelik, operatörleri karıştırdığında neyin önce bağlanacağına karar verir. Tıpkı matematikteki gibi * ve /, + ve -'den daha sıkı bağlanır, bu yüzden 2 + 3 * 4, 14'tür. Karşılaştırma aritmetikten daha gevşek, mantıksal &&/|| ise daha da gevşek bağlanır. Tereddütteysen tüm tabloyu ezberleme - parantez ekle. (a + b) * c, okuyucunun kuralları hatırlamasına güvenmekten daha açıktır.

Sıradaki: Tür Dönüştürme

Yukarıda (double)a / b ifadesinin bir tam sayıyı kayan noktalı bir bölmeye zorladığını gördün. İşte bu bir dönüştürmedir (cast) - bir değeri kasıtlı olarak bir türden başka bir türe çevirmek. Sonraki sayfada, örtük yükseltmelerden static_cast'e kadar C++'ın dönüştürme araçlarını ve her birinin ne zaman güvenli olduğunu ele alacağız.