C++ 支持哪些面向对象特性？

C++ 是一种支持面向对象编程（OOP）的语言，它提供了丰富的面向对象特性，使得开发者能够以类和对象为核心来组织代码。以下是 C++ 支持的主要面向对象特性：
一、类（Class）
类是 C++ 中面向对象的核心概念，它是一种用户自定义的数据类型，用于封装数据和操作数据的函数。类可以包含成员变量（属性）和成员函数（方法），并通过构造函数和析构函数管理对象的生命周期。
（一）定义类
cpp
复制
class MyClass {
public:

int value; // 成员变量

void setValue(int v) { // 成员函数
    value = v;
}

int getValue() const {
    return value;
}

};
（二）构造函数和析构函数
构造函数用于初始化对象，析构函数用于清理对象占用的资源。
cpp
复制
class MyClass {
public:

MyClass() : value(0) { // 默认构造函数
    std::cout << "Object created with value 0" << std::endl;
}

MyClass(int v) : value(v) { // 带参数的构造函数
    std::cout << "Object created with value " << v << std::endl;
}

~MyClass() { // 析构函数
    std::cout << "Object destroyed" << std::endl;
}

private:

int value;

};
二、封装（Encapsulation）
封装是指将类的成员变量和成员函数封装在一起，隐藏类的内部实现细节，只通过类的接口（公共成员函数）对外提供服务。封装可以保护数据的安全性和完整性，防止外部代码直接访问类的内部数据。
（一）访问控制
C++ 提供了三种访问控制级别：
public：公开成员，可以在类的外部访问。
private：私有成员，只能在类的内部访问。
protected：受保护成员，可以在类的内部和派生类中访问。
cpp
复制
class MyClass {
public:

void setValue(int v) {
    value = v; // 可以访问 private 成员
}

int getValue() const {
    return value;
}

private:

int value; // 私有成员变量

};
（二）封装的好处
数据隐藏：保护类的内部数据，防止外部代码直接修改。
接口清晰：通过公共成员函数提供清晰的接口，方便外部代码使用。
易于维护：隐藏内部实现细节，便于修改和扩展。
三、继承（Inheritance）
继承是指一个类（派生类）可以继承另一个类（基类）的属性和方法。通过继承，派生类可以复用基类的代码，同时还可以添加新的属性和方法或覆盖基类的方法。
（一）单继承
C++ 支持单继承，即一个派生类只能继承一个基类。
cpp
复制
class Base {
public:

void baseFunction() {
    std::cout << "Base function" << std::endl;
}

};

class Derived : public Base {
public:

void derivedFunction() {
    std::cout << "Derived function" << std::endl;
}

};

int main() {

Derived obj;
obj.baseFunction(); // 继承自 Base
obj.derivedFunction(); // 自己的函数
return 0;

}
（二）继承方式
C++ 提供了三种继承方式：
public 继承：派生类继承基类的公共和保护成员，派生类对象可以访问基类的公共成员。
protected 继承：派生类继承基类的公共和保护成员，但这些成员在派生类中变为保护成员。
private 继承：派生类继承基类的所有成员，但这些成员在派生类中变为私有成员。
（三）构造函数和析构函数的调用顺序
构造函数的调用顺序：先调用基类的构造函数，再调用派生类的构造函数。
析构函数的调用顺序：先调用派生类的析构函数，再调用基类的析构函数。
四、多态（Polymorphism）
多态是指同一个接口可以被不同的实例所实现，调用时根据对象的实际类型动态选择执行的方法。C++ 支持两种多态：编译时多态（重载）和运行时多态（虚函数）。
（一）编译时多态
编译时多态主要通过函数重载和运算符重载实现。
函数重载
cpp
复制
void print(int value) {

std::cout << "Integer: " << value << std::endl;

}

void print(double value) {

std::cout << "Double: " << value << std::endl;

}

int main() {

print(10); // 调用 int 版本
print(3.14); // 调用 double 版本
return 0;

}
运算符重载
cpp
复制
class MyClass {
public:

MyClass(int v) : value(v) {}

MyClass operator+(const MyClass& other) const {
    return MyClass(value + other.value);
}

private:

int value;

};

int main() {

MyClass a(5), b(3);
MyClass c = a + b; // 调用重载的 + 运算符
return 0;

}
（二）运行时多态
运行时多态通过虚函数实现。虚函数允许派生类覆盖基类的函数，并在运行时根据对象的实际类型调用相应的函数。
cpp
复制
class Base {
public:

virtual void show() {
    std::cout << "Base show" << std::endl;
}

};

class Derived : public Base {
public:

void show() override {
    std::cout << "Derived show" << std::endl;
}

};

int main() {

Base* ptr = new Derived();
ptr->show(); // 输出：Derived show
delete ptr;
return 0;

}
（三）纯虚函数与抽象类
纯虚函数是一种特殊的虚函数，它没有实现，只能在派生类中被覆盖。包含纯虚函数的类称为抽象类，不能直接实例化。
cpp
复制
class AbstractClass {
public:

virtual void pureVirtualFunction() = 0; // 纯虚函数

};

class Derived : public AbstractClass {
public:

void pureVirtualFunction() override {
    std::cout << "Derived pureVirtualFunction" << std::endl;
}

};

int main() {

Derived obj;
obj.pureVirtualFunction(); // 输出：Derived pureVirtualFunction
return 0;

}
五、C++ 面向对象的高级特性
（一）友元（Friend）
友元是一种特殊的机制，允许一个类或函数访问另一个类的私有或保护成员。
cpp
复制
class MyClass {

friend class FriendClass; // 声明友元类

private:

int value;

};

class FriendClass {
public:

void print(MyClass& obj) {
    std::cout << "Value: " << obj.value << std::endl; // 可以访问私有成员
}

};
（二）静态成员
静态成员属于类本身，而不是类的某个对象。静态成员变量需要在类外初始化，静态成员函数可以直接访问静态成员变量。
cpp
复制
class MyClass {
public:

static int count; // 静态成员变量

MyClass() {
    count++;
}

static void printCount() {
    std::cout << "Count: " << count << std::endl;
}

};

int MyClass::count = 0; // 静态成员变量初始化

int main() {

MyClass obj1;
MyClass obj2;
MyClass::printCount(); // 输出：Count: 2
return 0;

}
（三）内联函数
内联函数是一种优化机制，通过在编译时将函数体直接插入到调用点，减少函数调用的开销。
cpp
复制
inline int add(int a, int b) {

return a + b;

}
（四）构造函数列表初始化
C++11 引入了构造函数列表初始化（也称为统一初始化），允许使用花括号 {} 初始化类的成员变量。
cpp
复制
class MyClass {
public:

MyClass(int v) : value{v} {} // 构造函数列表初始化

private:

int value;

};
六、总结
C++ 提供了丰富的面向对象特性，包括类、封装、继承、多态等。这些特性使得 C++ 成为一种功能强大的面向对象编程语言，能够支持复杂的软件开发需求。通过合理使用这些特性，开发者可以编写出结构清晰、可维护性强且高效的代码。