当前位置：首页 > article >正文

简要介绍C++的“类（Class）”

article 2025/2/12 17:33:04

C++中的类（Class）是面向对象编程的核心概念之一，它是一种封装了数据和操作数据的函数的编程结构。类可以看作是一个自定义的数据类型，用于描述具有相同属性和行为的对象集合。以下是对C++类的详细介绍：

1. 类的定义

类的定义使用关键字class，其基本语法如下：

class 类名 {
    访问修饰符：
    成员变量；
    成员函数；
};

访问修饰符：主要有public、private和protected三种。
- public：公开的，类外可以访问。
- private：私有的，只能在类内部访问。
- protected：受保护的，类内部和派生类可以访问。
成员变量：存储对象的数据。
成员函数：定义对象的行为。

2. 类的成员

（1）成员变量

成员变量是类中定义的变量，用于存储对象的状态。它们可以是基本数据类型（如int、float等），也可以是其他类的对象。

（2）成员函数

成员函数是类中定义的函数，用于操作成员变量或实现对象的行为。成员函数可以访问类中的所有成员变量和函数。

3. 类的构造函数和析构函数

（1）构造函数

构造函数是一种特殊的成员函数，用于在创建对象时初始化对象。构造函数的名称与类名相同，没有返回值类型（包括void）。构造函数可以重载，即可以有多个构造函数，参数列表不同。

示例：

class Person {
public:
    Person() { // 默认构造函数
        cout << "Default Constructor" << endl;
    }
    Person(string name, int age) { // 带参数的构造函数
        this->name = name;
        this->age = age;
        cout << "Parameterized Constructor" << endl;
    }
private:
    string name;
    int age;
};

（2）析构函数

析构函数用于在对象销毁时进行清理工作，如释放动态分配的内存等。析构函数的名称与类名相同，前面加~，没有参数，也没有返回值类型。

示例：

class Person {
public:
    ~Person() {
        cout << "Destructor called" << endl;
    }
private:
    string name;
    int age;
};

4. 对象的创建和使用

（1）对象的创建

对象是类的实例，可以通过类名加括号来创建对象。如果类有构造函数，会调用构造函数进行初始化。

示例：

Person p1; // 调用默认构造函数
Person p2("John", 30); // 调用带参数的构造函数

（2）对象的使用

可以通过对象名访问其公有成员变量和成员函数。

示例：

p1.setName("Alice");
p1.setAge(25);
cout << p1.getName() << " " << p1.getAge() << endl;

5. 类的继承

继承是面向对象编程中的一个重要特性，允许一个类（派生类）继承另一个类（基类）的成员变量和成员函数。

示例：

class Animal {
public:
    void eat() {
        cout << "Animal is eating" << endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        cout << "Dog is barking" << endl;
    }
};

int main() {
    Dog dog;
    dog.eat(); // 继承自Animal类
    dog.bark(); // Dog类自己的函数
    return 0;
}

6. 类的多态

多态是指允许不同的对象对同一消息做出响应的能力。C++中的多态主要通过虚函数和重载实现。

（1）虚函数

虚函数用于实现动态绑定，即在运行时根据对象的实际类型调用相应的函数。

示例：

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

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

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

int main() {
    Animal* a1 = new Dog();
    Animal* a2 = new Cat();
    a1->sound(); // 输出 Dog barks
    a2->sound(); // 输出 Cat meows
    delete a1;
    delete a2;
    return 0;
}

（2）函数重载

函数重载是指在同一个作用域中，函数名相同但参数列表不同的函数。

示例：

class Math {
public:
    int add(int a, int b) {
        return a + b;
    }
    double add(double a, double b) {
        return a + b;
    }
};

7. 类的静态成员

静态成员变量和静态成员函数属于类本身，而不是某个对象。静态成员变量需要在类外初始化，静态成员函数可以访问静态成员变量。

示例：

class Student {
public:
    static int count; // 静态成员变量
    Student() {
        count++;
    }
    static void displayCount() { // 静态成员函数
        cout << "Total students: " << count << endl;
    }
};

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

int main() {
    Student s1, s2, s3;
    Student::displayCount(); // 输出 Total students: 3
    return 0;
}

8. 类的友元

友元可以是函数或类，它允许访问类的私有和受保护成员。

示例：

class A {
    int x;
    friend void display(A a); // 友元函数
};

void display(A a) {
    cout << "x = " << a.x << endl;
}

int main() {
    A a;
    a.x = 10; // 错误，x是私有成员
    display(a); // 正确，友元函数可以访问私有成员
    return 0;
}

9. 类的模板

类模板允许创建通用类，可以在定义类时指定数据类型。

示例：

template <typename T>
class Stack {
    T* arr;
    int top;
    int capacity;
public:
    Stack(int size) {
        arr = new T[size];
        capacity = size;
        top = -1;
    }
    void push(T item) {
        if (top < capacity - 1)
            arr[++top] = item;
    }
    T pop() {
        if (top >= 0)
            return arr[top--];
        return -1;
    }
};

int main() {
    Stack<int> s(5);
    s.push(10);
    s.push(20);
    cout << s.pop() << endl; // 输出 20
    return 0;
}