C++ Object-Oriented Programming (OOP)

C++ dilinin en güçlü yönlerinden biri Nesne Yönelimli Programlama (Object-Oriented Programming - OOP) desteğidir. Bu yaklaşım, yazılımı daha modüler, bakımı kolay ve yeniden kullanılabilir hale getirir.

🧱 1. Nesne Yönelimli Programlamanın Temel Kavramları

Kavram	Açıklama
Class (Sınıf)	Nesnelerin şablonudur. Veri ve fonksiyonları bir arada tutar.
Object (Nesne)	Sınıftan oluşturulan örnektir. Bellekte yer kaplar.
Encapsulation (Kapsülleme)	Verilerin ve fonksiyonların sınıf içinde saklanması.
Inheritance (Kalıtım)	Bir sınıfın başka bir sınıftan türemesi.
Polymorphism (Çok Biçimlilik)	Aynı isimde farklı iş yapan fonksiyonlar.
Abstraction (Soyutlama)	Gereksiz detaylardan soyutlama. Sadece gerekli olanı gösterme.

🔹 2. Sınıf (Class) ve Nesne (Object)

🧪 Örnek: Basit bir sınıf

#include <iostream>
using namespace std;

// Sınıf tanımı
class Araba {
public:
    string marka;
    int hiz;

    void bilgileriGoster() {
        cout << "Marka: " << marka << ", Hız: " << hiz << " km/s" << endl;
    }
};

int main() {
    // Nesne oluşturma
    Araba araba1;
    araba1.marka = "Toyota";
    araba1.hiz = 120;
    araba1.bilgileriGoster();

    return 0;
}

📌 Çıktı:

Marka: Toyota, Hız: 120 km/s

🔒 3. Erişim Belirleyiciler (Access Specifiers)

Tür	Açıklama
`public`	Her yerden erişilebilir
`private`	Sadece sınıf içinden erişilebilir
`protected`	Sınıf içinden ve türeyen sınıflardan erişilebilir

🧪 Örnek:

class Ogrenci {
private:
    int yas;

public:
    void setYas(int y) {
        if (y > 0)
            yas = y;
    }

    int getYas() {
        return yas;
    }
};

🧱 4. Yapıcı (Constructor) ve Yıkıcı (Destructor)

🔹 Constructor: Nesne oluşturulurken otomatik çalışan fonksiyon

🔹 Destructor: Nesne silinirken çalışan fonksiyon

class Kitap {
public:
    string isim;

    // Yapıcı (constructor)
    Kitap(string ad) {
        isim = ad;
        cout << "Kitap oluşturuldu: " << isim << endl;
    }

    // Yıkıcı (destructor)
    ~Kitap() {
        cout << "Kitap silindi: " << isim << endl;
    }
};

int main() {
    Kitap k1("1984");
    return 0;
}

🧬 5. Kalıtım (Inheritance)

Bir sınıf başka bir sınıftan özellik miras alabilir.

class Hayvan {
public:
    void sesCikar() {
        cout << "Hayvan ses çıkardı" << endl;
    }
};

class Kedi : public Hayvan {
public:
    void miyavla() {
        cout << "Miyav!" << endl;
    }
};

int main() {
    Kedi k;
    k.sesCikar(); // Kalıtılan fonksiyon
    k.miyavla();  // Kendi fonksiyonu
    return 0;
}

🧪 6. Çok Biçimlilik (Polymorphism)

Aynı isimli fonksiyonların farklı işlevlere sahip olmasıdır.

📌 Fonksiyon Aşırı Yükleme (Overloading)

class Hesap {
public:
    int topla(int a, int b) {
        return a + b;
    }

    float topla(float a, float b) {
        return a + b;
    }
};

📌 Fonksiyon Ezme (Overriding)

class Sekil {
public:
    virtual void ciz() {
        cout << "Sekil çiziliyor" << endl;
    }
};

class Daire : public Sekil {
public:
    void ciz() override {
        cout << "Daire çiziliyor" << endl;
    }
};

int main() {
    Sekil* s = new Daire();
    s->ciz(); // Daire çiziliyor (override edilmiş)
    delete s;
    return 0;
}

🧱 7. Soyut Sınıflar ve Arayüzler

Soyut sınıflar sadece arayüz sağlar. En az bir pure virtual function içerir.

class Sekil {
public:
    virtual void alan() = 0; // Pure virtual function
};

class Dikdortgen : public Sekil {
public:
    void alan() override {
        cout << "Alan = en * boy" << endl;
    }
};

📌 Özet

Konu	Açıklama
`class`	Nesne tanımı için kullanılır
`object`	class’tan oluşturulan örnek
`constructor` / `destructor`	Otomatik çalışan özel fonksiyonlar
`public`, `private`, `protected`	Erişim belirleyiciler
`inheritance`	Sınıf miras alma
`polymorphism`	Fonksiyonların çok biçimli kullanımı
`virtual`	Override edilebilir fonksiyonlar için kullanılır
`pure virtual`	Soyut fonksiyon, sınıfı da soyut yapar

🎓C++ OOP mini proje :

🎯 Hayvanat Bahçesi Uygulaması

Bu projede şu OOP kavramlarını kullanacağız:

Sınıf (Class)
Kalıtım (Inheritance)
Çok Biçimlilik (Polymorphism)
Sanal Fonksiyonlar (Virtual Functions)

🐾 Proje: Hayvanat Bahçesi

🧩 Senaryo:

Hayvanat bahçesinde çeşitli hayvanlar var. Her hayvanın bir ismi vardır ve farklı bir ses çıkarır. Her hayvan "konuş" fonksiyonuna sahip ama farklı şekilde uygular. Biz bir "Hayvan" sınıfı oluşturup farklı hayvan türlerini ondan türeteceğiz.

✅ Kullandığımız Yapılar:

#include <iostream>
using namespace std;

// Ana sınıf: Hayvan (Soyut sınıf)
class Hayvan {
protected:
    string isim;

public:
    Hayvan(string isim) {
        this->isim = isim;
    }

    virtual void sesCikar() = 0; // Soyut fonksiyon (pure virtual)

    virtual ~Hayvan() {
        cout << isim << " yok oldu." << endl;
    }
};

// Alt sınıf: Kedi
class Kedi : public Hayvan {
public:
    Kedi(string isim) : Hayvan(isim) {}

    void sesCikar() override {
        cout << isim << " miyavlıyor: Miyav miyav!" << endl;
    }
};

// Alt sınıf: Kopek
class Kopek : public Hayvan {
public:
    Kopek(string isim) : Hayvan(isim) {}

    void sesCikar() override {
        cout << isim << " havlıyor: Hav hav!" << endl;
    }
};

// Alt sınıf: Kus
class Kus : public Hayvan {
public:
    Kus(string isim) : Hayvan(isim) {}

    void sesCikar() override {
        cout << isim << " ötüyor: Cik cik!" << endl;
    }
};

// Ana fonksiyon
int main() {
    // Hayvanlar dinamik olarak oluşturuluyor
    Hayvan* hayvanlar[3];

    hayvanlar[0] = new Kedi("Minnak");
    hayvanlar[1] = new Kopek("Karabas");
    hayvanlar[2] = new Kus("Ciko");

    cout << "\nHayvanat Bahçesi Sesleri:\n";
    for (int i = 0; i < 3; i++) {
        hayvanlar[i]->sesCikar();
    }

    // Belleği temizliyoruz
    for (int i = 0; i < 3; i++) {
        delete hayvanlar[i];
    }

    return 0;
}

📌 Örnek Çıktı:

Hayvanat Bahçesi Sesleri:
Minnak miyavlıyor: Miyav miyav!
Karabas havlıyor: Hav hav!
Ciko ötüyor: Cik cik!
Minnak yok oldu.
Karabas yok oldu.
Ciko yok oldu.

🧠 Açıklamalar

✅ Hayvan sınıfı soyut (abstract) çünkü virtual void sesCikar() = 0; tanımlı
✅ Kedi, Kopek, Kus sınıfları bu fonksiyonu kendilerine göre override ediyor
✅ Nesneler Hayvan* olarak tanımlandı ve bu sayede polymorphism (çok biçimlilik) kullanıldı
✅ delete ile her nesne yok edilirken yıkıcı (destructor) çağrıldı

💡 Geliştirme Fikirleri

Projeyi daha da geliştirmen için bazı fikirler:

Hayvanlara yaş, tür veya favori yemeği gibi özellikler ekle
void yemekYe() gibi yeni sanal fonksiyonlar ekle
Kullanıcıdan kaç hayvan gireceğini sorup dinamik liste oluştur

yazın...

traotora