目录
总结
一、引言
C++是一种面向对象的编程语言，其核心概念是类和对象。类是对现实世界中具有共同特征的事物的抽象描述，而对象则是类的具体实例。通过类和对象，C++实现了数据抽象、封装、继承和多态等特性，使得代码更加模块化、可重用和易于维护。
二、类的定义
类是一种用户自定义的数据类型，用于描述具有相同属性和行为的对象的集合。类由成员变量（属性）和成员函数（方法）组成。成员变量用于存储对象的状态信息，而成员函数则用于实现对象的行为。
类的定义通常使用class关键字，后面跟类名，以及一对大括号{}。在大括号内部，可以定义类的成员变量和成员函数。成员变量可以是任何数据类型，包括基本数据类型、指针、数组、引用等。成员函数可以是普通函数、构造函数、析构函数、拷贝构造函数、赋值运算符重载函数等。
三、对象的创建与初始化
对象是类的具体实例，具有类的所有属性和行为。在C++中，可以通过类名和对象名来创建对象，并使用构造函数进行初始化。构造函数是一种特殊的成员函数，用于在创建对象时初始化对象的状态。
除了使用构造函数进行初始化外，还可以使用初始化列表来初始化成员变量。初始化列表在构造函数体之前执行，并且按照成员变量在类中声明的顺序进行初始化。
四、访问控制
C++提供了三种访问控制修饰符：public、protected和private。这些修饰符用于控制类成员的访问权限。public成员可以在任何地方被访问，protected成员只能在类的成员函数和派生类中被访问，而private成员只能在类的成员函数中被访问。
五、封装
封装是面向对象编程的一个重要特性，它通过将数据和操作封装到一个类中来实现。封装可以隐藏对象的内部实现细节，只暴露必要的接口给外部使用。这有助于提高代码的安全性和可维护性。
在C++中，可以通过将成员变量设置为private或protected来实现封装。然后，通过提供公共的成员函数（如getter和setter函数）来访问和修改这些成员变量的值。
六、继承
继承是面向对象编程的另一个重要特性，它允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和行为。通过继承，子类可以重用父类的代码，并实现自己的特定功能。
在C++中，继承通过冒号（:）和访问修饰符（通常是public）来表示。子类可以访问父类的public和protected成员，但不能直接访问private成员。子类可以添加新的成员变量和成员函数，也可以重写父类的成员函数（通过函数覆盖）。
七、多态
多态是面向对象编程的又一重要特性，它允许不同的对象对同一消息做出不同的响应。在C++中，多态通过虚函数和纯虚函数来实现。虚函数是一种可以在派生类中被重写的函数，而纯虚函数则是一种没有实现的虚函数。
通过多态性，我们可以实现代码的灵活性和可扩展性。例如，我们可以定义一个基类指针或引用，然后将其指向不同的派生类对象。当调用基类指针或引用所指向的对象的成员函数时，将根据对象的实际类型来调用相应的函数版本（即动态绑定）。
八、其他特性
除了上述特性外，C++类和对象还支持其他一些特性，如友元函数、静态成员、运算符重载等。这些特性进一步丰富了C++面向对象编程的表达能力。
九、总结
C++类和对象是面向对象编程的核心概念之一。通过类和对象，我们可以实现数据抽象、封装、继承和多态等特性，从而编写出更加模块化、可重用和易于维护的代码。在实际开发中，我们应该充分利用这些特性来提高代码的质量和效率。
C++类的定义
C++中的类（Class）是面向对象编程（OOP）的核心概念之一。类是对一组具有相同属性和行为的对象的抽象描述。下面是一个简单的C++类的定义示例：
cpp
#include <iostream>
#include <string>
// 定义一个名为Person的类
class Person {
public: // 公共访问修饰符
// 构造函数
Person(const std::string& name, int age)
: name_(name), age_(age) {}
// 析构函数（如果需要的话）
~Person() {}
// 成员函数（方法）
void display() const {
std::cout << "Name: " << name_ << ", Age: " << age_ << std::endl;
}
// 获取器（getter）
std::string getName() const {
return name_;
}
// 设置器（setter）
void setAge(int age) {
if (age >= 0) { // 假设年龄不能是负数
age_ = age;
}
}
private: // 私有访问修饰符
// 成员变量（属性）
std::string name_; // 名字
int age_; // 年龄
};
int main() {
// 创建Person类的对象
Person person("Alice", 30);
// 调用成员函数
person.display(); // 输出：Name: Alice, Age: 30
// 调用设置器修改对象的属性
person.setAge(31);
// 再次调用成员函数查看修改后的结果
person.display(); // 输出：Name: Alice, Age: 31
return 0;
}在上面的例子中，我们定义了一个名为Person的类，它包含：
公共部分（public）：这部分包含类的成员函数和可以被外部访问的成员变量（尽管在良好的实践中，成员变量通常被声明为私有的）。在这个例子中，我们有一个构造函数、一个析构函数（尽管在这个简单的例子中它并未做实际的工作）、一个display成员函数用于显示人的信息，以及两个getter和setter函数用于访问和修改年龄。
私有部分（private）：这部分包含类的私有成员变量。在这个例子中，我们有两个私有成员变量：name_和age_，它们分别用于存储人的名字和年龄。
类的成员函数（如构造函数、析构函数、display、getName和setAge）定义了类的对象可以执行的操作。成员变量（如name_和age_）则存储了对象的状态信息。
在main函数中，我们创建了一个Person类的对象person，并通过调用其成员函数来操作该对象。注意，由于name_成员变量是私有的，我们不能直接访问它，但可以通过getName成员函数来获取它的值。类似地，我们不能直接设置age_的值，但可以通过setAge成员函数来修改它。这种封装机制使得我们可以更好地控制对对象内部状态的访问和修改，从而提高了代码的安全性和可维护性。
C++对象的创建和初始化
在C++中，对象的创建和初始化是通过构造函数（constructor）来完成的。构造函数是一种特殊的成员函数，它用于初始化类的对象。当创建类的对象时，构造函数会自动被调用。
下面是一个关于C++对象创建和初始化的例子：
cpp
#include <iostream>
#include <string>
// 定义一个名为Person的类
class Person {
public:
// 构造函数
Person(const std::string& name, int age)
: name_(name), age_(age) // 初始化列表
{
// 构造函数的函数体（这里为空）
}
// 成员函数（方法）
void display() const {
std::cout << "Name: " << name_ << ", Age: " << age_ << std::endl;
}
private:
std::string name_; // 名字
int age_; // 年龄
};
int main() {
// 对象的创建和初始化
// 使用构造函数直接初始化
Person person1("Alice", 30);
// 使用大括号列表（C++11及以后版本）初始化
Person person2{"Bob", 25};
// 调用成员函数
person1.display(); // 输出：Name: Alice, Age: 30
person2.display(); // 输出：Name: Bob, Age: 25
// 注意：如果没有提供构造函数，编译器会生成一个默认的构造函数
// 但这个默认构造函数不会执行任何初始化操作（对于内置类型），对于类类型成员会调用其默认构造函数
return 0;
}在上面的例子中，Person类有一个构造函数，它接受两个参数：name和age。这两个参数被用于初始化对象的name_和age_成员变量。
在main函数中，我们创建了两个Person对象：person1和person2。这两个对象在创建时都调用了构造函数，并传递了相应的参数来初始化它们的状态。
注意，构造函数的名字必须与类名相同，并且没有返回类型（包括void）。此外，构造函数可以有多个重载版本（参数列表不同），以支持不同的初始化方式。
另外，C++11及以后的版本支持使用大括号列表（{}）进行列表初始化。这提供了一种更加直观和一致的方式来初始化对象，尤其是当涉及到聚合类型（如数组和结构体）时。在上面的例子中，person2就是使用大括号列表进行初始化的。
C++类的访问控制
在C++中，类的访问控制是一个重要的特性，它允许程序员定义类的成员（包括成员函数和成员变量）的可见性和可访问性。这通过三种访问控制修饰符来实现：public、protected 和 private。
访问控制修饰符
public：使用public修饰符定义的成员可以在任何地方被访问，包括类的内部、类的派生类以及类的对象。
protected：使用protected修饰符定义的成员在类的内部和派生类内部可以被访问，但在类的对象上则不可访问。
private：使用private修饰符定义的成员只能在类的内部被访问，类的派生类和类的对象都无法直接访问它们。
示例下面是一个简单的C++类示例，展示了如何使用这些访问控制修饰符：
cpp
#include <iostream>
class MyClass {
public:
// 公有成员函数，可以在任何地方被访问
void publicFunction() {
std::cout << "This is a public function.\n";
// 可以在这里访问公有和保护的成员
// 但不能访问私有的成员
}
// 公有成员变量，可以在任何地方被访问（但通常不推荐公有数据成员）
int publicVar;
protected:
// 保护成员函数，可以在类的内部和派生类内部被访问
void protectedFunction() {
std::cout << "This is a protected function.\n";
}
// 保护成员变量，可以在类的内部和派生类内部被访问
int protectedVar;
private:
// 私有成员函数，只能在类的内部被访问
void privateFunction() {
std::cout << "This is a private function.\n";
}
// 私有成员变量，只能在类的内部被访问
int privateVar;
};
int main() {
MyClass obj;
// 可以访问公有成员
obj.publicFunction(); // 正确
obj.publicVar = 10; // 正确
// 无法直接访问保护和私有成员
// obj.protectedFunction(); // 错误
// obj.protectedVar = 20; // 错误
// obj.privateFunction(); // 错误
// obj.privateVar = 30; // 错误
return 0;
}类的封装性
通过合理地使用访问控制修饰符，可以实现类的封装性。封装性是一种将类的数据和操作数据的方法（即成员函数）组合在一起，作为一个独立的单元。封装性可以隐藏类的实现细节，只暴露必要的接口给外部使用，从而保护类的数据不被非法访问和修改。
在C++中，通常将类的成员变量设置为private或protected，并通过public成员函数（也称为接口）来访问和修改这些成员变量。这样可以确保类的数据只能通过特定的方式进行访问和修改，从而增加了代码的安全性和可维护性。