Durum Kalıbı

Coddy'nin C++ Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası — ders 100 / 104.

State deseni, bir nesnenin iç durumu değiştiğinde davranışını değiştirmesine olanak tanıyarak, nesnenin sanki sınıfını değiştirmiş gibi görünmesini sağlar. Farklı durumları yönetmek için karmaşık koşullu ifadeler kullanmak yerine, her bir durumu ayrı bir sınıf olarak kapsüllersiniz.

Desen; mevcut duruma bir referans tutan bir Context, duruma özgü davranışı tanımlayan bir State interface ve her bir durum için davranışı uygulayan Concrete States yapılarından oluşur:

#include <iostream>
#include <memory>

class Document;  // İleriye dönük bildirim

// Durum arayüzü
class DocumentState {
public:
    virtual void publish(Document& doc) = 0;
    virtual std::string getName() const = 0;
    virtual ~DocumentState() = default;
};

// Bağlam
class Document {
    std::unique_ptr<DocumentState> state;
public:
    Document();
    void setState(std::unique_ptr<DocumentState> newState) {
        state = std::move(newState);
    }
    void publish() { state->publish(*this); }
    std::string getStateName() const { return state->getName(); }
};

// Somut Durumlar
class Draft : public DocumentState {
public:
    void publish(Document& doc) override;
    std::string getName() const override { return "Draft"; }
};

class Review : public DocumentState {
public:
    void publish(Document& doc) override;
    std::string getName() const override { return "Review"; }
};

class Published : public DocumentState {
public:
    void publish(Document& doc) override {
        std::cout << "Already published\n";
    }
    std::string getName() const override { return "Published"; }
};

void Draft::publish(Document& doc) {
    std::cout << "Moving to review\n";
    doc.setState(std::make_unique<Review>());
}

void Review::publish(Document& doc) {
    std::cout << "Publishing document\n";
    doc.setState(std::make_unique<Published>());
}

Document::Document() : state(std::make_unique<Draft>()) {}

Her durum publish() eylemini farklı şekilde ele alır ve bir sonraki duruma geçişten sorumludur. Document nesnesinin geçiş mantığını bilmesine gerek yoktur; sadece mevcut duruma delege eder. Bu, büyük switch ifadelerini ortadan kaldırır ve yeni durumlar eklemeyi kolaylaştırır.

Bir nesnenin davranışı büyük ölçüde durumuna bağlı olduğunda ve nesnenin durumuna göre değişen çok sayıda koşullu ifadeniz olduğunda State desenini kullanın.

Görev

Kolay

State desenini kullanarak bir Trafik Işığı Kontrolcüsü oluşturalım. Bir trafik ışığının farklı durumlar (Red, Yellow, Green) arasında döngü yaptığı, her durumun ışık değiştiğinde ne olacağını ve hangi mesajın görüntüleneceğini belirlediği bir sistem oluşturacaksınız. Bu, State deseninin klasik bir örneğidir; trafik ışığının davranışı tamamen mevcut durumuna bağlıdır.

Kodunuzu üç dosya halinde düzenleyeceksiniz:

TrafficLightState.h: Durum arayüzünü ve tüm somut durum sınıflarını tanımlayın.
Aşağıdakilere sahip soyut bir TrafficLightState sınıfı oluşturun:
- Bir sonraki duruma geçişi yöneten saf sanal bir change(TrafficLight& light) metodu
- Mevcut rengi bir dize olarak döndüren saf sanal bir getColor() metodu
- Sürücülerin ne yapması gerektiğini döndüren saf sanal bir getAction() metodu (örneğin, "Stop", "Caution", "Go")
- Sanal bir yıkıcı (destructor)
Üç somut durum uygulayın:
- RedState — renk "Red", eylem "Stop", Green durumuna geçer
- YellowState — renk "Yellow", eylem "Caution", Red durumuna geçer
- GreenState — renk "Green", eylem "Go", Yellow durumuna geçer
Durumlar TrafficLight sınıfına atıfta bulunduğu için TrafficLight için bir ön bildirim (forward declaration) yapmanız gerekecektir.
TrafficLight.h: Mevcut durumu koruyan bağlam (context) sınıfını oluşturun.
TrafficLight sınıfınız bir std::unique_ptr<TrafficLightState> tutmalı ve varsayılan olarak Red durumunda başlamalıdır. Şunları uygulayın:
- setState(std::unique_ptr<TrafficLightState> newState) — mevcut durumu değiştirir
- change() — mevcut durumun change metoduna yetki devreder
- display() — ışığın durumunu şu formatta yazdırır: [Color]: [Action]
main.cpp: Trafik ışığının durumlar arasındaki döngüsünü gösterin.
Bir girdi okuyun: gerçekleştirilecek durum değişikliği sayısı (tam sayı).

Bir TrafficLight oluşturun ve başlangıç durumunu görüntüleyin. Ardından, belirtilen sayıda değişiklik yapın ve her değişiklikten sonra durumu görüntüleyin.

Örneğin, 3 girdisi ile:

Red: Stop
Green: Go
Yellow: Caution
Red: Stop

6 girdisi ile:

Red: Stop
Green: Go
Yellow: Caution
Red: Stop
Green: Go
Yellow: Caution
Red: Stop

Trafik ışığının durumları arasında öngörülebilir bir düzende nasıl döngü yaptığına dikkat edin: Red → Green → Yellow → Red. Her durum kendisinden sonra hangi durumun geleceğini bilir ve kendi geçişini yönetir. TrafficLight sınıfının ne olacağını belirlemek için herhangi bir koşullu mantığa ihtiyacı yoktur; sadece o anki durumu neyse ona yetki devreder.

Kopya kağıdı

State (Durum) deseni, bir nesnenin iç durumu değiştiğinde davranışını değiştirmesine olanak tanır. Karmaşık koşullu ifadeler kullanmak yerine, her durum ayrı bir sınıf olarak kapsüllenir.

Desen üç bileşenden oluşur:

State (Durum) arayüzü: Duruma özgü davranışı tanımlar
Concrete States (Somut Durumlar): Her durum için davranışı uygular
Context (Bağlam): Mevcut duruma bir referans tutar

Temel yapı:

#include <memory>

class Context;  // İleriye dönük bildirim

// State interface
class State {
public:
    virtual void handleAction(Context& ctx) = 0;
    virtual std::string getName() const = 0;
    virtual ~State() = default;
};

// Context
class Context {
    std::unique_ptr<State> state;
public:
    void setState(std::unique_ptr<State> newState) {
        state = std::move(newState);
    }
    void performAction() { 
        state->handleAction(*this); 
    }
    std::string getStateName() const { 
        return state->getName(); 
    }
};

// Concrete State
class ConcreteState : public State {
public:
    void handleAction(Context& ctx) override {
        // Eylemi işle ve bir sonraki duruma geç
        ctx.setState(std::make_unique<AnotherState>());
    }
    std::string getName() const override { 
        return "ConcreteState"; 
    }
};

Her durum eylemleri farklı şekilde ele alır ve bir sonraki duruma geçişten sorumludur. Context, geçiş mantığını bilmesine gerek kalmadan davranışı mevcut duruma devreder.

Bir nesnenin davranışı büyük ölçüde durumuna bağlı olduğunda ve büyük koşullu ifadelerden kaçınmak istediğinizde State desenini kullanın.

Kendin dene

#include <iostream>
#include "TrafficLight.h"

using namespace std;

int main() {
    // Durum değişikliklerinin sayısını oku
    int numChanges;
    cin >> numChanges;
    
    // TODO: Bir TrafficLight nesnesi oluşturun
    
    // TODO: Başlangıç durumunu görüntüleyin
    
    // TODO: Belirtilen sayıda değişikliği gerçekleştirin
    // Her değişiklikten sonra mevcut durumu görüntüleyin
    
    return 0;
}