static operator[](C++23) ​

什么是 static operator[] ​

C++23 允许 operator[](下标运算符)声明为 static。在此之前,operator[] 必须是非静态成员函数,即使函数体内完全不使用 this 指针,编译器也要传递它。

对于无状态的下标运算符(比如只做索引计算或查表),声明为 static 可以避免传递不必要的 this 指针,减少一点开销。这和 C++23 同时引入的 static operator() 遵循同样的原则——不为不使用的东西付出代价。

cpp
struct LookupTable {
    // C++23:static operator[],不需要 this
    static int operator[](int index) {
        static constexpr int table[] = {10, 20, 30, 40, 50};
        return table[index];
    }
};

// 通过实例调用(语法要求)
LookupTable t;
int val = t[2];  // 30

基本示例 ​

cpp
#include <iostream>
#include <array>
#include <cstddef>
#include <cmath>

// ============================
// 示例1:静态查找表
// ============================

struct FibTable {
    // 不需要对象状态,只是查表
    static constexpr int operator[](int n) {
        constexpr int fibs[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55};
        return fibs[n];
    }
};

void lookup_demo() {
    FibTable fib;
    std::cout << "fib[0] = " << fib[0] << std::endl;   // 0
    std::cout << "fib[5] = " << fib[5] << std::endl;   // 5
    std::cout << "fib[10] = " << fib[10] << std::endl;  // 55

    // 也可以用临时对象
    std::cout << "FibTable{}[7] = " << FibTable{}[7] << std::endl;  // 13
}

// ============================
// 示例2:数学函数映射
// ============================

struct SquareMap {
    // 计算平方——不依赖对象状态
    static constexpr int operator[](int x) {
        return x * x;
    }
};

struct CubeMap {
    static constexpr int operator[](int x) {
        return x * x * x;
    }
};

void math_demo() {
    SquareMap sq;
    CubeMap cb;

    for (int i = 1; i <= 5; i++) {
        std::cout << i << "^2 = " << sq[i]
                  << "  " << i << "^3 = " << cb[i] << std::endl;
    }
}

// ============================
// 示例3:多维静态下标(结合多维下标运算符)
// ============================

struct IdentityMatrix {
    // 单位矩阵:对角线为 1,其余为 0
    static constexpr int operator[](int row, int col) {
        return (row == col) ? 1 : 0;
    }
};

void multidim_demo() {
    IdentityMatrix id;

    std::cout << "3x3 单位矩阵:" << std::endl;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << id[i, j] << " ";
        }
        std::cout << std::endl;
    }
}

// ============================
// 示例4:枚举到字符串的映射
// ============================

enum class Color { Red, Green, Blue, Count };

struct ColorName {
    static const char* operator[](Color c) {
        static constexpr const char* names[] = {
            "红色", "绿色", "蓝色"
        };
        return names[static_cast<int>(c)];
    }
};

void enum_demo() {
    ColorName cn;
    std::cout << cn[Color::Red] << std::endl;
    std::cout << cn[Color::Green] << std::endl;
    std::cout << cn[Color::Blue] << std::endl;
}

// ============================
// 示例5:对比 static 和非 static
// ============================

// 非 static:隐式传递 this 指针
struct NonStaticIndex {
    int operator[](int i) const {
        return i * 10;
    }
};

// static:不传递 this 指针,更轻量
struct StaticIndex {
    static int operator[](int i) {
        return i * 10;
    }
};

void comparison_demo() {
    NonStaticIndex ns;
    StaticIndex st;

    // 调用语法完全一样
    std::cout << "非 static: " << ns[3] << std::endl;  // 30
    std::cout << "static: " << st[3] << std::endl;      // 30

    // 但 static 版本不传递 this 指针
    // 在某些场景(如频繁调用的无状态函数对象)有微小的性能优势
}

// ============================
// 示例6:用作 lambda 的静态下标
// ============================

void lambda_demo() {
    // C++23 static lambda 配合 operator()
    auto square = [](int x) static { return x * x; };

    // lambda 不能定义 operator[],但函数对象可以
    // 这里展示 static lambda 的 operator() 作为对比
    std::cout << "static lambda: " << square(5) << std::endl;  // 25
}

int main() {
    std::cout << "=== 查找表 ===" << std::endl;
    lookup_demo();

    std::cout << "\n=== 数学映射 ===" << std::endl;
    math_demo();

    std::cout << "\n=== 多维静态 ===" << std::endl;
    multidim_demo();

    std::cout << "\n=== 枚举映射 ===" << std::endl;
    enum_demo();

    std::cout << "\n=== static vs 非 static ===" << std::endl;
    comparison_demo();

    std::cout << "\n=== static lambda ===" << std::endl;
    lambda_demo();

    return 0;
}

static vs 非 static operator[] ​

特性static operator[]非 static operator[]
this 指针不传递隐式传递
访问成员变量不能可以
调用语法需要通过实例调用通过实例调用
适用场景无状态映射/查表需要对象状态
constexpr支持支持
性能省去 this 传递有 this 传递

适用场景 ​

  • 无状态的查找表(斐波那契、ASCII 映射等)
  • 编译期常量表的下标访问
  • 枚举到字符串/数值的映射
  • 数学函数映射(平方、阶乘等)
  • 与多维下标运算符结合使用

常见问题 ​

为什么不能直接用 类名[index] 调用?

C++ 的运算符调用语法要求有一个对象实例。即使是 static 的,也需要写成 obj[index] 或 ClassName{}[index]。要用 ClassName::operator[](index) 也可以,但语法较长。

static operator[] 可以和多维下标一起用吗?

可以。static 和多维参数是独立的特性,可以组合使用。

什么时候应该用 static operator[]?

当你的下标运算符完全不依赖对象状态时。如果函数体里不访问任何成员变量,就应该考虑声明为 static。

注意事项 ​

  • C++23 特性
  • 调用仍需要通过实例或临时对象
  • 不能访问非静态成员变量
  • 可以和 constexpr 一起使用
  • GCC 13+、Clang 16+、MSVC 2022 17.4+ 支持

总结 ​

C++23 允许 operator[] 声明为 static,和 static operator() 保持一致。当下标运算符不需要访问对象状态时,声明为 static 可以避免传递不必要的 this 指针。典型用途包括编译期查找表、无状态的数学映射、枚举到字符串的转换等。它可以和多维下标运算符组合使用。调用语法上仍需要通过实例调用,这是 C++ 运算符语法的要求。