constexpr 虚函数
什么是 constexpr 虚函数
C++20 之前,constexpr 和 virtual 不能同时使用——virtual 意味着运行期多态,constexpr 意味着编译期求值,两者看上去矛盾。C++20 移除了这个限制(P1064),允许虚函数标记为 constexpr,从而实现编译期多态。
之所以可行,是因为在常量表达式求值过程中,编译器始终知道对象的动态类型(编译期创建的对象类型是确定的),所以虚函数调用可以在编译期解析到正确的最终覆盖函数。
constexpr 虚函数的规则
| 规则 | 说明 |
|---|---|
| constexpr 虚函数可以覆盖非 constexpr 虚函数 | 派生类可以给基类的非 constexpr 虚函数加上 constexpr |
| 非 constexpr 虚函数可以覆盖 constexpr 虚函数 | 派生类可以去掉 constexpr |
| 编译期调用时选中非 constexpr 覆盖函数会报错 | 如果最终覆盖函数不是 constexpr,该调用不是常量表达式 |
| 析构函数也可以是 constexpr virtual | 多态基类的析构函数可以同时标记 constexpr 和 virtual |
| 默认析构函数自动 constexpr | 如果满足 constexpr 要求,编译器生成的默认析构函数是 constexpr 的 |
基本示例
#include <iostream>
#include <array>
// ============================
// 示例1:基本的 constexpr 虚函数
// ============================
struct Shape {
// constexpr 虚析构函数——多态基类必须
constexpr virtual ~Shape() = default;
// constexpr 纯虚函数
constexpr virtual double area() const = 0;
constexpr virtual const char* name() const = 0;
};
struct Circle : Shape {
double radius;
constexpr Circle(double r) : radius(r) {}
constexpr double area() const override {
return 3.14159265358979 * radius * radius;
}
constexpr const char* name() const override {
return "圆形";
}
};
struct Rectangle : Shape {
double width, height;
constexpr Rectangle(double w, double h) : width(w), height(h) {}
constexpr double area() const override {
return width * height;
}
constexpr const char* name() const override {
return "矩形";
}
};
struct Triangle : Shape {
double base, height;
constexpr Triangle(double b, double h) : base(b), height(h) {}
constexpr double area() const override {
return 0.5 * base * height;
}
constexpr const char* name() const override {
return "三角形";
}
};
// 通过基类引用调用虚函数——编译期多态
constexpr double get_area(const Shape& s) {
return s.area();
}
void basic_demo() {
// 编译期创建对象并调用虚函数
constexpr Circle c(5.0);
constexpr Rectangle r(3.0, 4.0);
constexpr Triangle t(6.0, 3.0);
// 通过基类引用,编译期解析虚函数
constexpr double ca = get_area(c);
constexpr double ra = get_area(r);
constexpr double ta = get_area(t);
static_assert(ra == 12.0, "矩形面积应该是 12.0");
static_assert(ta == 9.0, "三角形面积应该是 9.0");
std::cout << c.name() << " 面积: " << ca << std::endl;
std::cout << r.name() << " 面积: " << ra << std::endl;
std::cout << t.name() << " 面积: " << ta << std::endl;
}
// ============================
// 示例2:编译期多态计算
// ============================
struct Animal {
constexpr virtual ~Animal() = default;
constexpr virtual int legs() const = 0;
constexpr virtual const char* species() const = 0;
};
struct Cat : Animal {
constexpr int legs() const override { return 4; }
constexpr const char* species() const override { return "猫"; }
};
struct Duck : Animal {
constexpr int legs() const override { return 2; }
constexpr const char* species() const override { return "鸭"; }
};
struct Spider : Animal {
constexpr int legs() const override { return 8; }
constexpr const char* species() const override { return "蜘蛛"; }
};
// 编译期通过基类指针数组计算总腿数
constexpr int total_legs() {
Cat cat;
Duck duck;
Spider spider;
// 基类指针数组
const Animal* animals[] = {&cat, &duck, &spider, &cat};
int total = 0;
for (const auto* a : animals) {
total += a->legs(); // 编译期虚函数调用
}
return total; // 4 + 2 + 8 + 4 = 18
}
void polymorphic_calc_demo() {
constexpr int legs = total_legs();
static_assert(legs == 18);
std::cout << "总腿数: " << legs << std::endl;
}
// ============================
// 示例3:constexpr 覆盖非 constexpr
// ============================
struct Base {
virtual ~Base() = default;
virtual int value() const { return 0; } // 非 constexpr
};
struct Derived : Base {
constexpr int value() const override { return 42; } // constexpr 覆盖非 constexpr
};
void override_demo() {
constexpr Derived d;
constexpr int v = d.value(); // 编译期调用
static_assert(v == 42);
std::cout << "Derived::value() = " << v << std::endl;
// 注意:通过 Base 引用在编译期调用时,
// 如果最终覆盖函数是 constexpr 的,调用仍然有效
// constexpr const Base& b = d;
// constexpr int bv = b.value(); // 正确:最终覆盖函数 Derived::value() 是 constexpr
}
// ============================
// 示例4:编译期工厂模式
// ============================
struct Config {
constexpr virtual ~Config() = default;
constexpr virtual int max_retries() const = 0;
constexpr virtual int timeout_ms() const = 0;
constexpr virtual bool use_cache() const = 0;
};
struct DevConfig : Config {
constexpr int max_retries() const override { return 1; }
constexpr int timeout_ms() const override { return 5000; }
constexpr bool use_cache() const override { return false; }
};
struct ProdConfig : Config {
constexpr int max_retries() const override { return 3; }
constexpr int timeout_ms() const override { return 30000; }
constexpr bool use_cache() const override { return true; }
};
// 编译期根据配置做决策
constexpr int compute_total_timeout(const Config& cfg) {
return cfg.timeout_ms() * cfg.max_retries();
}
void factory_demo() {
constexpr DevConfig dev;
constexpr ProdConfig prod;
constexpr int dev_timeout = compute_total_timeout(dev);
constexpr int prod_timeout = compute_total_timeout(prod);
static_assert(dev_timeout == 5000);
static_assert(prod_timeout == 90000);
std::cout << "开发环境总超时: " << dev_timeout << "ms" << std::endl;
std::cout << "生产环境总超时: " << prod_timeout << "ms" << std::endl;
}
// ============================
// 示例5:协变返回类型
// ============================
struct BaseNode {
constexpr virtual ~BaseNode() = default;
constexpr virtual const BaseNode* clone_ref() const { return this; }
constexpr virtual int id() const { return 0; }
};
struct DerivedNode : BaseNode {
int value_;
constexpr DerivedNode(int v) : value_(v) {}
// 协变返回类型:返回 DerivedNode* 而不是 BaseNode*
constexpr const DerivedNode* clone_ref() const override { return this; }
constexpr int id() const override { return value_; }
};
void covariant_demo() {
constexpr DerivedNode node(42);
constexpr const BaseNode* base_ptr = &node;
constexpr int node_id = base_ptr->id();
static_assert(node_id == 42);
std::cout << "节点 ID: " << node_id << std::endl;
}
int main() {
std::cout << "=== 基本用法 ===" << std::endl;
basic_demo();
std::cout << "\n=== 编译期多态计算 ===" << std::endl;
polymorphic_calc_demo();
std::cout << "\n=== 覆盖关系 ===" << std::endl;
override_demo();
std::cout << "\n=== 编译期工厂 ===" << std::endl;
factory_demo();
std::cout << "\n=== 协变返回 ===" << std::endl;
covariant_demo();
return 0;
}编译期多态 vs 运行期多态
| 方面 | 运行期多态(传统 virtual) | 编译期多态(constexpr virtual) |
|---|---|---|
| 类型确定时机 | 运行期(通过虚表) | 编译期(编译器已知动态类型) |
| 虚表开销 | 有(虚指针 + 虚表查找) | 无(编译期直接解析) |
| 适用场景 | 运行期决定调用哪个函数 | 编译期已知所有类型 |
| 代码复用 | 好 | 好(同一套继承体系两个上下文都能用) |
适用场景
- 在编译期和运行期共享同一套继承体系和业务逻辑
- 编译期配置验证(不同配置类覆盖不同的虚函数)
- 编译期计算中需要多态行为
- 替代模板元编程中的值特化(用继承 + constexpr virtual 更直观)
- 编译期测试和断言(用 static_assert 验证多态行为)
常见问题
编译期虚函数调用还需要虚表吗?
不需要。在编译期求值时,编译器知道对象的实际类型,直接调用对应的函数,不经过虚表。虚表只在运行期使用。
constexpr 虚函数和去虚化有什么关系?
去虚化(Devirtualization)是编译器在运行期代码中的优化——当编译器能推断出动态类型时,直接调用具体函数而不经过虚表。constexpr 虚函数是语言层面的保证——在编译期上下文中,虚函数调用一定能解析。
可以在 constexpr 中使用 dynamic_cast 和 typeid 吗?
C++20 也允许了。在常量表达式中对象的动态类型已知,所以 dynamic_cast 和 typeid 可以在编译期使用。
所有虚函数都应该加 constexpr 吗?
不一定。只有需要在编译期调用的虚函数才需要加 constexpr。加了 constexpr 意味着函数体必须满足 constexpr 的要求(不能有不支持的操作)。
注意事项
- constexpr 虚函数的函数体必须满足 constexpr 要求
- 多态基类的析构函数需要是 constexpr virtual
- constexpr 虚函数可以覆盖非 constexpr 虚函数,反之亦然
- 编译期调用时如果最终覆盖函数不是 constexpr,会编译错误
- 编译期创建的多态对象不能使用动态内存(除非满足瞬态分配要求)
- 同一个继承体系可以同时用于编译期和运行期
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 11.0 |
| Clang | 9.0 |
| MSVC | 19.28 (VS 2019 16.8) |
总结
C++20 允许虚函数标记为 constexpr,实现了编译期多态。在常量表达式求值中,编译器已知对象的动态类型,可以直接解析虚函数调用到正确的最终覆盖函数,不需要虚表。这让同一套继承体系可以同时用于编译期和运行期,减少了代码重复。constexpr 虚函数可以覆盖非 constexpr 虚函数(反之亦然),但在编译期调用时选中的最终覆盖函数必须是 constexpr 的。实际应用中,constexpr 虚函数适合编译期配置验证、编译期计算中的多态行为、以及替代基于值特化的模板元编程。