Ders 05: Yapılar (Struct)

🎒 Kendi Yaratığını Tasarla!Design Your Own Creature!

Struct = Şablon! Bir yaratığın tüm özelliklerini bir arada tutabilirsin.

📝 Örnek 1: Evcil Hayvan OyunuExample 1: Pet Game

🐾 pet.berk

// 🐾 Evcil hayvan şablonu
yapi EvcilHayvan {
    isim: metin,
    tur: metin,
    yas: tamsayı,
    mutluluk: tamsayı,
    aclik: tamsayı,
}

// Evcil hayvana özellikler ekle
impl EvcilHayvan {
    // Yeni hayvan oluştur
    fonksiyon yeni(isim: metin, tur: metin) -> EvcilHayvan {
        don EvcilHayvan {
            isim: isim,
            tur: tur,
            yas: 0,
            mutluluk: 50,
            aclik: 50,
        };
    }
    
    // Besle 🍖
    fonksiyon besle(&mut self) {
        self.aclik = self.aclik - 20;
        self.mutluluk = self.mutluluk + 10;
        yazdir("🍖 {} yemek yedi! Mutluluk: {}", self.isim, self.mutluluk);
    }
    
    // Oyna 🎾
    fonksiyon oyna(&mut self) {
        self.mutluluk = self.mutluluk + 20;
        self.aclik = self.aclik + 10;
        yazdir("🎾 {} ile oynadın! Mutluluk: {}", self.isim, self.mutluluk);
    }
    
    // Durum göster
    fonksiyon durum(&self) {
        yazdir("╔══════════════════╗");
        yazdir("║ 🐾 {} ({})     ", self.isim, self.tur);
        yazdir("║ 😊 Mutluluk: {}  ", self.mutluluk);
        yazdir("║ 🍖 Açlık: {}     ", self.aclik);
        yazdir("╚══════════════════╝");
    }
}

fonksiyon ana() {
    değişken mut kopek = EvcilHayvan::yeni("Karabaş", "🐕 Köpek");
    
    kopek.durum();
    kopek.oyna();
    kopek.besle();
    kopek.durum();
}

📝 Örnek 2: Monster KartlarıExample 2: Monster Cards

👾 monsters.berk

yapi Canavar {
    isim: metin,
    element: metin,
    can: tamsayı,
    saldiri: tamsayı,
    savunma: tamsayı,
}

impl Canavar {
    fonksiyon kart_goster(&self) {
        yazdir("┌─────────────────────┐");
        yazdir("│ {} {}              ", self.element, self.isim);
        yazdir("├─────────────────────┤");
        yazdir("│ ❤️  HP: {:3}         │", self.can);
        yazdir("│ ⚔️  ATK: {:3}        │", self.saldiri);
        yazdir("│ 🛡️  DEF: {:3}        │", self.savunma);
        yazdir("└─────────────────────┘");
    }
    
    fonksiyon saldir(&self, hedef: &mut Canavar) {
        değişken hasar = self.saldiri - hedef.savunma;
        eğer hasar > 0 yap
            hedef.can = hedef.can - hasar;
            yazdir("💥 {} -> {} için {} hasar!", self.isim, hedef.isim, hasar);
        değilse yap
            yazdir("🛡️ Saldırı engellendi!");
        son
    }
}

fonksiyon ana() {
    değişken mut ejderha = Canavar {
        isim: "Ateş Ejderhası",
        element: "🔥",
        can: 100,
        saldiri: 40,
        savunma: 20,
    };
    
    değişken mut golem = Canavar {
        isim: "Kaya Golemi",
        element: "🪨",
        can: 150,
        saldiri: 25,
        savunma: 35,
    };
    
    ejderha.kart_goster();
    golem.kart_goster();
    
    yazdir("\n⚔️ SAVAŞ!\n");
    ejderha.saldir(&mut golem);
    golem.kart_goster();
}

📖 Struct Nedir?What is a Struct?

Struct, ilişkili verileri bir arada tutan özel bir veri tipidir. Sınıflara benzer ama daha basit.

📝 Örnek 1: Öğrenci SistemiExample 1: Student System

📚 ogrenci.berk

yapi Ogrenci {
    numara: tamsayı,
    isim: metin,
    bolum: metin,
    notlar: Vektor[ondalık],
}

impl Ogrenci {
    fonksiyon yeni(numara: tamsayı, isim: metin, bolum: metin) -> Ogrenci {
        don Ogrenci {
            numara: numara,
            isim: isim,
            bolum: bolum,
            notlar: Vektor::yeni(),
        };
    }
    
    fonksiyon not_ekle(&mut self, not: ondalık) {
        self.notlar.ekle(not);
    }
    
    fonksiyon ortalama(&self) -> ondalık {
        eğer self.notlar.bos_mu() yap
            don 0.0;
        son
        değişken toplam: ondalık = 0.0;
        icin not in &self.notlar {
            toplam = toplam + not;
        }
        don toplam / self.notlar.uzunluk() as ondalık;
    }
    
    fonksiyon bilgi_goster(&self) {
        yazdir("📋 Öğrenci Bilgisi");
        yazdir("  No: {}", self.numara);
        yazdir("  Ad: {}", self.isim);
        yazdir("  Bölüm: {}", self.bolum);
        yazdir("  Ortalama: {:.2}", self.ortalama());
    }
}

fonksiyon ana() {
    değişken mut ogrenci = Ogrenci::yeni(12345, "Ayşe Yılmaz", "Bilgisayar Müh.");
    
    ogrenci.not_ekle(85.0);
    ogrenci.not_ekle(90.0);
    ogrenci.not_ekle(78.5);
    
    ogrenci.bilgi_goster();
}

📝 Örnek 2: Ürün YönetimiExample 2: Product Management

🛒 product.berk

struct Product {
    id: int,
    name: string,
    price: float,
    stock: int,
}

impl Product {
    function new(id: int, name: string, price: float, stock: int) -> Product {
        Product { id, name, price, stock }
    }
    
    function is_available(&self) -> bool {
        self.stock > 0
    }
    
    function apply_discount(&mut self, percent: float) {
        self.price = self.price * (1.0 - percent / 100.0);
    }
    
    function sell(&mut self, quantity: int) -> bool {
        if quantity <= self.stock {
            self.stock = self.stock - quantity;
            return true;
        }
        return false;
    }
    
    function display(&self) {
        print("🏷️ {} (ID: {})", self.name, self.id);
        print("   Fiyat: {:.2}₺", self.price);
        print("   Stok: {} adet", self.stock);
    }
}

function main() {
    let mut laptop = Product::new(1, "Gaming Laptop", 25000.0, 10);
    
    laptop.display();
    
    laptop.apply_discount(15.0);  // %15 indirim
    print("\n📢 İndirimli fiyat:");
    laptop.display();
    
    if laptop.sell(2) {
        print("\n✅ 2 adet satıldı!");
    }
    laptop.display();
}

🎯 İleri Struct KavramlarıAdvanced Struct Concepts

Builder patternBuilder pattern
Tuple structs ve unit structsTuple structs and unit structs
Visibility (pub) ve encapsulationVisibility (pub) and encapsulation
Derive macros (#[derive(...)])Derive macros

📝 Örnek 1: Builder PatternExample 1: Builder Pattern

BERK (Builder)

#[derive(Debug, Clone)]
struct HttpRequest {
    method: String,
    url: String,
    headers: HashMap,
    body: Option,
    timeout: Duration,
}

struct HttpRequestBuilder {
    method: String,
    url: String,
    headers: HashMap,
    body: Option,
    timeout: Duration,
}

impl HttpRequestBuilder {
    function new(url: &str) -> Self {
        HttpRequestBuilder {
            method: "GET".to_string(),
            url: url.to_string(),
            headers: HashMap::new(),
            body: None,
            timeout: Duration::from_secs(30),
        }
    }
    
    function method(mut self, method: &str) -> Self {
        self.method = method.to_string();
        self
    }
    
    function header(mut self, key: &str, value: &str) -> Self {
        self.headers.insert(key.to_string(), value.to_string());
        self
    }
    
    function body(mut self, body: &str) -> Self {
        self.body = Some(body.to_string());
        self
    }
    
    function timeout(mut self, secs: u64) -> Self {
        self.timeout = Duration::from_secs(secs);
        self
    }
    
    function build(self) -> HttpRequest {
        HttpRequest {
            method: self.method,
            url: self.url,
            headers: self.headers,
            body: self.body,
            timeout: self.timeout,
        }
    }
}

function main() {
    let request = HttpRequestBuilder::new("https://api.example.com/users")
        .method("POST")
        .header("Content-Type", "application/json")
        .header("Authorization", "Bearer token123")
        .body(r#"{"name": "John"}"#)
        .timeout(60)
        .build();
    
    print("Request: {:?}", request);
}

📝 Örnek 2: Domain ModelingExample 2: Domain Modeling

BERK (Domain)

// Newtype pattern for type safety
struct UserId(u64);
struct Email(String);
struct Money(i64);  // Cents to avoid float precision

impl Money {
    function from_dollars(dollars: f64) -> Self {
        Money((dollars * 100.0).round() as i64)
    }
    
    function as_dollars(&self) -> f64 {
        self.0 as f64 / 100.0
    }
}

// Domain entity with invariants
struct BankAccount {
    id: UserId,
    owner_email: Email,
    balance: Money,
    is_active: bool,
}

impl BankAccount {
    function deposit(&mut self, amount: Money) -> Result<(), &'static str> {
        if !self.is_active {
            return Err("Account is not active");
        }
        if amount.0 <= 0 {
            return Err("Deposit amount must be positive");
        }
        self.balance = Money(self.balance.0 + amount.0);
        Ok(())
    }
    
    function withdraw(&mut self, amount: Money) -> Result<(), &'static str> {
        if !self.is_active {
            return Err("Account is not active");
        }
        if amount.0 <= 0 {
            return Err("Withdrawal amount must be positive");
        }
        if self.balance.0 < amount.0 {
            return Err("Insufficient funds");
        }
        self.balance = Money(self.balance.0 - amount.0);
        Ok(())
    }
}

function main() {
    let mut account = BankAccount {
        id: UserId(12345),
        owner_email: Email("user@example.com".to_string()),
        balance: Money::from_dollars(100.0),
        is_active: true,
    };
    
    match account.deposit(Money::from_dollars(50.0)) {
        Ok(_) => print("Deposit successful"),
        Err(e) => print("Error: {}", e),
    }
    
    print("Balance: ${:.2}", account.balance.as_dollars());
}

📌 ÖzetSummary

yapi/struct ile yapı tanımlanıryapi/struct defines a structure
impl bloğu ile metotlar eklenirimpl block adds methods
&self okuma, &mut self değiştirme için