本文深入介绍了C++面向对象编程，包括面向对象的基本概念、类和对象的定义与使用、封装与继承等核心特性。文章详细讲解了如何在C++中实现类与对象、封装、继承和多态，以及构造函数和析构函数的作用与使用。

C++面向对象基本概念

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它基于“对象”的概念。对象是数据和操作数据的方法的封装体。面向对象编程的核心思想是将现实世界中的事物抽象为类（Class）和对象（Object）。类是对一组具有相同属性和行为的对象的定义，而对象则是类的实例。这种范式强调代码的模块化、可重用性和可维护性。

在C++中，面向对象编程具有以下几个特点：

• 封装（Encapsulation）：将数据和操作数据的方法封装在一起，通过访问控制符来限制外部对数据的直接访问。
• 继承（Inheritance）：允许一个类继承另一个类的属性和方法，从而实现代码的重用。
• 多态（Polymorphism）：允许子类重写父类的方法，使得不同类的对象通过统一的接口进行操作。

面向对象的核心概念包括：

• 类（Class）：一个模板或蓝图，描述了对象的属性和行为。
• 对象（Object）：类的实例，具有独特的状态和行为。
• 成员变量（Member Variable）：对象的属性。
• 成员函数（Member Function）：对象的行为或方法。

类和对象的定义

类的声明和定义

类的声明一般由关键字class开始，后跟类名，然后是类体。类体包括成员变量和成员函数。成员变量表示对象的属性，成员函数表示对象的行为。以下是一个简单的类的声明和定义。

class Person {
public:
    // 成员变量
    std::string name;
    int age;

    // 成员函数
    void greet() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

对象的创建与使用

创建对象时，使用类名后跟一对圆括号。对象的创建通常伴随着内存的分配。下面的代码展示了如何创建Person类的对象，并调用其成员函数。

int main() {
    // 创建对象
    Person person;
    person.name = "Alice";
    person.age = 25;

    // 调用成员函数
    person.greet();

    return 0;
}

成员变量与成员函数

成员变量和成员函数可以有不同的访问控制符（public、private、protected）。这些控制符决定了其他部分的代码能否访问这些成员。默认情况下，成员函数是public的，而成员变量是private的。

class Rectangle {
private:
    int length;
    int width;

public:
    void setDimensions(int l, int w) {
        length = l;
        width = w;
    }

    int getArea() {
        return length * width;
    }
};

int main() {
    Rectangle rect;
    rect.setDimensions(4, 5);
    std::cout << "Area: " << rect.getArea() << std::endl;

    return 0;
}

封装与访问控制

封装是面向对象编程中的一个核心概念，它确保数据的安全性和完整性。封装通过封装数据和访问数据的方法来限制外部代码直接访问对象的内部细节。这通常通过访问控制符实现。

封装的概念

封装使得类的使用者只能通过公开的接口访问数据，而不能直接访问数据本身。这有助于维护数据的完整性，避免数据被非法修改。

class BankAccount {
private:
    double balance;

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

    // 存款方法
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    // 取款方法
    bool withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }

    // 获取余额
    double getBalance() const {
        return balance;
    }
};

访问控制符的使用

访问控制符决定了成员的可访问性。public成员可以被任何对象访问，private成员只能在类的内部访问，而protected成员可以在类内部和继承类内部访问。

class ProtectedAccount : protected BankAccount {
public:
    void printBalance() {
        // 只能在继承类内部访问
        std::cout << "Balance: " << getBalance() << std::endl;
    }
};

int main() {
    BankAccount account(1000);
    account.deposit(500);
    std::cout << "Balance: " << account.getBalance() << std::endl;

    ProtectedAccount protectedAccount(2000);
    protectedAccount.printBalance();  // 这里可以访问protected成员
    // protectedAccount.getBalance();  // 这里不能直接访问，违反封装原则

    return 0;
}

数据成员与成员函数的封装

封装不仅限于数据成员，还包括成员函数。通过封装成员函数，确保了数据的一致性和完整性。

class EncapsulatedAccount {
private:
    double balance;

public:
    EncapsulatedAccount(double initialBalance) : balance(initialBalance) {}

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    bool withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }

    double getBalance() const {
        return balance;
    }
};

继承与多态

继承是一种机制，允许一个类（子类或派生类）继承另一个类（基类或父类）的属性和行为。这有助于代码的重用和扩展性。多态性则允许不同类的对象通过统一的接口进行操作，提高代码的灵活性和可维护性。

继承的概念

继承允许子类直接使用基类的成员变量和成员函数，也可以重新定义或扩展它们。子类可以继承基类的公共和保护成员。

class Base {
public:
    void baseFunction() {
        std::cout << "Base Function" << std::endl;
    }
};

class Derived : public Base {
public:
    void derivedFunction() {
        std::cout << "Derived Function" << std::endl;
    }
};

继承的实现方式

继承可以通过public、protected或private访问修饰符来实现。public继承允许基类的公共成员在子类中作为公共成员访问，而protected继承则允许基类的保护成员在子类中作为保护成员访问。

class ProtectedBase {
protected:
    void protectedFunction() {
        std::cout << "Protected Function" << std::endl;
    }
};

class ProtectedDerived : protected ProtectedBase {
public:
    void callProtected() {
        protectedFunction();
    }
};

多态的实现与优势

多态性允许基类的指针或引用指向不同类型的对象。这些对象可以通过基类的接口进行操作，但实现细节是不同的。这使得代码更加灵活和通用。

class Shape {
public:
    virtual void draw() = 0;  // 抽象方法
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Square" << std::endl;
    }
};

int main() {
    std::vector<Shape*> shapes;
    shapes.push_back(new Circle());
    shapes.push_back(new Square());

    for (auto shape : shapes) {
        shape->draw();
    }

    return 0;
}

构造函数与析构函数

构造函数和析构函数是类的特殊成员函数，分别在对象创建和销毁时自动调用。构造函数用于初始化对象，而析构函数用于清理对象。

构造函数的作用与使用

构造函数在对象创建时调用，用于初始化对象的成员变量。构造函数可以有多个，包括默认构造函数、参数化构造函数和拷贝构造函数。

class Point {
public:
    // 默认构造函数
    Point() : x(0), y(0) {}

    // 参数化构造函数
    Point(int x, int y) : x(x), y(y) {}

    // 拷贝构造函数
    Point(const Point& other) : x(other.x), y(other.y) {}

private:
    int x;
    int y;
};

析构函数的作用与使用

析构函数在对象销毁时调用，用于释放资源，如内存、文件句柄等。析构函数没有参数，也没有返回类型。

class Resource {
public:
    Resource() {
        // 分配资源
        std::cout << "Resource allocated" << std::endl;
    }

    ~Resource() {
        // 释放资源
        std::cout << "Resource deallocated" << std::endl;
    }
};

int main() {
    Resource res;
    // res 对象在离开其作用域后自动调用析构函数
    return 0;
}

拷贝构造函数和赋值操作符重载

拷贝构造函数用于初始化对象的副本，赋值操作符重载用于对象之间的复制操作。这两个成员函数对于实现对象的正确复制非常重要。

class CustomString {
public:
    CustomString(const std::string& str) : data(new char[str.length() + 1]) {
        std::strcpy(data, str.c_str());
    }

    CustomString(const CustomString& other) : data(new char[strlen(other.data) + 1]) {
        std::strcpy(data, other.data);
    }

    ~CustomString() {
        delete[] data;
    }

    CustomString& operator=(const CustomString& other) {
        if (this != &other) {
            delete[] data;
            data = new char[strlen(other.data) + 1];
            std::strcpy(data, other.data);
        }
        return *this;
    }

private:
    char* data;
};

int main() {
    CustomString str1("Hello");
    CustomString str2 = str1;  // 使用拷贝构造函数
    str1 = str2;  // 使用赋值操作符重载

    return 0;
}

虚函数与纯虚函数

虚函数是允许在子类中重定义的成员函数，用于实现多态性。纯虚函数是抽象类的成员，它没有实现，要求子类必须实现它。

虚函数的作用与使用

虚函数允许子类重写基类的方法，从而实现运行时的多态。这使得相同的函数调用可以执行不同的行为。

class Animal {
public:
    virtual void makeSound() {
        std::cout << "Animal makes sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Dog barks" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "Cat meows" << std::endl;
    }
};

int main() {
    Animal* animals[2];
    animals[0] = new Dog();
    animals[1] = new Cat();

    for (auto animal : animals) {
        animal->makeSound();
    }

    return 0;
}

纯虚函数与抽象类

纯虚函数是抽象类的成员，没有实现，要求子类必须实现它们。抽象类不能直接实例化，只能作为基类。

class AbstractShape {
public:
    virtual ~AbstractShape() = default;
    virtual void draw() = 0;  // 纯虚函数
};

class Circle : public AbstractShape {
public:
    void draw() override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

int main() {
    AbstractShape* shape = new Circle();
    shape->draw();

    // AbstractShape obj;  // 不能实例化抽象类

    delete shape;
    return 0;
}

多态性的实现机制

多态性的核心在于虚函数表（VMT）的使用。每个类有一个虚函数表，其中包含指向虚函数的指针。通过虚函数表，调用虚函数可以实现运行时的多态性。

class Base {
public:
    virtual void func() {
        std::cout << "Base::func()" << std::endl;
    }
};

class Derived : public Base {
public:
    void func() override {
        std::cout << "Derived::func()" << std::endl;
    }
};

int main() {
    Base* base = new Base();
    Derived* derived = new Derived();

    base->func();  // 输出 "Base::func()"
    derived->func();  // 输出 "Derived::func()"
    Base* baseFromDerived = new Derived();
    baseFromDerived->func();  // 输出 "Derived::func()"

    delete base;
    delete derived;
    delete baseFromDerived;
    return 0;
}

通过这些示例和代码，可以更好地理解C++中的面向对象编程特性和机制，掌握类与对象的定义、封装、继承、多态等核心概念。