Swift: فئات Swift وبناها

class UserAccount {
    var name: String
    var balance: Double
    init(name: String, balance: Double) {
        self.name = name
        self.balance = balance
    }
}
let account1 = UserAccount(name: "Alice", balance: 1000)
let account2 = account1  // References the same instance
account2.name = "Bob"
print(account1.name)  // "Bob" — account1 was also changed!

struct UserAccount {
    var name: String
    var balance: Double
}
var account1 = UserAccount(name: "Alice", balance: 1000)
var account2 = account1  // Copies an independent set of data
account2.name = "Bob"
print(account1.name)  // "Alice" — account1 is unaffected

// ============================================
// Class and struct definition comparison
// ============================================
// Class definition — must write init manually
class PersonClass {
    var name: String
    var age: Int
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    func introduce() {
        print("Hi, I'm \(name), \(age) years old")
    }
}
// Struct definition — automatically gets a memberwise initializer
struct PersonStruct {
    var name: String
    var age: Int
    func introduce() {
        print("Hi, I'm \(name), \(age) years old")
    }
}
let p1 = PersonClass(name: "Alice", age: 28)
p1.introduce()
let p2 = PersonStruct(name: "Bob", age: 22)  // Auto-generated init
p2.introduce()

// ============================================
// Value type vs reference type assignment behavior
// ============================================
// Struct — value type
struct Position {
    var x: Int
    var y: Int
}
var posA = Position(x: 10, y: 20)
var posB = posA
posB.x = 99
print("posA: (\(posA.x), \(posA.y))")  // Unchanged
print("posB: (\(posB.x), \(posB.y))")  // Only affects posB
// Class — reference type
class Location {
    var x: Int
    var y: Int
    init(x: Int, y: Int) { self.x = x; self.y = y }
}
var locA = Location(x: 10, y: 20)
var locB = locA
locB.x = 99
print("locA: (\(locA.x), \(locA.y))")  // Also changed!
print("locB: (\(locB.x), \(locB.y))")

let loc1 = Location(x: 5, y: 10)
let loc2 = loc1
let loc3 = Location(x: 5, y: 10)  // Different instance
print(loc1 === loc2)  // true — same instance
print(loc1 === loc3)  // false — different instances

// ============================================
// Struct mutating methods
// ============================================
struct Counter {
    var count = 0
    // Non-mutating — read-only method
    func display() {
        print("Count: \(count)")
    }
    // mutating — modifies property
    mutating func increment() {
        count += 1
    }
    // mutating — replaces the entire instance
    mutating func reset() {
        self = Counter()  // Replace self
    }
}
var counter = Counter()  // Must be var to call mutating methods
counter.increment()
counter.increment()
counter.display()   // Count: 2
counter.reset()
counter.display()   // Count: 0

// ============================================
// Why modern Swift prefers struct for models
// ============================================
struct User {
    let id: Int
    var name: String
    var email: String
    var score: Int
    mutating func addScore(_ points: Int) {
        score += points
    }
}
var user = User(id: 1, name: "Alice", email: "alice@example.com", score: 100)
user.addScore(50)
// Copy-and-mutate pattern — safely create changed versions
let admin = User(id: 2, name: "Admin", email: "admin@example.com", score: 0)
// admin.addScore(10)  // Compile error! let constant cannot call mutating methods
var editor = admin
editor.name = "Editor"  // Independent modification, doesn't affect admin

// ============================================
// Complete example: Bank account system
// Features: class for account management, struct for transaction records
// ============================================
import Foundation
// 1. Transaction record — value type struct
struct Transaction {
    let id: Int
    let amount: Double
    let type: String  // "deposit" or "withdraw"
    let date: Date
    func description() -> String {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd"
        return "[\(formatter.string(from: date))] \(type): $\(amount)"
    }
}
// 2. Account — reference type class (shared state)
class BankAccount {
    let accountNumber: String
    var balance: Double
    private var transactions: [Transaction] = []
    private var nextId = 1
    init(accountNumber: String, initialBalance: Double = 0) {
        self.accountNumber = accountNumber
        self.balance = initialBalance
    }
    func deposit(amount: Double) {
        guard amount > 0 else { return }
        balance += amount
        let tx = Transaction(id: nextId, amount: amount, type: "deposit", date: Date())
        transactions.append(tx)
        nextId += 1
    }
    func withdraw(amount: Double) -> Bool {
        guard amount > 0 && amount <= balance else { return false }
        balance -= amount
        let tx = Transaction(id: nextId, amount: amount, type: "withdraw", date: Date())
        transactions.append(tx)
        nextId += 1
        return true
    }
    func printStatement() {
        print("=== Account \(accountNumber) ===")
        print("Balance: $\(balance)")
        print("Transactions:")
        for tx in transactions {
            print("  \(tx.description())")
        }
    }
}
// 3. Usage
let account = BankAccount(accountNumber: "ACC-001", initialBalance: 1000)
account.deposit(amount: 500)
account.withdraw(amount: 200)
account.deposit(amount: 100)
account.printStatement()