纯虚函数与抽象类 ​

面试考点 ​

这道题考察你对 C++ 接口设计和多态体系的理解。面试官想知道你是否能区分虚函数和纯虚函数、抽象类的特性以及实际工程中怎么用。

核心概念 ​

纯虚函数是在声明时赋值为 0 的虚函数,没有(也可以有)默认实现。包含至少一个纯虚函数的类就是抽象类,不能直接实例化,只能被继承。派生类必须覆写所有纯虚函数,否则派生类也是抽象类。

cpp
class Shape {
public:
    // 纯虚函数:= 0 表示没有默认实现,派生类必须覆写
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

// Shape s;  // 编译错误:不能实例化抽象类

基本示例 ​

cpp
#include <iostream>
#include <vector>
#include <memory>
#include <cmath>

// ============================
// 示例1:抽象类与纯虚函数
// ============================

class Shape {
public:
    // 纯虚函数:派生类必须实现
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
    virtual std::string name() const = 0;

    // 非纯虚函数:有默认实现,派生类可以选择覆写
    virtual void print() const {
        std::cout << name() << " 面积=" << area()
                  << " 周长=" << perimeter() << std::endl;
    }

    // 虚析构函数
    virtual ~Shape() = default;
};

class Circle : public Shape {
    double radius_;
public:
    Circle(double r) : radius_(r) {}

    // 必须实现所有纯虚函数
    double area() const override {
        return 3.14159265358979 * radius_ * radius_;
    }

    double perimeter() const override {
        return 2.0 * 3.14159265358979 * radius_;
    }

    std::string name() const override {
        return "圆形";
    }
};

class Rectangle : public Shape {
    double width_, height_;
public:
    Rectangle(double w, double h) : width_(w), height_(h) {}

    double area() const override {
        return width_ * height_;
    }

    double perimeter() const override {
        return 2.0 * (width_ + height_);
    }

    std::string name() const override {
        return "矩形";
    }
};

void shape_demo() {
    // 不能创建 Shape 对象,但可以用 Shape 指针
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(5.0));
    shapes.push_back(std::make_unique<Rectangle>(3.0, 4.0));

    for (const auto& s : shapes) {
        s->print();  // 多态调用
    }
}

// ============================
// 示例2:纯虚函数可以有实现
// ============================

class Logger {
public:
    // 纯虚函数可以提供默认实现(在类外定义)
    virtual void log(const std::string& msg) = 0;
    virtual ~Logger() = default;
};

// 纯虚函数的默认实现(类外定义)
void Logger::log(const std::string& msg) {
    std::cout << "[默认] " << msg << std::endl;
}

class FileLogger : public Logger {
public:
    void log(const std::string& msg) override {
        // 可以调用基类的默认实现
        Logger::log(msg);  // 显式调用纯虚函数的默认实现
        std::cout << "[文件] " << msg << std::endl;
    }
};

void pure_virtual_impl_demo() {
    FileLogger fl;
    fl.log("测试消息");
}

// ============================
// 示例3:接口类(所有函数都是纯虚函数)
// ============================

// C++ 没有 interface 关键字,但可以用纯虚函数模拟
class ISerializable {
public:
    virtual std::string serialize() const = 0;
    virtual void deserialize(const std::string& data) = 0;
    virtual ~ISerializable() = default;
};

class IComparable {
public:
    virtual int compare_to(const IComparable& other) const = 0;
    virtual ~IComparable() = default;
};

// 一个类可以"实现"多个"接口"
class Student : public ISerializable, public IComparable {
    std::string name_;
    int score_;
public:
    Student(const std::string& name, int score)
        : name_(name), score_(score) {}

    std::string serialize() const override {
        return name_ + ":" + std::to_string(score_);
    }

    void deserialize(const std::string& data) override {
        auto pos = data.find(':');
        name_ = data.substr(0, pos);
        score_ = std::stoi(data.substr(pos + 1));
    }

    int compare_to(const IComparable& other) const override {
        auto& s = dynamic_cast<const Student&>(other);
        return score_ - s.score_;
    }

    void print() const {
        std::cout << name_ << " 分数: " << score_ << std::endl;
    }
};

void interface_demo() {
    Student s1("张三", 90);
    Student s2("李四", 85);

    // 通过接口使用
    ISerializable& ser = s1;
    std::cout << "序列化: " << ser.serialize() << std::endl;

    IComparable& cmp1 = s1;
    IComparable& cmp2 = s2;
    std::cout << "比较结果: " << cmp1.compare_to(cmp2) << std::endl;
}

// ============================
// 示例4:派生类不实现纯虚函数仍然是抽象类
// ============================

class Base {
public:
    virtual void func1() = 0;
    virtual void func2() = 0;
    virtual ~Base() = default;
};

class Partial : public Base {
public:
    void func1() override {
        std::cout << "Partial::func1()" << std::endl;
    }
    // func2 没有实现,所以 Partial 仍然是抽象类
};

class Complete : public Partial {
public:
    void func2() override {
        std::cout << "Complete::func2()" << std::endl;
    }
};

void incomplete_demo() {
    // Partial p;    // 编译错误:Partial 仍然是抽象类
    Complete c;      // OK:所有纯虚函数都已实现
    c.func1();
    c.func2();
}

int main() {
    std::cout << "=== 抽象类多态 ===" << std::endl;
    shape_demo();

    std::cout << "\n=== 纯虚函数默认实现 ===" << std::endl;
    pure_virtual_impl_demo();

    std::cout << "\n=== 接口 ===" << std::endl;
    interface_demo();

    std::cout << "\n=== 不完整派生 ===" << std::endl;
    incomplete_demo();

    return 0;
}

虚函数 vs 纯虚函数 ​

特性虚函数纯虚函数
声明语法virtual void foo()virtual void foo() = 0
是否有实现必须有可以有(类外定义)
派生类是否必须覆写不必须必须(否则派生类也是抽象类)
包含它的类能否实例化可以不能(变成抽象类)
用途提供默认行为定义接口契约

常见问题 ​

纯虚函数能有函数体吗?

可以,但必须在类外定义。派生类可以通过 Base::func() 显式调用这个默认实现。不过即使有函数体,包含纯虚函数的类仍然是抽象类,不能实例化。

抽象类可以有构造函数吗?

可以。虽然不能直接实例化抽象类,但派生类构造时会调用基类的构造函数,所以抽象类的构造函数用于初始化基类部分的成员。

C++ 的"接口"和 Java 的 interface 有什么区别?

C++ 没有 interface 关键字。通常把所有成员函数都是纯虚函数、没有数据成员的类当作接口。C++ 的"接口"可以有虚析构函数的默认实现,也支持多重继承。

适用场景 ​

  • 定义统一的接口规范
  • 强制派生类实现特定行为
  • 策略模式、工厂模式等设计模式
  • 插件系统的接口定义

注意事项 ​

  • 抽象类的析构函数通常应该是 virtual 的
  • 派生类必须覆写所有纯虚函数才能实例化
  • 纯虚函数可以有默认实现(类外定义)
  • 抽象类可以有普通成员变量和非虚函数
  • 不能创建抽象类的对象,但可以有抽象类的指针和引用

总结 ​

纯虚函数用 = 0 声明,包含纯虚函数的类是抽象类,不能实例化。抽象类定义了接口契约,强制派生类必须实现所有纯虚函数。纯虚函数可以有默认实现(类外定义),派生类可以显式调用。C++ 用全纯虚函数的类模拟 Java/C# 的 interface。面试中要能区分虚函数和纯虚函数的作用,理解抽象类的约束,并知道纯虚函数可以有函数体这个冷知识。