在C++编程语言中，类和对象是面向对象编程（OOP）的核心概念。类定义了一种对象的类型，它描述了该类型对象所应具有的属性和行为；而对象则是根据类创建的具体实例。通过类和对象，C++程序员能够构建出模块化、可重用的代码，提高软件开发的效率和质量。
一、类的定义
在C++中，类是通过class关键字定义的。一个类可以包含数据成员（属性）和成员函数（方法）。数据成员存储与对象相关联的数据，而成员函数则定义了对象的行为。
class MyClass { public: // 数据成员（属性） int myData; // 成员函数（方法） MyClass(int value) : myData(value) {} // 构造函数 void display() const { std::cout << "Data: " << myData << std::endl; } // ... 其他成员函数 };
二、对象的创建与使用
通过类定义，我们可以创建该类的对象。对象的创建是通过类名后跟一对圆括号（对于带有参数的构造函数）或不带圆括号（对于默认构造函数）来完成的。
int main() { // 创建对象 MyClass obj1(10); // 使用带参数的构造函数 MyClass obj2; // 使用默认构造函数（如果定义了） // 使用对象 obj1.display(); // 输出：Data: 10 obj2.myData = 20; // 直接访问对象的数据成员 obj2.display(); // 输出：Data（假设默认构造函数初始化为0）：Data: 20 return 0; }
三、访问控制
C++中的类支持三种访问控制修饰符：public、protected和private。public成员可以在任何地方被访问；protected成员在派生类（即子类）中可以被访问，但在类外部不可直接访问；private成员仅能在类内部被访问。
class AccessControl { private: int privateData; protected: int protectedData; public: int publicData; // ... 成员函数 };
四、继承
C++支持单继承和多继承。通过继承，一个类（派生类）可以获取另一个类（基类）的属性和行为。这提供了一种代码重用和扩展的方式。
class Base { public: void baseFunc() { std::cout << "Base function." << std::endl; } }; class Derived : public Base { // 继承自Base类 public: void derivedFunc() { std::cout << "Derived function." << std::endl; } }; int main() { Derived obj; obj.baseFunc(); // 调用基类函数 obj.derivedFunc(); // 调用派生类函数 return 0; }
五、多态性
多态性是面向对象编程的三大特性之一，它允许使用父类类型的指针或引用来指向子类对象，并通过该指针或引用来调用子类中重写的虚函数。这实现了运行时动态绑定，增强了程序的灵活性和可扩展性。
class Shape { public: virtual void draw() const { std::cout << "Drawing a generic shape." << std::endl; } virtual ~Shape() {} // 虚析构函数 }; class Circle : public Shape { public: void draw() const override { std::cout << "Drawing a circle." << std::endl; } }; void drawShapes(Shape* shapes[], int n) { for (int i = 0; i < n; ++i) { shapes[i]->draw(); // 动态绑定到正确的draw()函数 } } int main() { Shape* shapes[2] = {new Circle(), new Shape()}; drawShapes(shapes, 2); // 输出：Drawing a circle. 和 Drawing a generic shape. // ... 释放内存 return 0; }
六、封装
封装是面向对象编程的四大基本特性之一（另外三个是继承、多态和抽象）。封装的主要目的是保护对象的内部状态（属性），同时提供公共接口（方法）来访问或修改这些状态。封装隐藏了类的内部实现细节，只允许通过对象的方法对数据进行访问和操作，从而提高了数据的安全性和代码的可维护性。
在C++中，封装主要通过类的访问控制修饰符（public、protected和private）来实现。private成员只能在类内部被访问，而public成员则可以在任何地方被访问。protected成员在类内部和派生类中可以访问，但在类外部不可直接访问。
class EncapsulatedClass { private: int privateMember; // 私有成员，只能在类内部访问 public: EncapsulatedClass(int value) : privateMember(value) {} // 构造函数，初始化私有成员 // 公共接口，用于访问或修改私有成员 int getPrivateMember() const { return privateMember; } void setPrivateMember(int value) { privateMember = value; } }; int main() { EncapsulatedClass obj(10); // 创建对象，通过构造函数初始化私有成员 std::cout << obj.getPrivateMember() << std::endl; // 访问私有成员，输出：10 obj.setPrivateMember(20); // 修改私有成员 std::cout << obj.getPrivateMember() << std::endl; // 访问私有成员，输出：20 return 0; }
七、友元
在C++中，有时需要让某个类或函数能够访问另一个类的私有或保护成员。为此，可以使用友元（friend）声明。被声明为友元的类或函数可以访问该类的所有成员，包括私有和保护成员。
class MyClass { private: int secretData; public: MyClass(int data) : secretData(data) {} // 声明另一个类为友元 friend class FriendClass; // 声明一个函数为友元 friend void friendFunction(MyClass& obj); }; class FriendClass { public: void displaySecret(const MyClass& obj) { std::cout << "Secret data: " << obj.secretData << std::endl; // 可以访问私有成员 } }; void friendFunction(MyClass& obj) { std::cout << "Secret data: " << obj.secretData << std::endl; // 可以访问私有成员 } int main() { MyClass obj(42); FriendClass friendObj; friendObj.displaySecret(obj); // 输出：Secret data: 42 friendFunction(obj); // 输出：Secret data: 42 return 0; }
八、构造函数与析构函数
构造函数用于初始化对象的状态，它在创建对象时自动调用。析构函数用于释放对象所使用的资源，它在对象生命周期结束时自动调用。C++支持多种类型的构造函数，包括默认构造函数、带参数的构造函数、拷贝构造函数和移动构造函数。
class MyClass { private: int* data; public: // 默认构造函数 MyClass() : data(nullptr) {} // 带参数的构造函数 MyClass(int value) : data(new int(value)) {} // 拷贝构造函数 MyClass(const MyClass& other) : data(new int(*other.data)) {} // 移动构造函数（C++11及以后） MyClass(MyClass&& other) noexcept : data(other.data) { other.data = nullptr; } // 析构函数 ~MyClass() { delete data; // 释放内存 } // ... 其他成员函数 };
九、运算符重载
C++允许程序员重新定义或重载大部分内置运算符，以便它们能用于自定义类型。通过运算符重载，可以使自定义类型的使用更加自然和直观。
class Complex { private: double real, imag; public: // ... 构造函数、析构函数和其他成员函数 // 运算符重载：+ Complex operator+(const Complex& other) const { return Complex(real + other.real, imag + other.imag); } // ... 其他运算符重载，如-、*、/、==等 }; int main() { Complex c1(
Complex c1(1.0, 2.0); Complex c2(3.0, 4.0); Complex c3 = c1 + c2; // 使用重载的+运算符 std::cout << "c3 = " << c3.real << " + " << c3.imag << "i" << std::endl; // 输出：c3 = 4 + 6i return 0; }
十、继承
继承是面向对象编程中的一个重要概念，它允许我们定义一个类（称为基类或父类）作为另一个类（称为派生类或子类）的基础，从而创建一个类层次结构。派生类继承基类的所有公共和保护成员，并可以添加自己的新成员。
class Base { public: void display() { std::cout << "This is the base class." << std::endl; } }; class Derived : public Base { // 继承自Base类 public: void anotherDisplay() { std::cout << "This is the derived class." << std::endl; } }; int main() { Derived obj; // 创建Derived类的对象 obj.display(); // 调用继承自Base类的display方法 obj.anotherDisplay(); // 调用Derived类自己的anotherDisplay方法 return 0; }
十一、多态
多态是面向对象编程中的一个重要概念，它允许使用父类类型的引用或指针来调用子类的方法。在运行时，程序将根据实际对象的类型来决定调用哪个方法，从而实现不同的行为。这主要通过虚函数和纯虚函数来实现。
class Shape { public: virtual void draw() { // 虚函数 std::cout << "Drawing a generic shape." << std::endl; } }; class Circle : public Shape { public: void draw() override { // 重写虚函数 std::cout << "Drawing a circle." << std::endl; } }; int main() { Shape* shapePtr; // 指向Shape的指针 Circle circle; // Circle类的对象 shapePtr = &circle; // 让指针指向Circle对象 shapePtr->draw(); // 调用Circle类的draw方法，因为shapePtr实际指向的是Circle对象 return 0; }
在上面的例子中，draw方法在Shape类中被声明为virtual，这意味着它可以在派生类中被重写。在main函数中，我们通过指向Shape的指针shapePtr调用了draw方法，但由于shapePtr实际上指向的是Circle对象，所以调用的是Circle类的draw方法，这就是多态的体现。
注意：多态的实现需要满足一定的条件，包括存在继承关系、基类中有虚函数、通过基类指针或引用调用虚函数等。
