C++ Sanal Fonksiyonlar: Polimorfizm Açıklaması

Neden Tek Başına Kalıtım Yeterli Değil

Önceki sayfada bir sınıf hiyerarşisi oluşturmuştunuz: türetilmiş bir sınıf, temelinden üyeleri devralır. Ama bir püf nokta var. Bir metodu bir temel sınıf işaretçisi üzerinden çağırdığınızda, C++ hangi fonksiyonu çalıştıracağına nesnenin gerçek tipine değil, işaretçinin tipine göre karar verir. Yani aslında bir Dog'a işaret eden bir Animal* yine de Animal'ın metot sürümünü çağırır.

Bu neredeyse hiçbir zaman istediğiniz şey değildir. Çoğu zaman, her biri farklı bir türetilmiş nesneye işaret eden bir temel sınıf işaretçisi koleksiyonunuz olur ve her birinin kendisi gibi davranmasını istersiniz. Sanal fonksiyonlar bunu gerçekleştirir.

#include <iostream>
using namespace std;

struct Animal {
    void speak() { cout << "...\n"; }   // sanal DEĞİL
};

struct Dog : Animal {
    void speak() { cout << "Woof\n"; }
};

int main() {
    Animal* a = new Dog();
    a->speak();   // "..." yazdırır - Woof değil, Animal sürümü!
    delete a;
    return 0;
}

Nesne gerçekten bir Dog, ancak yine de a->speak() ifadesi Animal::speak()'i çalıştırdı. speak sanal olmadığı için derleyici fonksiyonu derleme zamanında statik Animal* tipinden seçti. Sanal fonksiyonların var olma nedeni tam da bu hatadır.

Bir Fonksiyonu Sanal Yapmak

Temel sınıf metoduna virtual anahtar kelimesini ekleyin. Artık çağrı, nesnenin gerçek tipine göre çalışma zamanında çözümlenir - işte bu dinamik gönderim.

#include <iostream>
using namespace std;

struct Animal {
    virtual void speak() { cout << "...\n"; }
};

struct Dog : Animal {
    void speak() override { cout << "Woof\n"; }
};

struct Cat : Animal {
    void speak() override { cout << "Meow\n"; }
};

int main() {
    Animal* pets[] = { new Dog(), new Cat(), new Animal() };

    for (Animal* p : pets) {
        p->speak();   // her biri kendi sürümünü çalıştırır
    }
    // Woof / Meow / ...

    for (Animal* p : pets) delete p;
    return 0;
}

Animal* üzerinde tek bir döngü, üç farklı davranış. Temel işaretçi çalışma zamanında gerçek tipi "bilir" ve buna göre gönderim yapar. Bu tek mekanizma - tek arayüz, çok sayıda uygulama - C++'ta polimorfizmin anlamıdır.

virtual'ın yalnızca temel bildirimde görünmesi gerektiğini unutmayın; bir fonksiyon sanal olduktan sonra, her türetilmiş sınıfta otomatik olarak sanal kalır. Onu türetilmiş sınıfta tekrar yazmak isteğe bağlı ve gereksizdir.

Her Zaman override Anahtar Kelimesini Kullanın

Yukarıdaki örnekte her türetilmiş metot override ile işaretlenmiştir. Kodun çalışması için isteğe bağlıdır, ancak onu zorunlu olarak ele almalısınız. override (C++11), derleyiciden gerçekten eşleşen bir imzayla bir temel sanal fonksiyonu geçersiz kıldığınızı doğrulamasını ister. İmzayı incelikle yanlış yaparsanız, sessiz bir hata yerine net bir hata alırsınız.

struct Animal {
    virtual void speak() const { }   // not: const
};

struct Dog : Animal {
    void speak() { }            // const DEĞİL - bu YENİ bir fonksiyon, geçersiz kılma değil!
    void speak() override { }   // hata: 'speak' geçersiz kılmıyor - size hemen söyler
};

override olmadan ilk speak() sorunsuz derlenir ama bir Animal* üzerinden asla çağrılmaz, çünkü imzası temelden farklıdır (const eksik). Geçersiz kılmanızın neden hiçbir şey yapmadığını merak ederek bir öğleden sonranızı harcardınız. override ile derleyici uyumsuzluğu anında yakalar. Onu geçersiz kılan her fonksiyona ekleyin.

Saf Sanal Fonksiyonlar ve Soyut Sınıflar

Bazen temel sınıfın mantıklı bir varsayılanı yoktur - genel bir "Animal" ne ses çıkarır? Bu durumda, fonksiyona = 0 atayarak onu saf sanal olarak tanımlayın. Bu, onu gövdesiz bırakır ve sınıfı tek başına örneği oluşturulamayan bir soyut sınıfa dönüştürür. Yalnızca türetilmiş sınıfların yerine getirmesi gereken bir arayüz tanımlamak için vardır.

#include <iostream>
using namespace std;

struct Shape {
    virtual double area() const = 0;   // saf sanal: gövdesiz, geçersiz kılınmalı
    virtual ~Shape() = default;        // sanal yıkıcı (sonraki bölüme bakın)
};

struct Circle : Shape {
    double r;
    Circle(double radius) : r(radius) {}
    double area() const override { return 3.14159 * r * r; }
};

struct Rectangle : Shape {
    double w, h;
    Rectangle(double width, double height) : w(width), h(height) {}
    double area() const override { return w * h; }
};

int main() {
    // Shape s;   // hata: soyut sınıfın örneği oluşturulamaz
    Shape* shapes[] = { new Circle(2.0), new Rectangle(3.0, 4.0) };

    for (Shape* s : shapes) {
        cout << "area = " << s->area() << "\n";
    }
    // area = 12.5664 / area = 12

    for (Shape* s : shapes) delete s;
    return 0;
}

Her somut alt sınıf area()'yı uygulamak zorundadır, aksi takdirde o da soyut kalır. C++ "arayüzleri" böyle ifade eder: yalnızca saf sanal fonksiyonlara sahip bir soyut sınıf, Java gibi dillerdeki bir arayüzün C++ karşılığıdır.

Sanal Yıkıcı Kuralı

Bu, herkesi en az bir kez tuzağa düşüren püf noktadır. Bir nesneyi bir temel sınıf işaretçisi üzerinden delete ettiğinizde, C++ bulduğu yıkıcıyı çağırır - ve o yıkıcı sanal değilse, yalnızca temel yıkıcıyı çalıştırır. Türetilmiş kısım asla yok edilmez ve sahip olduğu her şeyi sızdırır. Standart buna tanımsız davranış der.

#include <iostream>
using namespace std;

struct Base {
    ~Base() { cout << "~Base\n"; }   // sanal DEĞİL - hata!
};

struct Derived : Base {
    ~Derived() { cout << "~Derived\n"; }
};

int main() {
    Base* p = new Derived();
    delete p;   // yalnızca "~Base" yazdırır - ~Derived asla çalışmaz!
    return 0;
}

Çözüm tek kelime: temel yıkıcıyı virtual yapın. O zaman delete p önce ~Derived'i, sonra ~Base'i çalıştırır, tam olması gerektiği gibi.

struct Base {
    virtual ~Base() { cout << "~Base\n"; }   // doğru
};
// şimdi: önce ~Derived sonra ~Base

Temel kural: Bir sınıfın herhangi bir sanal fonksiyonu olduğu an, ona bir de sanal yıkıcı verin. Bir sınıf, işaretçiler üzerinden kullanılan bir temel sınıf olarak tasarlandıysa, yıkıcısı sanal olmalıdır.

Sık Yapılan Hatalar ve Tuzaklar

Sanal fonksiyonlarla rahatladığınızda dikkat etmeniz gereken birkaç tuzak daha:

Nesne dilimleme (object slicing). Türetilmiş bir nesneyi bir temel değişkene değerle aktarır veya saklarsanız, türetilmiş kısım "dilimlenir" ve elinizde sade bir temel nesne kalır - sanal gönderim artık geçersiz kılmaya ulaşamaz. Polimorfizm için her zaman işaretçi veya referans kullanın:

Dog d;
Animal a = d;   // DİLİMLENDİ: a artık sadece bir Animal, Dog kısmı gitti
a.speak();      // sanal olmasına rağmen Animal::speak çalıştırır

Animal& ref = d;   // OK: referans gerçek tipi korur
ref.speak();       // Dog::speak çalıştırır

Yapıcılardan veya yıkıcılardan sanal fonksiyon çağırmayın. Yapım sırasında türetilmiş kısım henüz yoktur, bu nedenle sanal bir çağrı türetilmiş geçersiz kılmaya değil, mevcut sınıfın sürümüne çözümlenir - bu nadiren amaçladığınız şeydir.

Sanal gönderimin küçük bir maliyeti vardır. Her sanal çağrı, gizli bir fonksiyon işaretçileri tablosundan ("vtable") geçer, çağrı başına bir dolaylama. Ucuzdur ama bedava değildir, bu yüzden gerçekten geçersiz kılmaya ihtiyacınız olmadıkça bir fonksiyonu sanal yapmayın.

Temel sürümü bilerek çağırmak. Bir geçersiz kılma içinde temel uygulamayı Base::method() ile açıkça çağırmaya devam edebilirsiniz - türetilmiş davranış temeli değiştirmek yerine genişlettiğinde kullanışlıdır.

Sıradaki: Operatör Aşırı Yükleme

Sanal fonksiyonlar, nesnelerinizin paylaşılan bir arayüz üzerinden davranışlarını özelleştirmesini sağlar. Sonraki sayfa, nesnelerinize etki eden operatörleri nasıl özelleştireceğinizi gösterir: operatör aşırı yükleme ile kendi tiplerinize +, ==, << ve daha fazlasına yanıt vermeyi öğretebilirsiniz; böylece Vector + Vector veya cout << myObject ifadeleri yerleşik tiplerdeki kadar doğal okunur.