纯虚函数与抽象类
面试考点
这道题考察你对 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。面试中要能区分虚函数和纯虚函数的作用,理解抽象类的约束,并知道纯虚函数可以有函数体这个冷知识。