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 的

基本示例 ​

cpp
#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,会编译错误
  • 编译期创建的多态对象不能使用动态内存(除非满足瞬态分配要求)
  • 同一个继承体系可以同时用于编译期和运行期

编译器支持情况 ​

编译器最低支持版本
GCC11.0
Clang9.0
MSVC19.28 (VS 2019 16.8)

总结 ​

C++20 允许虚函数标记为 constexpr,实现了编译期多态。在常量表达式求值中,编译器已知对象的动态类型,可以直接解析虚函数调用到正确的最终覆盖函数,不需要虚表。这让同一套继承体系可以同时用于编译期和运行期,减少了代码重复。constexpr 虚函数可以覆盖非 constexpr 虚函数(反之亦然),但在编译期调用时选中的最终覆盖函数必须是 constexpr 的。实际应用中,constexpr 虚函数适合编译期配置验证、编译期计算中的多态行为、以及替代基于值特化的模板元编程。