C++ Operatör Aşırı Yükleme: Özel +, == ve << Operat…

Q: C++'ta operatör aşırı yükleme nedir?

Operatör aşırı yükleme, +, == veya << gibi yerleşik operatörlerin kendi türleriniz için ne anlama geldiğini tanımlamanıza olanak tanır. Özel adlı bir fonksiyon yazarsınız - operator+, operator== vb. - ve operatör sizin sınıfınızın işlenenleriyle göründüğünde derleyici bunu çağırır. string + string ifadesinin birleştirme yapması ve cout << obj ifadesinin özel bir nesneyi yazdırması bu sayededir.

Q: C++'ta operatörler üye fonksiyon mu yoksa üye olmayan (friend) fonksiyon mu olmalı?

Sol işlenen kendi sınıfınız olduğunda ve dönüşüm gerekmediğinde bir üye fonksiyon kullanın (ör. +=, [], ()). Sol işlenen yerleşik bir tür olabildiğinde veya her iki tarafta da simetrik dönüşümler istediğinizde bir üye olmayan fonksiyon (genellikle friend) kullanın; operator<< için bu zorunludur, çünkü sol işlenen sizin sınıfınız değil bir std::ostream'dir.

Q: Hangi C++ operatörleri aşırı yüklenemez?

:: (kapsam çözümleme), . (üye erişimi), .* (üye işaretçisi erişimi), ?: (üçlü) ve sizeof operatörlerini aşırı yükleyemezsiniz. Ayrıca tamamen yeni operatörler icat edemez veya bir operatörün işlenen sayısını ya da önceliğini değiştiremezsiniz - + ister int toplasın ister sizin Vector2 türünüzü, her zaman aynı öncelikli ikili bir operatördür.

Türlerinizi Yerleşik Gibi Hissettirin

std::string türünün birleştirme için a + b ve yazdırma için cout << s yazmanıza izin verdiğini zaten biliyorsunuz. Bunlar özel derleyici hileleri değildir - tuhaf adlara sahip sıradan fonksiyonlardır. Operatör aşırı yükleme, sizin sınıflarınızın aynı söz dizimine bağlanmasını sağlayan özelliktir; böylece bir Vector2 veya Money türü tam olarak bir int gibi toplanabilir, karşılaştırılabilir ve yazdırılabilir.

Mekanizma bir kez gördüğünüzde basittir: a + b gibi bir ifade bir kısaltmadır. Derleyici bunu operator+ adlı bir fonksiyona yapılan çağrı olarak yeniden yazar ve işlenen türleriyle eşleşen birini arar. Bu fonksiyonu sınıfınız için tanımlayın ve a + b aniden çalışmaya başlar. Bu aslında özelleşmiş bir fonksiyon aşırı yükleme biçimidir - oradaki aynı ad çözümleme kuralları geçerlidir, sadece operatör biçimli adlarla.

#include <iostream>
using namespace std;

struct Vector2 {
    double x, y;
};

// a + b, operator+(a, b) haline gelir
Vector2 operator+(const Vector2& a, const Vector2& b) {
    return Vector2{a.x + b.x, a.y + b.y};
}

int main() {
    Vector2 p{1, 2};
    Vector2 q{3, 4};
    Vector2 r = p + q;          // operator+ çağrılır
    cout << r.x << ", " << r.y << "\n";  // 4, 6
}

Fonksiyonun her iki işleneni de const& ile aldığına dikkat edin: aritmetik, girdilerini değiştirmemelidir ve referanslar kopyalamayı önler. Yeni bir Vector2 değer olarak döndürür - p + q, tıpkı 2 + 3'ün 2'yi değiştirmemesi gibi, p veya q'ya dokunmadan taze bir sonuç üretmelidir.

Üye vs Üye Olmayan

Bir operatörü tanımlayabileceğiniz iki yer vardır: sınıfın bir üyesi olarak veya serbest (üye olmayan) fonksiyon olarak. Üye olarak, sol işlenen örtük this'tir, dolayısıyla ikili bir operatör yalnızca bir açık parametre alır:

#include <iostream>
using namespace std;

class Money {
    long cents;
public:
    Money(long c) : cents(c) {}

    // üye: sol işlenen *this, sağ işlenen parametredir
    Money operator+(const Money& other) const {
        return Money(cents + other.cents);
    }

    long value() const { return cents; }
};

int main() {
    Money a(150), b(99);
    Money total = a + b;        // a.operator+(b)
    cout << total.value() << "\n";  // 249
}

Parametre listesinden sonraki const önemlidir: a + b, a'yı değiştirmemelidir, bu yüzden üye const olarak işaretlenir. Doğası gereği sol işlenene bağlı olan ve onun üzerinde dönüşüme ihtiyaç duymayan operatörler için üye biçimini kullanın - +=, [], (), -> ve -x veya ++x gibi tekli operatörler.

Üyelerdeki sorun: sol işlenen dönüştürülemez. Yukarıdaki üye operator+ ile a + 50 çalışır (50, sağ taraf için Money'ye dönüşür), ancak 50 + a derlenemez - sol işlenen 50 bir int'tir ve int'e bir üye fonksiyon ekleyemezsiniz. Üye olmayan bir operatör bunu düzeltir, çünkü işlenenlerin ikisi de açık parametredir ve ikisi de dönüştürülebilir:

#include <iostream>
using namespace std;

class Money {
    long cents;
public:
    Money(long c) : cents(c) {}
    long value() const { return cents; }
    // serbest fonksiyona özel alana erişim ver
    friend Money operator+(const Money& a, const Money& b);
};

Money operator+(const Money& a, const Money& b) {
    return Money(a.cents + b.cents);
}

int main() {
    Money a(150);
    Money total = 50 + a;       // 50, Money(50)'ye dönüşür; artık simetrik
    cout << total.value() << "\n";  // 200
}

Pratik kural: simetrik ikili operatörleri (+, ==, *) üye olmayan yapın ki dönüşümler her iki tarafta da çalışsın; sol işleneni değiştirmesi gereken veya ona bağlı olan operatörleri (+=, [], =) üye yapın.

Akış Operatörünü Aşırı Yükleme

Açık ara en sık aşırı yüklenen operatör, yazdırma için kullanılan <<'dir. Bunu sınıfınızın bir üyesi yapamazsınız, çünkü sol işlenen sizin türünüz değil bir std::ostream'dir (cout gibi) ve ostream'in sahibi siz değilsiniz. Bu yüzden o her zaman, akışı sabit olmayan referansla alıp geri döndüren üye olmayan bir fonksiyondur:

#include <iostream>
using namespace std;

struct Point {
    int x, y;
};

// sol işlenen akıştır; çağrıların zincirlenebilmesi için onu geri döndür
ostream& operator<<(ostream& os, const Point& p) {
    os << "(" << p.x << ", " << p.y << ")";
    return os;
}

int main() {
    Point p{3, 7};
    cout << "p = " << p << "\n";   // p = (3, 7)
}

Bunu işe yarar kılan iki ayrıntı vardır. Akış referansla (ostream&) geçirilir ve döndürülür - akışlar kopyalanamaz ve aynı akışı döndürmek, cout << "p = " << p << "\n" ifadesini zincirlemenizi sağlayan şeydir. Her <<, bir sonraki <<'in bağlanacağı bir şeyi olsun diye akışı döndürür. return os; ifadesini unutursanız zincirleme bozulur.

Karşılaştırma Operatörleri

Nesnelerinizi ==, < ve benzerleriyle karşılaştırmak için karşılaştırma operatörlerini aşırı yükleyin. C++20'den önce her birini elle yazardınız; ana tuzak, operator<'in bir bool döndürmesi ve tutarlı bir sıralama tanımlaması gerektiğidir:

#include <iostream>
using namespace std;

struct Version {
    int major, minor;
};

bool operator==(const Version& a, const Version& b) {
    return a.major == b.major && a.minor == b.minor;
}

bool operator<(const Version& a, const Version& b) {
    if (a.major != b.major) return a.major < b.major;
    return a.minor < b.minor;        // minor üzerinden eşitlik bozma
}

int main() {
    Version v1{1, 4}, v2{1, 9};
    cout << (v1 == v2) << "\n";   // 0
    cout << (v1 < v2) << "\n";    // 1
}

Altı karşılaştırmanın (==, !=, <, <=, >, >=) tümünü elle yazmak sıkıcı ve hataya açıktır. C++20, üç yönlü karşılaştırma operatörü <=>'i ("uzay gemisi") ekledi. Bunu == ile birlikte varsayılana ayarlamak, tüm karşılaştırmaları sizin için üretir:

#include <compare>
#include <iostream>
using namespace std;

struct Version {
    int major, minor;
    auto operator<=>(const Version&) const = default;
    bool operator==(const Version&) const = default;
};

int main() {
    Version v1{1, 4}, v2{1, 9};
    cout << (v1 < v2)  << "\n";   // 1
    cout << (v1 >= v2) << "\n";   // 0
}

= default, derleyiciye üyeleri bildirim sırasına göre karşılaştırmasını söyler ki bu da tam olarak elle yazacağınız sözlüksel sıralamadır. Modern derleyicilerde bunu tercih edin.

Atama Operatörü ve Tuzakları

operator= (kopya atama) özeldir: derleyici sizin için bir tane üretir ve basit sınıflar için bu varsayılan doğrudur. Yalnızca sınıfınız bir kaynağı - ham bellek, bir dosya tutamacı - yönettiğinde ve üye üye kopyalamanın yanlış olacağı durumda kendinizinkini yazmanız gerekir. Standart imza, atamaların zincirlenebilmesi için (a = b = c) *this'i referansla döndürür:

#include <iostream>
using namespace std;

class Buffer {
    int* data;
    int size;
public:
    Buffer(int n) : data(new int[n]), size(n) {}
    ~Buffer() { delete[] data; }

    Buffer& operator=(const Buffer& other) {
        if (this == &other) return *this;   // kendine atamaya karşı koru
        delete[] data;                      // elimizde olanı serbest bırak
        size = other.size;
        data = new int[size];               // yeni bellek ayır
        for (int i = 0; i < size; ++i) data[i] = other.data[i];
        return *this;                       // a = b = c'yi mümkün kılar
    }
    int length() const { return size; }
};

int main() {
    Buffer a(3), b(5);
    a = b;
    cout << a.length() << "\n";   // 5
}

Bu kısa fonksiyonda iki tuzak yaşar. Birincisi, kendine atama kontrolü if (this == &other): o olmadan a = a, delete[] data yapar ve ardından az önce serbest bırakılan other.data'dan okur - tanımsız davranış. İkincisi, sıra önemlidir - elle yazılmış bir sürümde, yenisini güvenle kopyalamadan önce eski tamponu silmemelisiniz (gerçek bir uygulama genellikle önce bellek ayırır veya copy-and-swap deyimini kullanır, böylece başarısız bir bellek ayırma nesneyi bozulmamış bırakır).

Daha geniş bir tuzak: operatörleri şaşırtıcı şekillerde aşırı yüklemeyin. Sol işlenenini gizlice değiştiren bir operator+ veya simetrik olmayan bir operator==, her okuyucunun kafasını karıştırır ve olağan anlamları varsayan standart kütüphane kodunu bozar. Operatörleri yalnızca işlem, türünüz için gerçekten "toplama benzeri" veya "eşitlik benzeri" olduğunda aşırı yükleyin.

Sıradaki: Erişim Belirteçleri

Her örneğin veri üyelerini private tutup davranışı küçük bir genel yüzey - yapıcılar, operatörler ve birkaç metot - aracılığıyla nasıl açığa çıkardığına dikkat edin. Dış dünyaya görünür olan ile sınıfın içinde gizli kalan arasındaki bu sınır, erişim belirteçleri ile denetlenir: public, private ve protected. Sırada her birinin tam olarak neye izin verdiğine, genel metotlu private verinin neden iyi kapsülleme için varsayılan olduğuna ve protected'in kalıtıma nasıl uyduğuna bakacağız.

Sıkça Sorulan Sorular

C++'ta operatör aşırı yükleme nedir?

Operatör aşırı yükleme, +, == veya << gibi yerleşik operatörlerin kendi türleriniz için ne anlama geldiğini tanımlamanıza olanak tanır. Özel adlı bir fonksiyon yazarsınız - operator+, operator== vb. - ve operatör sizin sınıfınızın işlenenleriyle göründüğünde derleyici bunu çağırır. string + string ifadesinin birleştirme yapması ve cout << obj ifadesinin özel bir nesneyi yazdırması bu sayededir.

C++'ta operatörler üye fonksiyon mu yoksa üye olmayan (friend) fonksiyon mu olmalı?

Sol işlenen kendi sınıfınız olduğunda ve dönüşüm gerekmediğinde bir üye fonksiyon kullanın (ör. +=, [], ()). Sol işlenen yerleşik bir tür olabildiğinde veya her iki tarafta da simetrik dönüşümler istediğinizde bir üye olmayan fonksiyon (genellikle friend) kullanın; operator<< için bu zorunludur, çünkü sol işlenen sizin sınıfınız değil bir std::ostream'dir.

Hangi C++ operatörleri aşırı yüklenemez?

:: (kapsam çözümleme), . (üye erişimi), .* (üye işaretçisi erişimi), ?: (üçlü) ve sizeof operatörlerini aşırı yükleyemezsiniz. Ayrıca tamamen yeni operatörler icat edemez veya bir operatörün işlenen sayısını ya da önceliğini değiştiremezsiniz - + ister int toplasın ister sizin Vector2 türünüzü, her zaman aynı öncelikli ikili bir operatördür.

İlgili kavramlar