C++: day7

**C++: Day7**

### **类和对象**

在 C++ 中，类是用来描述一个集合的属性和行为的蓝图。对象则是根据这个蓝图创建出来的实体。

#### **类定义**

cppclass Person {
public:
 string name;
 int age;

 void sayHello() {
 cout << "Hello, my name is " << name << " and I'm " << age << " years old." << endl;
 }
};

在这个例子中，我们定义了一个名为 `Person` 的类，它有两个属性：`name` 和 `age`，以及一个方法 `sayHello()`。

#### **对象创建**

cppint main() {
 Person person1, person2;

 person1.name = "John";
 person1.age =30;

 person2.name = "Alice";
 person2.age =25;

 person1.sayHello();
 person2.sayHello();

 return0;
}

在这个例子中，我们创建了两个 `Person` 对象：`person1` 和 `person2`。我们为每个对象赋值属性，然后调用 `sayHello()` 方法。

### **构造函数**

构造函数是用于初始化类成员的特殊方法。它的名字与类名相同，且没有返回类型（即使是 `void`）。

#### **默认构造函数**

cppclass Person {
public:
 string name;
 int age;

 Person() {
 name = "Unknown";
 age =0;
 }
};

在这个例子中，我们定义了一个默认构造函数，它会将 `name` 和 `age` 初始化为 `"Unknown"` 和 `0`。

#### **参数化构造函数**

cppclass Person {
public:
 string name;
 int age;

 Person(string n, int a) {
 name = n;
 age = a;
 }
};

在这个例子中，我们定义了一个参数化构造函数，它会将 `name` 和 `age` 初始化为传入的值。

### **拷贝构造函数**

拷贝构造函数是用于创建一个类对象的副本的特殊方法。它的名字与类名相同，且没有返回类型（即使是 `void`）。

cppclass Person {
public:
 string name;
 int age;

 Person(const Person& p) {
 name = p.name;
 age = p.age;
 }
};

在这个例子中，我们定义了一个拷贝构造函数，它会将 `name` 和 `age` 初始化为传入对象的值。

### **赋值运算符**

赋值运算符是用于将一个类对象的属性复制到另一个类对象的特殊方法。它的名字与类名相同，且没有返回类型（即使是 `void`）。

cppclass Person {
public:
 string name;
 int age;

 void operator=(const Person& p) {
 name = p.name;
 age = p.age;
 }
};

在这个例子中，我们定义了一个赋值运算符，它会将 `name` 和 `age` 初始化为传入对象的值。

### **析构函数**

析构函数是用于释放类成员资源的特殊方法。它的名字与类名相同，且没有返回类型（即使是 `void`）。

cppclass Person {
public:
 string name;
 int age;

 ~Person() {
 cout << "Person object destroyed." << endl;
 }
};

在这个例子中，我们定义了一个析构函数，它会输出一条消息指示对象被销毁。

### **友元类**

友元类是可以访问另一个类的私有成员的特殊类。它通过使用 `friend` 关键字来声明。

cppclass Person {
public:
 string name;
 int age;

 friend class FriendClass;
};

class FriendClass {
public:
 void printPerson(const Person& p) {
 cout << "Name: " << p.name << ", Age: " << p.age << endl;
 }
};

在这个例子中，我们定义了一个 `FriendClass`，它可以访问 `Person` 类的私有成员。

### **友元函数**

友元函数是可以访问另一个类的私有成员的特殊函数。它通过使用 `friend` 关键字来声明。

cppclass Person {
public:
 string name;
 int age;

 friend void printPerson(const Person& p) {
 cout << "Name: " << p.name << ", Age: " << p.age << endl;
 }
};

在这个例子中，我们定义了一个友元函数 `printPerson()`，它可以访问 `Person` 类的私有成员。

### **多重继承**

多重继承是指一个类可以从多个基类继承属性和行为。它通过使用 `:` 来声明。

cppclass Person {
public:
 string name;
 int age;

 void sayHello() {
 cout << "Hello, my name is " << name << " and I'm " << age << " years old." << endl;
 }
};

class Student : public Person {
public:
 string major;

 void printInfo() {
 cout << "Name: " << name << ", Age: " << age << ", Major: " << major << endl;
 }
};

在这个例子中，我们定义了一个 `Student` 类，它从 `Person` 类继承属性和行为。

### **虚函数**

虚函数是可以重载的特殊函数。它通过使用 `virtual` 关键字来声明。

cppclass Person {
public:
 virtual void sayHello() {
 cout << "Hello, my name is " << name << " and I'm " << age << " years old." << endl;
 }
};

在这个例子中，我们定义了一个虚函数 `sayHello()`，它可以被重载。

### **纯虚函数**

纯虚函数是不能实现的特殊函数。它通过使用 `=0` 来声明。

cppclass Person {
public:
 virtual void sayHello() =0;
};

在这个例子中，我们定义了一个纯虚函数 `sayHello()`，它必须被重载。

### **抽象类**

抽象类是不能实例化的特殊类。它通过使用 `abstract` 关键字来声明。

cppclass Person {
public:
 abstract void sayHello();
};

在这个例子中，我们定义了一个抽象类 `Person`，它不能被实例化。

### **接口**

接口是不能实现的特殊类。它通过使用 `interface` 关键字来声明。

cppclass Person {
public:
 interface void sayHello();
};

在这个例子中，我们定义了一个接口 `Person`，它不能被实例化。

### **多态**

多态是指一个函数或方法可以有多个不同的实现。它通过使用虚函数和重载来实现。

cppclass Person {
public:
 virtual void sayHello() {
 cout << "Hello, my name is " << name << " and I'm " << age << " years old." << endl;
 }
};

class Student : public Person {
public:
 void sayHello() override {
 cout << "Hello, my name is " << name << " and I'm a student." << endl;
 }
};

在这个例子中，我们定义了一个 `Student` 类，它重载了 `sayHello()` 函数。

### **动态多态**

动态多态是指一个函数或方法可以有多个不同的实现，且这些实现是在运行时决定的。它通过使用虚函数和重载来实现。

cppclass Person {
public:
 virtual void sayHello() {
 cout << "Hello, my name is " << name << " and I'm " << age << " years old." << endl;
 }
};

class Student : public Person {
public:
 void sayHello() override {
 cout << "Hello, my name is " << name << " and I'm a student." << endl;
 }
};

在这个例子中，我们定义了一个 `Student` 类，它重载了 `sayHello()` 函数。

### **模板**

模板是指可以使用不同的类型来实现的特殊类或函数。它通过使用 `template` 关键字来声明。

cpptemplate <typename T>
class Person {
public:
 void sayHello() {
 cout << "Hello, my name is " << name << " and I'm " << age << " years old." << endl;
 }
};

在这个例子中，我们定义了一个模板类 `Person`，它可以使用不同的类型来实现。

### **泛型**

泛型是指可以使用不同的类型来实现的特殊类或函数。它通过使用 `typename` 关键字来声明。

cpptemplate <typename T>
class Person {
public:
 void sayHello() {
 cout << "Hello, my name is " << name << " and I'm " << age << " years