C++: البانيات المتقدمة

#include <iostream>
#include <string>

class Student {
private:
 std::string name;
 int age;
 
public:
 // باني افتراضي (بدون معاملات)
 Student() {
 name = "Unknown";
 age = 0;
 std::cout << "Default constructor called" << std::endl;
 }
};

int main() {
 Student s1; // ✅ يستدعي الباني الافتراضي
 return 0;
}

#include <iostream>
#include <string>

class Student {
private:
 std::string name;
 int age;
 
public:
 // كتبت بانيًا بمعاملات فقط
 Student(const std::string& n, int a) {
 name = n;
 age = a;
 }
};

int main() {
 Student s1("Alice", 20); // ✅ صحيح
 Student s2; // ❌ خطأ: لا يوجد باني افتراضي
 return 0;
}

// الطريقة 1: كتابته صراحةً
Student() {
 name = "Unknown";
 age = 0;
}

// الطريقة 2: استخدام = default (C++11، موصى بها)
Student() = default;

Student(const std::string& n, int a) {
 name = n; // هذا تعيين، وليس تهيئة
 age = a;
}

Student(const std::string& n, int a) : name(n), age(a) {
 // يمكن أن يكون جسم الدالة فارغاً
}

#include <iostream>
#include <string>

class Student {
private:
 const std::string id; // عضو const
 std::string name;
 
public:
 // ❌ خطأ: لا يمكن تعيين أعضاء const في جسم الدالة
 // Student(const std::string& i, const std::string& n) {
 // id = i; // ❌ عضو const لا يمكن تعيينه
 // name = n;
 // }
 
 // ✅ صحيح: استخدم قائمة التهيئة
 Student(const std::string& i, const std::string& n) : id(i), name(n) {
 }
};

int main() {
 Student s1("20240001", "Alice");
 return 0;
}

#include <iostream>
#include <string>

class Student {
public:
 std::string name;
 int age;
 
 // يُنشئ المترجم تلقائياً باني نسخ (نسخ عضو بعضو)
};

int main() {
 Student s1;
 s1.name = "Alice";
 s1.age = 20;
 
 Student s2 = s1; // ✅ يستدعي باني النسخ
 std::cout << "s2 Name: " << s2.name << std::endl; // Alice
 std::cout << "s2 Age: " << s2.age << std::endl; // 20
 
 return 0;
}

s2 Name: Alice
s2 Age: 20

#include <iostream>
#include <string>

class Student {
private:
 std::string name;
 int age;
 
public:
 // باني عادي
 Student(const std::string& n, int a) : name(n), age(a) {
 std::cout << "Regular constructor called：" << name << std::endl;
 }
 
 // باني نسخ
 Student(const Student& other) : name(other.name), age(other.age) {
 std::cout << "Copy constructor called: " << name << std::endl;
 }
};

int main() {
 Student s1("Alice", 20);
 Student s2 = s1; // يستدعي باني النسخ
 
 return 0;
}

#include <iostream>
#include <cstring>

class MyClass {
public:
 char* data;
 
 MyClass() {
 data = new char[5];
 std::strcpy(data, "Hello");
 }
 
 // ❌ لا يوجد باني نسخ مخصص (سيستخدم النسخة السطحية الافتراضية)
 
 ~MyClass() {
 delete data;
 }
};

int main() {
 MyClass obj1;
 MyClass obj2 = obj1; // نسخة سطحية: obj1.data و obj2.data يشيران إلى نفس الذاكرة
 
 // عند انتهاء main، يُدمَّر obj2 أولاً (يُحرر data)
 // ثم يُدمَّر obj1 (يُحرر data مرة أخرى، لكنها حُرِّرت بالفعل) → انهيار!
 return 0;
}

#include <iostream>
#include <cstring>

class MyClass {
public:
 char* data;
 
 MyClass() {
 data = new char[5];
 std::strcpy(data, "Hello");
 }
 
 // باني نسخ مخصص (نسخة عميقة)
 MyClass(const MyClass& other) {
 data = new char[std::strlen(other.data) + 1];
 std::strcpy(data, other.data);
 }
 
 ~MyClass() {
 delete data;
 }
};

int main() {
 MyClass obj1;
 MyClass obj2 = obj1; // نسخة عميقة: obj2.data يشير إلى ذاكرة مُخصصة حديثاً
 
 std::cout << "obj1.data = " << obj1.data << std::endl;
 std::cout << "obj2.data = " << obj2.data << std::endl;
 
 return 0;
}

#include <iostream>
#include <string>

class MyClass {
private:
 std::string* data;
 
public:
 // باني عادي
 MyClass(const std::string& s) {
 data = new std::string(s);
 std::cout << "Regular constructor" << std::endl;
 }
 
 // باني نقل (C++11)
 MyClass(MyClass&& other) noexcept : data(other.data) {
 other.data = nullptr; // اضبط مؤشر الكائن الآخر على قيمة فارغة (منع التحرير عند التدمير)
 std::cout << "Move constructionfunction" << std::endl;
 }
 
 ~MyClass() {
 delete data;
 }
};

int main() {
 MyClass obj1("Hello");
 MyClass obj2 = std::move(obj1); // يستدعي باني النقل
 
 return 0;
}

#include <iostream>
#include <string>

class Student {
private:
 std::string name;
 int age;
 
public:
 // باني عادي
 Student(const std::string& n, int a) : name(n), age(a) {
 std::cout << "Regular Constructor: " << name << std::endl;
 }
 
 // باني نسخ
 Student(const Student& other) : name(other.name), age(other.age) {
 std::cout << "Regular Constructor: " << name << std::endl;
 }
 
 // مدمر
 ~Student() {
 std::cout << "Destructor: " << name << std::endl;
 }
 
 void introduce() {
 std::cout << "My name is " << name << "，this year " << age << " years old。" << std::endl;
 }
};

int main() {
 Student s1("Alice", 20);
 Student s2 = s1; // يستدعي باني النسخ
 
 s1.introduce();
 s2.introduce();
 
 return 0;
}

Regular Constructor: Alice
Regular Constructor: Alice
Destructor: Alice
Destructor: Alice
My name is Alice，this year 20 years old。
My name is Alice，this year 20 years old。

#include <iostream>
#include <string>

class Student {
    std::string name;
    int age;
public:
    Student(std::string n, int a) : name(n), age(a) {}
    Student(std::string n) : Student(n, 18) {} // باني مفوَّض
    Student() : Student("Unknown") {}

    void print() { std::cout << name << "，" << age << "years old" << std::endl; }
};

int main() {
    Student s1("Zhang San", 20);
    Student s2("Li Si");
    Student s3;

    s1.print();
    s2.print();
    s3.print();

    return 0;
}

Zhang San, 20 years old
Li Si, 18 years old
Unknown, 18 years old