C++: تمرين: البرمجة كائنية التوجه الشامل

Student (الصنف الأساسي)
 ↑ يرث
UndergraduateStudent (طالب جامعي)
GraduateStudent (طالب دراسات عليا)

Course (صنف المقرر)
Grade (صنف الدرجة)

ManagementSystem (صنف نظام الإدارة)
 - vector<Student*> students
 - vector<Course> courses

#include <iostream>
#include <string>
#include <vector>

// صنف الطالب الأساسي
class Student {
protected:
	std::string id; // رقم الطالب
	std::string name; // الاسم
	int age; // العمر
	std::string major; // التخصص

public:
	// المُنشئ
	Student(const std::string& id, const std::string& name, int age, const std::string& major)
	: id(id), name(name), age(age), major(major) {}
	
	// دالة افتراضية: عرض المعلومات
	virtual void display() const {
		std::cout << "Student ID: " << id << std::endl;
		std::cout << "Name: " << name << std::endl;
		std::cout << "Age: " << age << std::endl;
		std::cout << "Major: " << major << std::endl;
	}
	
	// مدمر افتراضي
	virtual ~Student() {}
	
	// الحاصلات
	std::string getId() const { return id; }
	std::string getName() const { return name; }
};

// صنف الطالب الجامعي
class UndergraduateStudent : public Student {
private:
	int year; // السنة (1-4)

public:
	UndergraduateStudent(const std::string& id, const std::string& name, 
					int age, const std::string& major, int year)
	: Student(id, name, age, major), year(year) {}
	
	void display() const override {
		Student::display();
		std::cout << "Year: " << year << std::endl;
		std::cout << "Type: Undergraduate" << std::endl;
	}
};

// صنف طالب الدراسات العليا
class GraduateStudent : public Student {
private:
	std::string advisor; // المشرف

public:
	GraduateStudent(const std::string& id, const std::string& name,
				int age, const std::string& major, const std::string& advisor)
	: Student(id, name, age, major), advisor(advisor) {}
	
	void display() const override {
		Student::display();
		std::cout << "Advisor: " << advisor << std::endl;
		std::cout << "Type: Graduate Student" << std::endl;
	}
};

class ManagementSystem {
private:
	std::vector<Student*> students; // قائمة الطلاب (تعدد الأشكال)

public:
	// إضافة طالب
	void addStudent(Student* student) {
		students.push_back(student);
		std::cout << "Added successfully!" << std::endl;
	}
	
	// البحث عن طالب
	Student* findStudent(const std::string& id) {
		for (auto s : students) {
			if (s->getId() == id) {
				return s;
			}
		}
		return nullptr;
	}
	
	// عرض جميع الطلاب
	void displayAll() const {
		if (students.empty()) {
			std::cout << "No student information available" << std::endl;
			return;
		}
		
		for (auto s : students) {
			s->display();
			std::cout << "-------------------" << std::endl;
		}
	}
	
	// المدمر: تحرير الذاكرة
	~ManagementSystem() {
		for (auto s : students) {
			delete s;
		}
	}
};

// كود الاختبار
int main() {
	ManagementSystem sys;
	
	// إضافة طالب جامعي
	sys.addStudent(new UndergraduateStudent("001", "Zhang San", 20, "Computer Science", 3));
	sys.addStudent(new GraduateStudent("002", "Li Si", 24, "Software Engineering", "Prof. Wang"));
	
	// عرض جميع الطلاب
	sys.displayAll();
	
	return 0;
}

Added successfully!
No student information available
-------------------

Added successfully!
Added successfully!
Student ID: 001
Name: Zhang San
Age: 20
Major: Computer Science
Year: 3
Type: Undergraduate
-------------------
Student ID: 002
Name: Li Si
Age: 24
Major: Software Engineering
Advisor: Prof. Wang
Type: Graduate Student
-------------------

// صنف الدرجة
### ▶ مثال 2: عرض البرمجة كائنية التوجه (الصعوبة ⭐)

class Grade {
private:
	std::string courseId; // رقم المقرر
	std::string courseName; // اسم المقرر
	double score; // الدرجة

public:
	Grade(const std::string& courseId, const std::string& courseName, double score)
	: courseId(courseId), courseName(courseName), score(score) {}
	
	void display() const {
		std::cout << courseName << ": " << score << " points" << std::endl;
	}
	
	double getScore() const { return score; }
};

// إضافة طرق متعلقة بالدرجات لصنف Student
class Student {
	// ... أعضاء آخرون ...
	std::vector<Grade> grades; // قائمة الدرجات

public:
	void addGrade(const Grade& grade) {
		grades.push_back(grade);
	}
	
	void displayGrades() const {
		if (grades.empty()) {
			std::cout << "No grades available" << std::endl;
			return;
		}
		
		std::cout << name << "'s grades:" << std::endl;
		for (const auto& g : grades) {
			g.display();
		}
	}
	
	double getAverage() const {
		if (grades.empty()) return 0.0;
		
		double sum = 0;
		for (const auto& g : grades) {
			sum += g.getScore();
		}
		return sum / grades.size();
	}
};

void saveToFile(const std::string& filename) {
	std::ofstream file(filename);
	if (!file) {
		std::cout << "Cannot open file" << std::endl;
		return;
	}
	
	for (auto s : students) {
		file << s->getId() << ","
			<< s->getName() << ","
			<< s->getAge() << std::endl;
	}
	
	file.close();
	std::cout << "Saved successfully!" << std::endl;
}

void loadFromFile(const std::string& filename) {
	std::ifstream file(filename);
	if (!file) {
		std::cout << "Cannot open file" << std::endl;
		return;
	}
	
	std::string id, name, ageStr;
	while (std::getline(file, id, ',')) {
		std::getline(file, name, ',');
		std::getline(file, ageStr);
		int age = std::stoi(ageStr);
		
		// إنشاء كائن طالب (مبسط؛ يجب التمييز بين جامعي/دراسات عليا)
		students.push_back(new UndergraduateStudent(id, name, age, "Unknown", 1));
	}
	
	file.close();
	std::cout << "Loaded successfully!" << std::endl;
}

void showMenu() {
	std::cout << "\n===== Student Management System =====" << std::endl;
	std::cout << "1. Add student" << std::endl;
	std::cout << "2. Find student" << std::endl;
	std::cout << "3. Display all students" << std::endl;
	std::cout << "4. Enter grades" << std::endl;
	std::cout << "5. Save data" << std::endl;
	std::cout << "6. Load data" << std::endl;
	std::cout << "0. Exit" << std::endl;
	std::cout << "=====================================" << std::endl;
	std::cout << "Choose: ";
}

int main() {
	ManagementSystem sys;
	int choice;
	
	do {
		showMenu();
		std::cin >> choice;
		
		switch (choice) {
		case 1:
			// إضافة طالب
			break;
		case 2:
			// البحث عن طالب
			break;
		case 3:
			sys.displayAll();
			break;
		case 0:
			std::cout << "Goodbye!" << std::endl;
			break;
		default:
			std::cout << "Invalid choice" << std::endl;
		}
	} while (choice != 0);
	
	return 0;
}

#include <iostream>
#include <string>

class Animal {
public:
    std::string name;
    Animal(const std::string& n) : name(n) {}
    virtual void speak() const = 0;
    virtual ~Animal() {}
};

class Dog : public Animal {
public:
    Dog(const std::string& n) : Animal(n) {}
    void speak() const override {
        std::cout << name << ": Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    Cat(const std::string& n) : Animal(n) {}
    void speak() const override {
        std::cout << name << ": Meow!" << std::endl;
    }
};

int main() {
    Dog dog("Wangcai");
    Cat cat("Mimi");
    dog.speak();
    cat.speak();
    return 0;
}

: Woof!
: Meow!