انواع کلاس‌ها در ++C: راهنمای جامع با مثال‌های کاربردی

class BankAccount {
public:
    BankAccount(double initialBalance) : balance(initialBalance) {}
    
    void deposit(double amount) {
        balance += amount;
    }
    
    void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        }
    }
    
    double getBalance() const {
        return balance;
    }

private:
    double balance;
};

class Shape {
public:
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
    virtual void draw() const = 0;
    
    // تابع غیر مجازی می‌تواند پیاده‌سازی داشته باشد
    void printInfo() const {
        std::cout << "Area: " << area() << ", Perimeter: " << perimeter() << std::endl;
    }
    
    virtual ~Shape() {} // تخریب‌کننده مجازی
};

class Circle : public Shape {
public:
    Circle(double r) : radius(r) {}
    
    double area() const override {
        return 3.14159 * radius * radius;
    }
    
    double perimeter() const override {
        return 2 * 3.14159 * radius;
    }
    
    void draw() const override {
        std::cout << "Drawing a circle" << std::endl;
    }

private:
    double radius;
};

class NetworkConnection {
public:
    NetworkConnection(const std::string& address) : serverAddress(address) {}
    
    virtual void connect() {
        std::cout << "Connecting to " << serverAddress << std::endl;
    }
    
    virtual void disconnect() {
        std::cout << "Disconnecting from " << serverAddress << std::endl;
    }
    
    virtual void send(const std::string& data) = 0;
    virtual std::string receive() = 0;

protected:
    std::string serverAddress;
};

class Animal {
public:
    virtual void eat() {
        std::cout << "Animal is eating" << std::endl;
    }
};

class Mammal : public Animal {
public:
    void breathe() {
        std::cout << "Mammal is breathing air" << std::endl;
    }
};

class Dog : public Mammal {
public:
    void eat() override {
        std::cout << "Dog is eating dog food" << std::endl;
    }
    
    void bark() {
        std::cout << "Woof!" << std::endl;
    }
};

template 
class FixedSizeArray {
public:
    FixedSizeArray() = default;
    
    T& operator[](size_t index) {
        if (index >= N) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }
    
    const T& operator[](size_t index) const {
        if (index >= N) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }
    
    size_t size() const { return N; }

private:
    T data[N];
};

FixedSizeArray<int, 10> intArray;
FixedSizeArray<std::string, 5> stringArray;

class MathUtils {
public:
    static double pi() { return 3.141592653589793; }
    
    static double degToRad(double degrees) {
        return degrees * pi() / 180.0;
    }
    
    static double radToDeg(double radians) {
        return radians * 180.0 / pi();
    }
    
    // جلوگیری از ساخت نمونه از کلاس
    MathUtils() = delete;
};

// استفاده:
double angle = MathUtils::degToRad(45);

class DatabaseConnection {
public:
    static DatabaseConnection& getInstance() {
        static DatabaseConnection instance;
        return instance;
    }
    
    void connect() { /* ... */ }
    void disconnect() { /* ... */ }

    // جلوگیری از کپی و انتساب
    DatabaseConnection(const DatabaseConnection&) = delete;
    void operator=(const DatabaseConnection&) = delete;

private:
    DatabaseConnection() {} // سازنده خصوصی
};

class ShapeFactory {
public:
    static std::unique_ptr createShape(const std::string& type) {
        if (type == "circle") return std::make_unique();
        if (type == "rectangle") return std::make_unique();
        return nullptr;
    }
};

class SortingStrategy {
public:
    virtual void sort(std::vector& data) = 0;
    virtual ~SortingStrategy() = default;
};

class QuickSort : public SortingStrategy { /* ... */ };
class MergeSort : public SortingStrategy { /* ... */ };

class Sorter {
    std::unique_ptr strategy;
public:
    void setStrategy(std::unique_ptr s) { strategy = std::move(s); }
    void sort(std::vector& data) { if (strategy) strategy->sort(data); }
};

class Drawable {
public:
    virtual void draw() const = 0;
    virtual ~Drawable() = default;
};

class Clickable {
public:
    virtual void onClick() = 0;
    virtual ~Clickable() = default;
};

class Button : public Drawable, public Clickable {
    // پیاده‌سازی هر دو رابط
};

class MemoryBuffer {
public:
    explicit MemoryBuffer(size_t size) : size(size), data(new char[size]) {}
    
    ~MemoryBuffer() { delete[] data; }
    
    // قانون پنج‌تایی (Rule of Five)
    MemoryBuffer(const MemoryBuffer& other) : size(other.size), data(new char[other.size]) {
        std::copy(other.data, other.data + other.size, data);
    }
    
    MemoryBuffer& operator=(const MemoryBuffer& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new char[size];
            std::copy(other.data, other.data + other.size, data);
        }
        return *this;
    }
    
    MemoryBuffer(MemoryBuffer&& other) noexcept : size(other.size), data(other.data) {
        other.size = 0;
        other.data = nullptr;
    }
    
    MemoryBuffer& operator=(MemoryBuffer&& other) noexcept {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = other.data;
            other.size = 0;
            other.data = nullptr;
        }
        return *this;
    }

private:
    size_t size;
    char* data;
};

template 
class TypeInfo {
public:
    static std::string name() {
        return typeid(T).name();
    }
    
    static constexpr bool isPointer() {
        return std::is_pointer::value;
    }
};

// استفاده:
std::cout << TypeInfo::name(); // "i" در بسیاری از کامپایلرها