Sınıflar ve nesneler — C++

Bu derste öğreneceklerin

Sınıf ve nesne kavramlarını açıklamak
Üye değişkenleri ve metotları olan bir sınıf yazmak
Başlatma listeli yapıcılar ve bir yıkıcı yazmak
public ve private ile verileri korumak

Bir oyunda yüzlerce karakter vardır: her birinin adı, canı ve seviyesi vardır, her biri hareket edebilir ve saldırabilir. Bunların hepsini ayrı değişkenlerde ve fonksiyonlarda tutmak kısa sürede karmaşaya dönüşür. C++ kendi türünü oluşturmana izin verir: sınıf (class). Sınıf, verileri ve onlarla çalışan fonksiyonları bir araya getirir.

Sınıf ve nesne

Tanım

Sınıf ve nesne

Sınıf, yeni bir türün planıdır: nesnelerde hangi verilerin (üye değişkenlerin) ve hangi fonksiyonların (metotların) olacağını tanımlar. Nesne ise o sınıftan oluşturulmuş somut bir örnektir; tıpkı int x; yazdığında x'in int türünde bir değişken olması gibi.

C++

#include <iostream>
#include <string>

class Student {
public:
    std::string name;
    int grade = 0;

    void introduce() const {
        std::cout << name << " is in grade " << grade << '\n';
    }
};

int main() {
    Student a;
    a.name = "Aysel";
    a.grade = 8;

    Student m;
    m.name = "Murad";
    m.grade = 9;

    a.introduce();
    m.introduce();
    return 0;
}

Beklenen çıktı

Aysel is in grade 8
Murad is in grade 9

Üyelere nokta ile erişilir: a.name, a.introduce().
Her nesnenin kendi verileri vardır: a ve m aynı sınıftandır ama adları ve sınıfları farklıdır.
Metodun sonundaki const, metodun nesneyi değiştirmediğini belirtir; derleyici bunu denetler.

Yapıcılar ve yıkıcı

Yapıcı (constructor), nesne oluşturulurken otomatik olarak çağrılan özel bir metottur. Adı sınıfın adıyla aynıdır ve dönüş türü yoktur. Yapıcılar da sıradan fonksiyonlar gibi aşırı yüklenebilir. Üyelere değer vermenin en iyi yolu başlatma listesidir: iki noktadan sonra, gövdeden önce: : width_(w), height_(h).

C++

#include <iostream>

class Rectangle {
public:
    Rectangle() : width_(1), height_(1) {}
    Rectangle(int w, int h) : width_(w), height_(h) {}

    int area() const { return width_ * height_; }
    int perimeter() const { return 2 * (width_ + height_); }

private:
    int width_;
    int height_;
};

int main() {
    Rectangle tile;
    Rectangle room(4, 3);
    std::cout << "Tile area: " << tile.area() << '\n';
    std::cout << "Room area: " << room.area() << '\n';
    std::cout << "Room perimeter: " << room.perimeter() << '\n';
    return 0;
}

Beklenen çıktı

Tile area: 1
Room area: 12
Room perimeter: 14

Yıkıcı (destructor), nesne yok edildiğinde çağrılır: adı ~ işaretiyle başlar (~Logger). Yerel bir nesne kapsamından, yani kendi süslü parantezlerinden çıkınca yok edilir. Önceki dersteki RAII ilkesi tam olarak buna dayanır: kaynak yapıcıda alınır, yıkıcıda geri verilir.

C++

#include <iostream>
#include <string>

class Logger {
public:
    Logger(const std::string& name) : name_(name) {
        std::cout << "Start " << name_ << '\n';
    }
    ~Logger() {
        std::cout << "End " << name_ << '\n';
    }

private:
    std::string name_;
};

int main() {
    Logger a("A");
    {
        Logger b("B");
    }
    std::cout << "Main done\n";
    return 0;
}

Beklenen çıktı

Start A
Start B
End B
Main done
End A

b iç blok bitince, a ise main bitince yok edilir.

public, private ve kapsülleme

Bir banka hesabının bakiyesini her kod doğrudan değiştirebilseydi, biri yanlışlıkla ona negatif bir değer yazabilirdi. Kapsülleme, verileri gizler ve onlara yalnızca denetim yapan metotlar üzerinden erişime izin verir. Bunun için erişim belirleyicileri vardır: public üyeler her yerden görünür, private üyeler ise yalnızca sınıfın kendi metotlarından.

C++

#include <iostream>

class BankAccount {
public:
    BankAccount(int balance) : balance_(balance) {}

    void deposit(int amount) {
        if (amount > 0) {
            balance_ += amount;
        }
    }
    bool withdraw(int amount) {
        if (amount <= 0 || amount > balance_) {
            return false;
        }
        balance_ -= amount;
        return true;
    }
    int balance() const { return balance_; }

private:
    int balance_;
};

int main() {
    BankAccount acc(100);
    acc.deposit(50);
    std::cout << std::boolalpha << acc.withdraw(500) << '\n';
    std::cout << acc.withdraw(30) << '\n';
    std::cout << "Balance: " << acc.balance() << " AZN\n";
    // acc.balance_ = 1000000;  // error: balance_ is private
    return 0;
}

Beklenen çıktı

false
true
Balance: 120 AZN

150 manattan 500 çekmek başarısız oldu, 30 ise çekildi: 150 − 30 = 120.

Belirleyici	Kim erişebilir
`public`	her kod
`private`	yalnızca sınıfın kendi metotları
`protected`	sınıfın kendi metotları ve türetilmiş sınıflar (sonraki ders)

Önemli noktalar

Sınıf yeni bir türün planıdır, nesne ise onun somut bir örneğidir.
Üyelere nokta ile erişilir; const metot nesneyi değiştirmez.
Yapıcı nesne oluşturulurken, yıkıcı (~Ad) ise nesne yok edilirken otomatik olarak çağrılır.
Üyelere değer vermenin en iyi yeri başlatma listesidir.
private verileri gizler, public metotlar ise onlara denetimli erişim sağlar; buna kapsülleme denir.

Kendini test et

10 soru. Her doğru cevap XP kazandırır.

1 / 10

Sınıf ile nesne arasındaki fark nedir?