C++中类的三大特性及其应用

最新推荐文章于 2026-06-11 20:37:31 发布

原创最新推荐文章于 2026-06-11 20:37:31 发布 · 527 阅读

8 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

C++中类的三大特性及其应用

C++作为一种面向对象的编程语言，类的设计是其核心特性之一。类通过封装、继承和多态这三大特性，提供了强大的代码组织能力和灵活性。本文将详细介绍这三大特性，并探讨构造函数和析构函数的作用及其应用。

1. 封装

封装是面向对象编程的基石之一。它将数据的属性和行为结合在一起，形成一个整体。通过封装，数据和函数都成为类的成员，从而增强了代码的安全性和可维护性。

封装类的访问类型：

私有成员(private)：只有类内的成员函数可以访问。
受保护成员(protected)：类内和子类的成员函数可以访问，类外不可访问。
公有成员(public)：可以在类外访问。

封装类的优缺点：

优点：隔离变化、提高代码复用性、提高安全性。
缺点：过度封装可能影响运行效率，使用者容易混淆代码的具体实现。

示例代码：

#include<iostream>
#include<string>
using namespace std;

class Student {
public:
    string name;
    int num;
    void work() {
        cout << "姓名是" << name << "，学号是" << num << endl;
    }
};

int main() {
    Student s;
    s.name = "张三";
    s.num = 123;
    s.work();
    return 0;
}

2. 继承

继承允许一个类（子类）继承另一个类（父类）的成员变量和成员函数。通过继承，子类可以复用父类的代码，并可以在子类中重写父类的方法，以实现不同的功能。

继承的优点：

减少重复代码，提高代码的复用性。
让类与类之间产生联系，是多态的前提。
增加了类与类之间的耦合性。

继承方式：

私有继承：父类中的所有成员在子类中的权限都是私有的。
公有继承：父类中的所有成员在子类中的权限不会发生改变。
受保护继承：父类中的公有成员在子类中的权限会变成受保护的。

示例代码：

#include<iostream>
using namespace std;

class Father {
private:
    int pri;
protected:
    int pro;
public:
    int pub;
};

class Son : protected Father {
public:
    void fun() {
        pro = 1; // pro在Son中仍然是受保护的
        pub = 1; // pub在Son中是受保护的
    }
};

class Grandson : public Son {
public:
    void fun() {
        pro = 1; // pro在Grandson中仍然是受保护的
        pub = 1; // pub在Grandson中仍然是受保护的
    }
};

int main() {
    Son s;
    // s.pro = 2; // 错误：pro是受保护的，不能通过对象访问
    // s.pub = 2; // 错误：pub是受保护的，不能通过对象访问
    return 0;
}

3. 多态

多态是指一个接口可以有多种实现状态。多态的出现大大提高了程序的扩展性。多态分为静态多态和动态多态。

静态多态：在编译期间就能确定的多态，例如运算符重载和函数重载。

动态多态：在运行期间才能确定的多态，通常通过父类指针或引用指向子类对象来实现。

多态的前提：

必须存在父类子类的继承关系。
父类中必须有虚函数。
子类重写父类中的虚函数。
父类指针或引用指向子类对象。

示例代码：

#include<iostream>
using namespace std;

class Animal {
public:
    virtual void speak() {
        cout << "Animal speaks" << endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        cout << "Dog speaks" << endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        cout << "Cat speaks" << endl;
    }
};

void Test01() {
    Animal* a1 = new Dog;
    a1->speak();
    Animal* a2 = new Cat;
    a2->speak();
    Dog g;
    Animal& a3 = g;
    a3.speak();
}

void Test02(Animal* a) {
    a->speak();
}

int main() {
    Test01();
    Test02(new Dog);
    Test02(new Cat);
    return 0;
}

4. 构造函数和析构函数

构造函数用于初始化对象的成员变量，而析构函数用于释放对象占用的资源。

构造函数：

无参构造函数：如果用户不提供，编译器会自动生成一个默认的无参构造函数。
有参构造函数：用于初始化对象的成员变量。
拷贝构造函数：用于通过已存在的对象初始化新的对象。

析构函数：

用于释放对象占用的资源，特别是当对象包含动态分配的内存时。

示例代码：

#include<iostream>
using namespace std;

class Person {
public:
    int m_Age;
    int m_Height;

    // 默认构造函数
    Person() {
        cout << "默认构造函数的调用！" << endl;
        this->m_Age = 0;
        this->m_Height = 0;
    }

    // 有参构造函数
    Person(int age, int height) {
        cout << "有参构造函数的调用！" << endl;
        this->m_Age = age;
        this->m_Height = height;
    }

    // 拷贝构造函数
    Person(const Person& other) {
        cout << "拷贝构造函数的调用！" << endl;
        this->m_Age = other.m_Age;
        this->m_Height = other.m_Height;
    }

    // 析构函数
    ~Person() {
        cout << "析构函数的调用！" << endl;
    }
};

int main() {
    Person p1; // 调用默认构造函数
    Person p2(18, 175); // 调用有参构造函数
    Person p3 = p2; // 调用拷贝构造函数
    return 0;
}

总结

C++中的封装、继承和多态是面向对象编程的三大核心特性。通过封装，我们可以隐藏实现细节，提高代码的安全性和可维护性；通过继承，我们可以复用代码，减少重复劳动；通过多态，我们可以提高程序的扩展性和灵活性。构造函数和析构函数则分别用于对象的初始化和资源的释放，确保对象的生命周期管理得当。掌握这些特性，能够帮助我们编写出更加高效、可维护的C++代码。

标签

#c++