004 《C++ 面向对象编程 (Object-Oriented Programming - OOP) 深度解析》

                                
                                    

                            
1
                            
class Car { // 定义一个名为 Car 的类
                        

                            
2
                            
public: // 公有访问修饰符
                        

                            
3
                            
    std::string color; // 颜色属性
                        

                            
4
                            
    std::string brand; // 品牌属性
                        

                            
5
                            
    int speed;       // 速度属性
                        

                            
6
                            

                        

                            
7
                            
    void start() { // 启动行为
                        

                            
8
                            
        std::cout << "Car started." << std::endl;
                        

                            
9
                            
    }
                        

                            
10
                            

                        

                            
11
                            
    void accelerate() { // 加速行为
                        

                            
12
                            
        speed += 10;
                        

                            
13
                            
        std::cout << "Car accelerated. Current speed: " << speed << " km/h" << std::endl;
                        

                            
14
                            
    }
                        

                            
15
                            

                        

                            
16
                            
    void brake() { // 刹车行为
                        

                            
17
                            
        speed = 0;
                        

                            
18
                            
        std::cout << "Car braked. Current speed: " << speed << " km/h" << std::endl;
                        

                            
19
                            
    }
                        

                            
20
                            
};
                        

                            
21
                            

                        

                            
22
                            
int main() {
                        

                            
23
                            
    Car myCar; // 创建一个 Car 类的对象 myCar
                        

                            
24
                            
    myCar.color = "Red";
                        

                            
25
                            
    myCar.brand = "Toyota";
                        

                            
26
                            
    myCar.speed = 0;
                        

                            
27
                            

                        

                            
28
                            
    std::cout << "My car color: " << myCar.color << std::endl;
                        

                            
29
                            
    myCar.start();
                        

                            
30
                            
    myCar.accelerate();
                        

                            
31
                            
    myCar.brake();
                        

                            
32
                            

                        

                            
33
                            
    return 0;
                        

                            
34
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string>
                        

                            
3
                            

                        

                            
4
                            
// 抽象类 Shape
                        

                            
5
                            
class Shape {
                        

                            
6
                            
public:
                        

                            
7
                            
    // 纯虚函数，定义抽象接口，强制子类实现
                        

                            
8
                            
    virtual void draw() = 0;
                        

                            
9
                            

                        

                            
10
                            
    // 普通成员函数，提供通用行为
                        

                            
11
                            
    void displayShapeType() {
                        

                            
12
                            
        std::cout << "This is a shape." << std::endl;
                        

                            
13
                            
    }
                        

                            
14
                            
};
                        

                            
15
                            

                        

                            
16
                            
// 具体类 Circle，继承自 Shape
                        

                            
17
                            
class Circle : public Shape {
                        

                            
18
                            
public:
                        

                            
19
                            
    void draw() override { // 实现抽象方法 draw()
                        

                            
20
                            
        std::cout << "Drawing a circle." << std::endl;
                        

                            
21
                            
    }
                        

                            
22
                            
};
                        

                            
23
                            

                        

                            
24
                            
// 具体类 Rectangle，继承自 Shape
                        

                            
25
                            
class Rectangle : public Shape {
                        

                            
26
                            
public:
                        

                            
27
                            
    void draw() override { // 实现抽象方法 draw()
                        

                            
28
                            
        std::cout << "Drawing a rectangle." << std::endl;
                        

                            
29
                            
    }
                        

                            
30
                            
};
                        

                            
31
                            

                        

                            
32
                            
int main() {
                        

                            
33
                            
    Shape* shape1 = new Circle();    // 使用抽象类指针指向具体对象
                        

                            
34
                            
    Shape* shape2 = new Rectangle(); // 使用抽象类指针指向具体对象
                        

                            
35
                            

                        

                            
36
                            
    shape1->displayShapeType(); // 调用基类的通用方法
                        

                            
37
                            
    shape1->draw();             // 调用具体类的实现方法 (多态)
                        

                            
38
                            

                        

                            
39
                            
    shape2->displayShapeType(); // 调用基类的通用方法
                        

                            
40
                            
    shape2->draw();             // 调用具体类的实现方法 (多态)
                        

                            
41
                            

                        

                            
42
                            
    delete shape1;
                        

                            
43
                            
    delete shape2;
                        

                            
44
                            

                        

                            
45
                            
    return 0;
                        

                            
46
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string>
                        

                            
3
                            

                        

                            
4
                            
class BankAccount {
                        

                            
5
                            
private: // 私有访问修饰符，账户余额为私有成员
                        

                            
6
                            
    double balance;
                        

                            
7
                            

                        

                            
8
                            
public: // 公有访问修饰符，提供公有接口
                        

                            
9
                            
    BankAccount(double initialBalance) : balance(initialBalance) {} // 构造函数
                        

                            
10
                            

                        

                            
11
                            
    // 公有的存款方法
                        

                            
12
                            
    void deposit(double amount) {
                        

                            
13
                            
        if (amount > 0) {
                        

                            
14
                            
            balance += amount;
                        

                            
15
                            
            std::cout << "Deposit successful. Current balance: " << balance << std::endl;
                        

                            
16
                            
        } else {
                        

                            
17
                            
            std::cout << "Invalid deposit amount." << std::endl;
                        

                            
18
                            
        }
                        

                            
19
                            
    }
                        

                            
20
                            

                        

                            
21
                            
    // 公有的取款方法
                        

                            
22
                            
    void withdraw(double amount) {
                        

                            
23
                            
        if (amount > 0 && amount <= balance) {
                        

                            
24
                            
            balance -= amount;
                        

                            
25
                            
            std::cout << "Withdrawal successful. Current balance: " << balance << std::endl;
                        

                            
26
                            
        } else {
                        

                            
27
                            
            std::cout << "Insufficient balance or invalid withdrawal amount." << std::endl;
                        

                            
28
                            
        }
                        

                            
29
                            
    }
                        

                            
30
                            

                        

                            
31
                            
    // 公有的查询余额方法
                        

                            
32
                            
    double getBalance() const {
                        

                            
33
                            
        return balance; // 只读访问，不修改 balance
                        

                            
34
                            
    }
                        

                            
35
                            
};
                        

                            
36
                            

                        

                            
37
                            
int main() {
                        

                            
38
                            
    BankAccount account(1000.0); // 创建一个 BankAccount 对象，初始余额 1000.0
                        

                            
39
                            

                        

                            
40
                            
    // account.balance = -100.0; // 错误！无法直接访问私有成员 balance
                        

                            
41
                            

                        

                            
42
                            
    account.deposit(500.0);   // 通过公有方法 deposit 存款
                        

                            
43
                            
    account.withdraw(200.0);  // 通过公有方法 withdraw 取款
                        

                            
44
                            
    std::cout << "Current balance: " << account.getBalance() << std::endl; // 通过公有方法 getBalance 查询余额
                        

                            
45
                            

                        

                            
46
                            
    return 0;
                        

                            
47
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string>
                        

                            
3
                            

                        

                            
4
                            
// 父类 Person
                        

                            
5
                            
class Person {
                        

                            
6
                            
public:
                        

                            
7
                            
    std::string name;
                        

                            
8
                            
    int age;
                        

                            
9
                            

                        

                            
10
                            
    void eat() {
                        

                            
11
                            
        std::cout << "Person is eating." << std::endl;
                        

                            
12
                            
    }
                        

                            
13
                            

                        

                            
14
                            
    void sleep() {
                        

                            
15
                            
        std::cout << "Person is sleeping." << std::endl;
                        

                            
16
                            
    }
                        

                            
17
                            
};
                        

                            
18
                            

                        

                            
19
                            
// 子类 Student，公有继承自 Person
                        

                            
20
                            
class Student : public Person {
                        

                            
21
                            
public:
                        

                            
22
                            
    std::string studentID;
                        

                            
23
                            

                        

                            
24
                            
    void study() {
                        

                            
25
                            
        std::cout << "Student is studying." << std::endl;
                        

                            
26
                            
    }
                        

                            
27
                            
};
                        

                            
28
                            

                        

                            
29
                            
// 子类 Teacher，公有继承自 Person
                        

                            
30
                            
class Teacher : public Person {
                        

                            
31
                            
public:
                        

                            
32
                            
    std::string teacherID;
                        

                            
33
                            

                        

                            
34
                            
    void teach() {
                        

                            
35
                            
        std::cout << "Teacher is teaching." << std::endl;
                        

                            
36
                            
    }
                        

                            
37
                            
};
                        

                            
38
                            

                        

                            
39
                            
int main() {
                        

                            
40
                            
    Student student1;
                        

                            
41
                            
    student1.name = "Alice";
                        

                            
42
                            
    student1.age = 20;
                        

                            
43
                            
    student1.studentID = "2023001";
                        

                            
44
                            

                        

                            
45
                            
    std::cout << "Student name: " << student1.name << ", age: " << student1.age << ", ID: " << student1.studentID << std::endl;
                        

                            
46
                            
    student1.eat();  // 继承自 Person 类
                        

                            
47
                            
    student1.study(); // Student 类自身的方法
                        

                            
48
                            

                        

                            
49
                            
    Teacher teacher1;
                        

                            
50
                            
    teacher1.name = "Bob";
                        

                            
51
                            
    teacher1.age = 35;
                        

                            
52
                            
    teacher1.teacherID = "T001";
                        

                            
53
                            

                        

                            
54
                            
    std::cout << "Teacher name: " << teacher1.name << ", age: " << teacher1.age << ", ID: " << teacher1.teacherID << std::endl;
                        

                            
55
                            
    teacher1.sleep(); // 继承自 Person 类
                        

                            
56
                            
    teacher1.teach(); // Teacher 类自身的方法
                        

                            
57
                            

                        

                            
58
                            
    return 0;
                        

                            
59
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string>
                        

                            
3
                            

                        

                            
4
                            
// 基类 Animal
                        

                            
5
                            
class Animal {
                        

                            
6
                            
public:
                        

                            
7
                            
    // 虚函数 makeSound()
                        

                            
8
                            
    virtual void makeSound() {
                        

                            
9
                            
        std::cout << "Animal makes a sound." << std::endl;
                        

                            
10
                            
    }
                        

                            
11
                            
};
                        

                            
12
                            

                        

                            
13
                            
// 派生类 Dog，继承自 Animal
                        

                            
14
                            
class Dog : public Animal {
                        

                            
15
                            
public:
                        

                            
16
                            
    // 重写父类的虚函数 makeSound()
                        

                            
17
                            
    void makeSound() override {
                        

                            
18
                            
        std::cout << "Dog barks: Woof!" << std::endl;
                        

                            
19
                            
    }
                        

                            
20
                            
};
                        

                            
21
                            

                        

                            
22
                            
// 派生类 Cat，继承自 Animal
                        

                            
23
                            
class Cat : public Animal {
                        

                            
24
                            
public:
                        

                            
25
                            
    // 重写父类的虚函数 makeSound()
                        

                            
26
                            
    void makeSound() override {
                        

                            
27
                            
        std::cout << "Cat meows: Meow!" << std::endl;
                        

                            
28
                            
    }
                        

                            
29
                            
};
                        

                            
30
                            

                        

                            
31
                            
// 通用函数，接受 Animal 类型的指针
                        

                            
32
                            
void animalSound(Animal* animal) {
                        

                            
33
                            
    animal->makeSound(); // 调用虚函数 makeSound()，运行时动态绑定
                        

                            
34
                            
}
                        

                            
35
                            

                        

                            
36
                            
int main() {
                        

                            
37
                            
    Animal* animal1 = new Animal(); // 父类指针指向父类对象
                        

                            
38
                            
    Animal* animal2 = new Dog();    // 父类指针指向子类 Dog 对象 (向上转型)
                        

                            
39
                            
    Animal* animal3 = new Cat();    // 父类指针指向子类 Cat 对象 (向上转型)
                        

                            
40
                            

                        

                            
41
                            
    animalSound(animal1); // 调用 Animal::makeSound()
                        

                            
42
                            
    animalSound(animal2); // 调用 Dog::makeSound() (多态)
                        

                            
43
                            
    animalSound(animal3); // 调用 Cat::makeSound() (多态)
                        

                            
44
                            

                        

                            
45
                            
    delete animal1;
                        

                            
46
                            
    delete animal2;
                        

                            
47
                            
    delete animal3;
                        

                            
48
                            

                        

                            
49
                            
    return 0;
                        

                            
50
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
class Circle {
                        

                            
2
                            
public: // 公有访问修饰符
                        

                            
3
                            
    double radius; // 公有成员变量 - 半径
                        

                            
4
                            

                        

                            
5
                            
    double getArea() { // 公有成员函数 - 获取面积
                        

                            
6
                            
        return 3.14159 * radius * radius;
                        

                            
7
                            
    }
                        

                            
8
                            
};
                        

                            
9
                            

                        

                            
10
                            
int main() {
                        

                            
11
                            
    Circle myCircle;
                        

                            
12
                            
    myCircle.radius = 5.0; // 外部代码可以直接访问 public 成员 radius
                        

                            
13
                            
    double area = myCircle.getArea(); // 外部代码可以直接调用 public 成员函数 getArea()
                        

                            
14
                            
    return 0;
                        

                            
15
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
class BankAccount {
                        

                            
2
                            
private: // 私有访问修饰符
                        

                            
3
                            
    double balance; // 私有成员变量 - 账户余额
                        

                            
4
                            

                        

                            
5
                            
public:
                        

                            
6
                            
    BankAccount(double initialBalance) : balance(initialBalance) {}
                        

                            
7
                            

                        

                            
8
                            
    void deposit(double amount) {
                        

                            
9
                            
        if (amount > 0) {
                        

                            
10
                            
            balance += amount;
                        

                            
11
                            
        }
                        

                            
12
                            
    }
                        

                            
13
                            

                        

                            
14
                            
    void withdraw(double amount) {
                        

                            
15
                            
        if (amount > 0 && amount <= balance) {
                        

                            
16
                            
            balance -= amount;
                        

                            
17
                            
        }
                        

                            
18
                            
    }
                        

                            
19
                            

                        

                            
20
                            
    double getBalance() const { // 公有成员函数 - 获取余额
                        

                            
21
                            
        return balance; // 内部成员函数可以访问 private 成员 balance
                        

                            
22
                            
    }
                        

                            
23
                            
};
                        

                            
24
                            

                        

                            
25
                            
int main() {
                        

                            
26
                            
    BankAccount myAccount(100.0);
                        

                            
27
                            
    // myAccount.balance = 200.0; // 错误！外部代码不能直接访问 private 成员 balance
                        

                            
28
                            
    myAccount.deposit(50.0);
                        

                            
29
                            
    myAccount.withdraw(20.0);
                        

                            
30
                            
    double currentBalance = myAccount.getBalance(); // 通过公有成员函数 getBalance() 间接访问 private 成员
                        

                            
31
                            
    return 0;
                        

                            
32
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
class Animal {
                        

                            
2
                            
protected: // 保护访问修饰符
                        

                            
3
                            
    std::string name; // 保护成员变量 - 动物名称
                        

                            
4
                            

                        

                            
5
                            
public:
                        

                            
6
                            
    Animal(const std::string& animalName) : name(animalName) {}
                        

                            
7
                            

                        

                            
8
                            
    void eat() {
                        

                            
9
                            
        std::cout << name << " is eating." << std::endl;
                        

                            
10
                            
    }
                        

                            
11
                            
};
                        

                            
12
                            

                        

                            
13
                            
class Dog : public Animal { // Dog 类继承自 Animal 类
                        

                            
14
                            
public:
                        

                            
15
                            
    Dog(const std::string& dogName) : Animal(dogName) {}
                        

                            
16
                            

                        

                            
17
                            
    void bark() {
                        

                            
18
                            
        std::cout << name << " is barking." << std::endl; // 派生类 Dog 可以访问基类 Animal 的 protected 成员 name
                        

                            
19
                            
    }
                        

                            
20
                            
};
                        

                            
21
                            

                        

                            
22
                            
int main() {
                        

                            
23
                            
    Animal myAnimal("Generic Animal");
                        

                            
24
                            
    // std::cout << myAnimal.name; // 错误！外部代码不能直接访问 protected 成员 name
                        

                            
25
                            
    Dog myDog("Buddy");
                        

                            
26
                            
    // std::cout << myDog.name; // 错误！外部代码不能直接访问 protected 成员 name
                        

                            
27
                            
    myDog.eat(); // 调用基类 Animal 的 public 成员函数 eat()
                        

                            
28
                            
    myDog.bark(); // 调用派生类 Dog 的 public 成员函数 bark()
                        

                            
29
                            
    return 0;
                        

                            
30
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
class Rectangle {
                        

                            
2
                            
public:
                        

                            
3
                            
    double width;  // 公有成员变量 - 宽度
                        

                            
4
                            
    double height; // 公有成员变量 - 高度
                        

                            
5
                            

                        

                            
6
                            
private:
                        

                            
7
                            
    std::string name; // 私有成员变量 - 矩形名称
                        

                            
8
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class Circle {
                        

                            
2
                            
public:
                        

                            
3
                            
    double radius = 1.0; // 类内初始化，radius 默认值为 1.0
                        

                            
4
                            
    std::string color = "red"; // 类内初始化，color 默认值为 "red"
                        

                            
5
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class Point {
                        

                            
2
                            
public:
                        

                            
3
                            
    int x;
                        

                            
4
                            
    int y;
                        

                            
5
                            

                        

                            
6
                            
    Point() : x(0), y(0) { // 构造函数初始化列表，初始化 x 和 y
                        

                            
7
                            
        // 构造函数体，可以为空或包含其他逻辑
                        

                            
8
                            
    }
                        

                            
9
                            

                        

                            
10
                            
    Point(int xCoord, int yCoord) : x(xCoord), y(yCoord) { // 参数化构造函数，使用初始化列表
                        

                            
11
                            
        // 构造函数体
                        

                            
12
                            
    }
                        

                            
13
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class Line {
                        

                            
2
                            
public:
                        

                            
3
                            
    Point startPoint; // 类类型成员变量
                        

                            
4
                            
    Point endPoint;   // 类类型成员变量
                        

                            
5
                            

                        

                            
6
                            
    Line(int x1, int y1, int x2, int y2) {
                        

                            
7
                            
        startPoint = Point(x1, y1); // 构造函数体内赋值，效率较低
                        

                            
8
                            
        endPoint = Point(x2, y2);   // 构造函数体内赋值，效率较低
                        

                            
9
                            
    }
                        

                            
10
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class Counter {
                        

                            
2
                            
public:
                        

                            
3
                            
    static int count; // 静态成员变量声明
                        

                            
4
                            

                        

                            
5
                            
    Counter() {
                        

                            
6
                            
        count++;
                        

                            
7
                            
    }
                        

                            
8
                            
};
                        

                            
9
                            

                        

                            
10
                            
int Counter::count = 0; // 静态成员变量初始化，在类定义外部
                        

                            
11
                            

                        

                            
12
                            
int main() {
                        

                            
13
                            
    Counter c1;
                        

                            
14
                            
    Counter c2;
                        

                            
15
                            
    std::cout << "Counter count: " << Counter::count << std::endl; // 输出：Counter count: 2
                        

                            
16
                            
    return 0;
                        

                            
17
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
class ImmutableValue {
                        

                            
2
                            
public:
                        

                            
3
                            
    const int value; // 常量成员变量
                        

                            
4
                            

                        

                            
5
                            
    ImmutableValue(int val) : value(val) { // 在初始化列表中初始化常量成员变量
                        

                            
6
                            
        // value = 10; // 错误！常量成员变量在构造函数体内部不能被赋值
                        

                            
7
                            
    }
                        

                            
8
                            

                        

                            
9
                            
    int getValue() const {
                        

                            
10
                            
        return value;
                        

                            
11
                            
    }
                        

                            
12
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class Calculator {
                        

                            
2
                            
public:
                        

                            
3
                            
    int add(int a, int b);          // 公有成员函数声明 - 加法
                        

                            
4
                            
    double divide(double numerator, double denominator); // 公有成员函数声明 - 除法
                        

                            
5
                            

                        

                            
6
                            
private:
                        

                            
7
                            
    void logOperation(const std::string& operation); // 私有成员函数声明 - 记录操作日志
                        

                            
8
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class Square {
                        

                            
2
                            
public:
                        

                            
3
                            
    double side;
                        

                            
4
                            

                        

                            
5
                            
    double getArea() { // 类内定义 getArea() 函数
                        

                            
6
                            
        return side * side;
                        

                            
7
                            
    }
                        

                            
8
                            

                        

                            
9
                            
    double getPerimeter() { // 类内定义 getPerimeter() 函数
                        

                            
10
                            
        return 4 * side;
                        

                            
11
                            
    }
                        

                            
12
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class Circle {
                        

                            
2
                            
public:
                        

                            
3
                            
    double radius;
                        

                            
4
                            

                        

                            
5
                            
    double getArea();       // 类内声明 getArea() 函数
                        

                            
6
                            
    double getCircumference(); // 类内声明 getCircumference() 函数
                        

                            
7
                            
};
                        

                            
8
                            

                        

                            
9
                            
// 类外定义 getArea() 函数
                        

                            
10
                            
double Circle::getArea() {
                        

                            
11
                            
    return 3.14159 * radius * radius;
                        

                            
12
                            
}
                        

                            
13
                            

                        

                            
14
                            
// 类外定义 getCircumference() 函数
                        

                            
15
                            
double Circle::getCircumference() {
                        

                            
16
                            
    return 2 * 3.14159 * radius;
                        

                            
17
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
class Rectangle {
                        

                            
4
                            
public:
                        

                            
5
                            
    double width;
                        

                            
6
                            
    double height;
                        

                            
7
                            

                        

                            
8
                            
    Rectangle(double w, double h) : width(w), height(h) {
                        

                            
9
                            
        std::cout << "Rectangle object created on stack." << std::endl;
                        

                            
10
                            
    }
                        

                            
11
                            

                        

                            
12
                            
    ~Rectangle() {
                        

                            
13
                            
        std::cout << "Rectangle object destroyed from stack." << std::endl;
                        

                            
14
                            
    }
                        

                            
15
                            
};
                        

                            
16
                            

                        

                            
17
                            
int main() {
                        

                            
18
                            
    { // 引入一个代码块，限定作用域
                        

                            
19
                            
        Rectangle rect1(10.0, 5.0); // 在栈上创建 Rectangle 对象 rect1
                        

                            
20
                            
        std::cout << "Rectangle area: " << rect1.width * rect1.height << std::endl;
                        

                            
21
                            
    } // 代码块结束，rect1 对象超出作用域，自动销毁
                        

                            
22
                            

                        

                            
23
                            
    // 在 main 函数作用域创建 rect2
                        

                            
24
                            
    Rectangle rect2(20.0, 10.0); // 在栈上创建 Rectangle 对象 rect2
                        

                            
25
                            
    std::cout << "Rectangle area: " << rect2.width * rect2.height << std::endl;
                        

                            
26
                            

                        

                            
27
                            
    return 0; // main 函数结束，rect2 对象超出作用域，自动销毁
                        

                            
28
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
class Circle {
                        

                            
4
                            
public:
                        

                            
5
                            
    double radius;
                        

                            
6
                            

                        

                            
7
                            
    Circle(double r) : radius(r) {
                        

                            
8
                            
        std::cout << "Circle object created on heap." << std::endl;
                        

                            
9
                            
    }
                        

                            
10
                            

                        

                            
11
                            
    ~Circle() {
                        

                            
12
                            
        std::cout << "Circle object destroyed from heap." << std::endl;
                        

                            
13
                            
    }
                        

                            
14
                            
};
                        

                            
15
                            

                        

                            
16
                            
int main() {
                        

                            
17
                            
    Circle* circlePtr1 = new Circle(3.0); // 在堆上创建 Circle 对象，返回对象指针
                        

                            
18
                            
    std::cout << "Circle area: " << 3.14159 * circlePtr1->radius * circlePtr1->radius << std::endl;
                        

                            
19
                            

                        

                            
20
                            
    // ... 使用 circlePtr1 指向的对象 ...
                        

                            
21
                            

                        

                            
22
                            
    delete circlePtr1; // 手动释放 circlePtr1 指向的堆内存，调用析构函数
                        

                            
23
                            
    circlePtr1 = nullptr; // 良好的习惯：释放后将指针置为 nullptr，避免悬空指针
                        

                            
24
                            

                        

                            
25
                            
    Circle* circlePtr2 = new Circle(6.0);
                        

                            
26
                            
    std::cout << "Circle area: " << 3.14159 * circlePtr2->radius * circlePtr2->radius << std::endl;
                        

                            
27
                            

                        

                            
28
                            
    // ... 使用 circlePtr2 指向的对象 ...
                        

                            
29
                            

                        

                            
30
                            
    delete circlePtr2;
                        

                            
31
                            
    circlePtr2 = nullptr;
                        

                            
32
                            

                        

                            
33
                            
    return 0;
                        

                            
34
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string>
                        

                            
3
                            

                        

                            
4
                            
class Student {
                        

                            
5
                            
public:
                        

                            
6
                            
    std::string name;
                        

                            
7
                            
    int age;
                        

                            
8
                            

                        

                            
9
                            
    void study() {
                        

                            
10
                            
        std::cout << name << " is studying." << std::endl;
                        

                            
11
                            
    }
                        

                            
12
                            

                        

                            
13
                            
    void displayInfo() const {
                        

                            
14
                            
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
                        

                            
15
                            
    }
                        

                            
16
                            
};
                        

                            
17
                            

                        

                            
18
                            
int main() {
                        

                            
19
                            
    Student student1; // 在栈上创建 Student 对象 student1
                        

                            
20
                            
    student1.name = "Alice"; // 使用点运算符访问公有成员变量 name 并赋值
                        

                            
21
                            
    student1.age = 20;     // 使用点运算符访问公有成员变量 age 并赋值
                        

                            
22
                            
    student1.study();        // 使用点运算符调用公有成员函数 study()
                        

                            
23
                            
    student1.displayInfo();  // 使用点运算符调用公有成员函数 displayInfo()
                        

                            
24
                            

                        

                            
25
                            
    Student student2;
                        

                            
26
                            
    student2.name = "Bob";
                        

                            
27
                            
    student2.age = 22;
                        

                            
28
                            
    student2.displayInfo();
                        

                            
29
                            

                        

                            
30
                            
    return 0;
                        

                            
31
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string>
                        

                            
3
                            

                        

                            
4
                            
class Book {
                        

                            
5
                            
public:
                        

                            
6
                            
    std::string title;
                        

                            
7
                            
    std::string author;
                        

                            
8
                            

                        

                            
9
                            
    Book(const std::string& bookTitle, const std::string& bookAuthor) : title(bookTitle), author(bookAuthor) {}
                        

                            
10
                            

                        

                            
11
                            
    void printBookInfo() const {
                        

                            
12
                            
        std::cout << "Title: " << title << ", Author: " << author << std::endl;
                        

                            
13
                            
    }
                        

                            
14
                            
};
                        

                            
15
                            

                        

                            
16
                            
int main() {
                        

                            
17
                            
    Book* bookPtr = new Book("The C++ Programming Language", "Bjarne Stroustrup"); // 在堆上创建 Book 对象，bookPtr 指向对象
                        

                            
18
                            
    bookPtr->printBookInfo(); // 使用箭头运算符通过指针 bookPtr 访问公有成员函数 printBookInfo()
                        

                            
19
                            
    std::cout << "Book title: " << bookPtr->title << std::endl; // 使用箭头运算符访问公有成员变量 title
                        

                            
20
                            

                        

                            
21
                            
    delete bookPtr; // 释放堆内存
                        

                            
22
                            
    bookPtr = nullptr;
                        

                            
23
                            

                        

                            
24
                            
    return 0;
                        

                            
25
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
class Point {
                        

                            
2
                            
public:
                        

                            
3
                            
    int x;
                        

                            
4
                            
    int y;
                        

                            
5
                            

                        

                            
6
                            
    // 默认构造函数（无参数）
                        

                            
7
                            
    Point() : x(0), y(0) {
                        

                            
8
                            
        std::cout << "Default constructor called." << std::endl;
                        

                            
9
                            
    }
                        

                            
10
                            

                        

                            
11
                            
    // 默认构造函数（所有参数都有默认值）
                        

                            
12
                            
    Point(int xCoord = 0, int yCoord = 0) : x(xCoord), y(yCoord) {
                        

                            
13
                            
        std::cout << "Default constructor with default parameters called." << std::endl;
                        

                            
14
                            
    }
                        

                            
15
                            
};
                        

                            
16
                            

                        

                            
17
                            
int main() {
                        

                            
18
                            
    Point p1;      // 调用默认构造函数 Point()
                        

                            
19
                            
    Point p2();    // 注意：这不是创建对象，而是声明一个返回 Point 对象的函数 p2
                        

                            
20
                            
    Point p3{};    // C++11 列表初始化，调用默认构造函数 Point()
                        

                            
21
                            
    Point p4 = {}; // C++11 列表初始化，调用默认构造函数 Point()
                        

                            
22
                            
    Point p5(10);  // 调用默认构造函数 Point(int xCoord = 0, int yCoord = 0)，yCoord 使用默认值 0
                        

                            
23
                            
    Point p6();   // 注意：这不是创建对象，而是声明一个返回 Point 对象的函数 p6
                        

                            
24
                            

                        

                            
25
                            
    return 0;
                        

                            
26
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
class Rectangle {
                        

                            
2
                            
public:
                        

                            
3
                            
    double width;
                        

                            
4
                            
    double height;
                        

                            
5
                            

                        

                            
6
                            
    // 参数化构造函数，接受宽度和高度作为参数
                        

                            
7
                            
    Rectangle(double w, double h) : width(w), height(h) {
                        

                            
8
                            
        std::cout << "Parameterized constructor called." << std::endl;
                        

                            
9
                            
    }
                        

                            
10
                            

                        

                            
11
                            
    // 参数化构造函数重载，只接受边长作为参数，创建正方形
                        

                            
12
                            
    Rectangle(double side) : width(side), height(side) {
                        

                            
13
                            
        std::cout << "Overloaded parameterized constructor for square called." << std::endl;
                        

                            
14
                            
    }
                        

                            
15
                            
};
                        

                            
16
                            

                        

                            
17
                            
int main() {
                        

                            
18
                            
    Rectangle rect1(10.0, 5.0); // 调用 Rectangle(double w, double h)
                        

                            
19
                            
    Rectangle rect2(8.0);      // 调用 Rectangle(double side)
                        

                            
20
                            
    return 0;
                        

                            
21
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <cstring>
                        

                            
3
                            

                        

                            
4
                            
class String {
                        

                            
5
                            
private:
                        

                            
6
                            
    char* data; // 指向动态分配内存的指针
                        

                            
7
                            
    size_t length;
                        

                            
8
                            

                        

                            
9
                            
public:
                        

                            
10
                            
    // 构造函数
                        

                            
11
                            
    String(const char* str = "") {
                        

                            
12
                            
        length = std::strlen(str);
                        

                            
13
                            
        data = new char[length + 1]; // 动态分配内存
                        

                            
14
                            
        std::strcpy(data, str);
                        

                            
15
                            
        std::cout << "Constructor called." << std::endl;
                        

                            
16
                            
    }
                        

                            
17
                            

                        

                            
18
                            
    // 拷贝构造函数（深拷贝）
                        

                            
19
                            
    String(const String& other) {
                        

                            
20
                            
        length = other.length;
                        

                            
21
                            
        data = new char[length + 1]; // 为新对象重新动态分配内存
                        

                            
22
                            
        std::strcpy(data, other.data); // 复制字符串内容
                        

                            
23
                            
        std::cout << "Copy constructor called." << std::endl;
                        

                            
24
                            
    }
                        

                            
25
                            

                        

                            
26
                            
    // 析构函数
                        

                            
27
                            
    ~String() {
                        

                            
28
                            
        delete[] data; // 释放动态分配的内存
                        

                            
29
                            
        std::cout << "Destructor called." << std::endl;
                        

                            
30
                            
    }
                        

                            
31
                            

                        

                            
32
                            
    void print() const {
                        

                            
33
                            
        std::cout << data << std::endl;
                        

                            
34
                            
    }
                        

                            
35
                            
};
                        

                            
36
                            

                        

                            
37
                            
int main() {
                        

                            
38
                            
    String str1("Hello"); // 调用构造函数
                        

                            
39
                            
    String str2 = str1;   // 调用拷贝构造函数
                        

                            
40
                            
    String str3(str1);   // 调用拷贝构造函数
                        

                            
41
                            

                        

                            
42
                            
    str1.print();
                        

                            
43
                            
    str2.print();
                        

                            
44
                            
    str3.print();
                        

                            
45
                            

                        

                            
46
                            
    return 0;
                        

                            
47
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <cstring>
                        

                            
3
                            
#include <utility> // std::move
                        

                            
4
                            

                        

                            
5
                            
class Vector {
                        

                            
6
                            
private:
                        

                            
7
                            
    int* data;
                        

                            
8
                            
    size_t size;
                        

                            
9
                            
    size_t capacity;
                        

                            
10
                            

                        

                            
11
                            
public:
                        

                            
12
                            
    // 构造函数
                        

                            
13
                            
    Vector(size_t cap = 1) : size(0), capacity(cap) {
                        

                            
14
                            
        data = new int[capacity];
                        

                            
15
                            
        std::cout << "Constructor called." << std::endl;
                        

                            
16
                            
    }
                        

                            
17
                            

                        

                            
18
                            
    // 拷贝构造函数（深拷贝）
                        

                            
19
                            
    Vector(const Vector& other) : size(other.size), capacity(other.capacity) {
                        

                            
20
                            
        data = new int[capacity];
                        

                            
21
                            
        std::memcpy(data, other.data, size * sizeof(int));
                        

                            
22
                            
        std::cout << "Copy constructor called." << std::endl;
                        

                            
23
                            
    }
                        

                            
24
                            

                        

                            
25
                            
    // 移动构造函数（移动语义）
                        

                            
26
                            
    Vector(Vector&& other) noexcept : data(other.data), size(other.size), capacity(other.capacity) {
                        

                            
27
                            
        other.data = nullptr; // 将源对象的指针设为 nullptr，防止析构时重复释放
                        

                            
28
                            
        other.size = 0;
                        

                            
29
                            
        other.capacity = 0;
                        

                            
30
                            
        std::cout << "Move constructor called." << std::endl;
                        

                            
31
                            
    }
                        

                            
32
                            

                        

                            
33
                            
    // 析构函数
                        

                            
34
                            
    ~Vector() {
                        

                            
35
                            
        delete[] data;
                        

                            
36
                            
        std::cout << "Destructor called." << std::endl;
                        

                            
37
                            
    }
                        

                            
38
                            

                        

                            
39
                            
    void push_back(int value) {
                        

                            
40
                            
        if (size == capacity) {
                        

                            
41
                            
            capacity *= 2;
                        

                            
42
                            
            int* newData = new int[capacity];
                        

                            
43
                            
            std::memcpy(newData, data, size * sizeof(int));
                        

                            
44
                            
            delete[] data;
                        

                            
45
                            
            data = newData;
                        

                            
46
                            
        }
                        

                            
47
                            
        data[size++] = value;
                        

                            
48
                            
    }
                        

                            
49
                            

                        

                            
50
                            
    void print() const {
                        

                            
51
                            
        std::cout << "Vector: [";
                        

                            
52
                            
        for (size_t i = 0; i < size; ++i) {
                        

                            
53
                            
            std::cout << data[i] << (i == size - 1 ? "" : ", ");
                        

                            
54
                            
        }
                        

                            
55
                            
        std::cout << "]" << std::endl;
                        

                            
56
                            
    }
                        

                            
57
                            
};
                        

                            
58
                            

                        

                            
59
                            
Vector createVector() {
                        

                            
60
                            
    Vector v(3);
                        

                            
61
                            
    v.push_back(1);
                        

                            
62
                            
    v.push_back(2);
                        

                            
63
                            
    v.push_back(3);
                        

                            
64
                            
    return v; // 返回右值（临时对象），将调用移动构造函数
                        

                            
65
                            
}
                        

                            
66
                            

                        

                            
67
                            
int main() {
                        

                            
68
                            
    Vector v1;
                        

                            
69
                            
    v1.push_back(10);
                        

                            
70
                            
    v1.push_back(20);
                        

                            
71
                            

                        

                            
72
                            
    Vector v2 = v1; // 调用拷贝构造函数
                        

                            
73
                            

                        

                            
74
                            
    Vector v3 = createVector(); // 调用移动构造函数
                        

                            
75
                            

                        

                            
76
                            
    Vector v4 = std::move(v1); // 显式使用 std::move()，调用移动构造函数
                        

                            
77
                            

                        

                            
78
                            
    v2.print();
                        

                            
79
                            
    v3.print();
                        

                            
80
                            
    v4.print();
                        

                            
81
                            
    v1.print(); // v1 的资源已被移动走，打印为空 Vector
                        

                            
82
                            

                        

                            
83
                            
    return 0;
                        

                            
84
                            
}