C++入门教程：第四篇 - 面向对象编程基础_c++面向对象教程-优快云博客

C++入门教程：第四篇 - 面向对象编程基础

面向对象编程（OOP）是C++的核心特性之一，它帮助程序员通过封装、继承和多态等机制来组织和管理代码。理解这些概念能够显著提高代码的复用性、可维护性和可扩展性。本文将介绍C++中的面向对象编程基础，包括类的定义与使用、继承和多态的实现。

1. 类和对象

1.1 类的定义

类是C++中的基本构造块，它是一个自定义的数据类型，用于封装数据和操作这些数据的方法。类的定义包括数据成员（属性）和成员函数（方法）。

1.1.1 类的基本结构

以下是一个简单的类定义示例：

cpp

#include <iostream>

using namespace std;

// 类定义
class Car {
public:
    // 数据成员
    string brand;
    int year;

    // 成员函数
    void displayInfo() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
    // 创建对象
    Car myCar;
    myCar.brand = "Toyota";
    myCar.year = 2020;

    // 调用成员函数
    myCar.displayInfo();

    return 0;
}

cpp

1.1.2 构造函数

构造函数是特殊的成员函数，在对象创建时自动调用，用于初始化对象的状态。

cpp

#include <iostream>

using namespace std;

class Car {
public:
    string brand;
    int year;

    // 构造函数
    Car(string b, int y) : brand(b), year(y) {}

    void displayInfo() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
    // 使用构造函数创建对象
    Car myCar("Honda", 2022);
    myCar.displayInfo();

    return 0;
}

cpp

1.1.3 析构函数

析构函数是另一个特殊的成员函数，在对象销毁时自动调用，用于释放资源。

cpp

#include <iostream>

using namespace std;

class Car {
public:
    string brand;
    int year;

    // 构造函数
    Car(string b, int y) : brand(b), year(y) {}

    // 析构函数
    ~Car() {
        cout << "Car object is being destroyed" << endl;
    }

    void displayInfo() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
    Car myCar("Ford", 2019);
    myCar.displayInfo();

    return 0;
}

cpp

2. 继承

继承是OOP的一个重要特性，它允许一个类继承另一个类的属性和方法，从而实现代码的重用和扩展。

2.1 基类和派生类

基类是被继承的类，派生类是继承基类的类。派生类可以访问基类的公共和保护成员。

2.1.1 公共继承

以下示例展示了如何定义基类和派生类：

cpp

#include <iostream>

using namespace std;

// 基类
class Vehicle {
public:
    string brand;

    void displayBrand() {
        cout << "Brand: " << brand << endl;
    }
};

// 派生类
class Car : public Vehicle {
public:
    int year;

    void displayInfo() {
        displayBrand();
        cout << "Year: " << year << endl;
    }
};

int main() {
    Car myCar;
    myCar.brand = "Chevrolet";
    myCar.year = 2023;

    myCar.displayInfo();

    return 0;
}

cpp

2.1.2 访问控制

C++中的继承有三种访问控制类型：public、protected和private。公共继承是最常用的继承方式，它允许派生类访问基类的公共成员。

cpp

#include <iostream>

using namespace std;

// 基类
class Base {
public:
    int pubVar;
protected:
    int protVar;
private:
    int privVar;
};

// 派生类
class Derived : public Base {
public:
    void accessMembers() {
        pubVar = 1; // 访问公有成员
        protVar = 2; // 访问保护成员
        // privVar = 3; // 错误：无法访问私有成员
    }
};

cpp

3. 多态

多态是OOP的另一重要特性，它允许通过基类指针或引用调用派生类中的重写方法，从而实现运行时动态绑定。

3.1 虚函数

虚函数是基类中声明为virtual的函数，允许派生类重写（override）该函数，实现动态绑定。

3.1.1 虚函数的使用

以下示例展示了如何使用虚函数实现多态：

cpp

#include <iostream>

using namespace std;

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

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

int main() {
    Base* ptr;
    Derived obj;
    ptr = &obj;

    // 调用虚函数
    ptr->show(); // 输出: Derived class show()

    return 0;
}

cpp

3.1.2 虚析构函数

如果基类包含虚函数，通常应该将析构函数声明为虚函数，以确保派生类的析构函数也会被调用。

cpp

#include <iostream>

using namespace std;

class Base {
public:
    virtual ~Base() {
        cout << "Base destructor" << endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived destructor" << endl;
    }
};

int main() {
    Base* ptr = new Derived();
    delete ptr; // 正确调用Derived析构函数
    return 0;
}

cpp