考研复试C++的类相关知识

在 C++ 中，类是面向对象编程的核心概念之一。通过类，可以定义对象的属性和行为。C++ 还支持继承和多态（通过虚函数实现），这些特性使得代码更具扩展性和灵活性。

以下是对 C++ 类的定义、继承和虚函数的详细讲解，并附带示例代码。

1. 类的定义

类是用户定义的数据类型，包含成员变量（属性）和成员函数（方法）。

语法

class ClassName {
private:
    // 私有成员（只能在类内部访问）
    int privateVar;

protected:
    // 受保护成员（可以在派生类中访问）
    int protectedVar;

public:
    // 公有成员（可以在类外部访问）
    int publicVar;

    // 构造函数
    ClassName() {
        // 初始化代码
    }

    // 成员函数
    void display() {
        cout << "Value: " << privateVar << endl;
    }

    // 析构函数
    ~ClassName() {
        // 清理代码
    }
};

示例

#include <iostream>
using namespace std;

class Person {
private:
    string name;

public:
    // 构造函数
    Person(string n) : name(n) {}

    // 成员函数
    void display() {
        cout << "Name: " << name << endl;
    }
};

int main() {
    Person p("Alice");
    p.display(); // 输出: Name: Alice
    return 0;
}

2. 继承

继承是面向对象编程的重要特性，允许一个类（派生类）从另一个类（基类）继承属性和方法。

语法

class BaseClass {
    // 基类成员
};

class DerivedClass : access-specifier BaseClass {
    // 派生类成员
};

• 访问修饰符： public：基类的公有成员在派生类中仍然是公有的。protected：基类的公有成员在派生类中变为受保护的。private：基类的公有成员在派生类中变为私有的。

示例

#include <iostream>
using namespace std;

// 基类
class Animal {
protected:
    string name;

public:
    Animal(string n) : name(n) {}

    void speak() {
        cout << name << " makes a sound." << endl;
    }
};

// 派生类
class Dog : public Animal {
public:
    Dog(string n) : Animal(n) {}

    void speak() {
        cout << name << " barks." << endl;
    }
};

int main() {
    Dog dog("Buddy");
    dog.speak(); // 输出: Buddy barks.
    return 0;
}

3. 虚函数与多态

虚函数允许在派生类中重写基类的函数，并通过基类指针或引用调用派生类的函数，实现运行时多态。

语法

class BaseClass {
public:
    virtual void function() {
        // 基类实现
    }
};

class DerivedClass : public BaseClass {
public:
    void function() override {
        // 派生类实现
    }
};

• virtual：声明虚函数。
• override：显式标记派生类中重写的函数（C++11 引入）。

示例

#include <iostream>
using namespace std;

// 基类
class Animal {
public:
    virtual void speak() {
        cout << "Animal makes a sound." << endl;
    }
};

// 派生类
class Dog : public Animal {
public:
    void speak() override {
        cout << "Dog barks." << endl;
    }
};

// 派生类
class Cat : public Animal {
public:
    void speak() override {
        cout << "Cat meows." << endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->speak(); // 输出: Dog barks.
    animal2->speak(); // 输出: Cat meows.

    delete animal1;
    delete animal2;
    return 0;
}

4. 纯虚函数与抽象类

纯虚函数是没有实现的虚函数，包含纯虚函数的类称为抽象类，不能实例化。

语法

class AbstractClass {
public:
    virtual void function() = 0; // 纯虚函数
};

示例

#include <iostream>
using namespace std;

// 抽象类
class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

// 派生类
class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle." << endl;
    }
};

// 派生类
class Square : public Shape {
public:
    void draw() override {
        cout << "Drawing a square." << endl;
    }
};

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();

    shape1->draw(); // 输出: Drawing a circle.
    shape2->draw(); // 输出: Drawing a square.

    delete shape1;
    delete shape2;
    return 0;
}

总结

• 类的定义：封装属性和方法。
• 继承：实现代码复用和层次化设计。
• 虚函数：支持运行时多态。
• 纯虚函数与抽象类：定义接口，强制派生类实现。

通过合理使用这些特性，可以编写出高效、可扩展的 C++ 程序。如果有其他问题，欢迎继续提问！