能否仅用一个函数重写C++的operator[]运算符？

我有一段可正常运行的代码：

template<size_t size>
struct myClass {
public:
    std::array<uint8_t, size> bytes;

    bool operator==(const myClass<size>& o) const {
        for (size_t i{0}; i < size; ++i) {
            if (bytes[i] != o.bytes[i]) return false;
        }
        return true;
    }

    uint8_t& operator[] (size_t ind) {
        return bytes[ind];
    }

    const uint8_t& operator[] (size_t ind) const { 
        return bytes[ind]; // function body is identical, can I write only once?
    }
};

int main() {

    myClass<4> my{23,24,55,26};
    my.bytes[2] = 24;
    cout << std::dec << static_cast<int32_t>(my[2]) << endl;
    my[2] = 44;
    cout << static_cast<int32_t>(my[2]) << endl;

    uint8_t *p1 = &my[2];
    cout << static_cast<int32_t>(*p1) << endl;

    const myClass<4> my2{23,24,55,26};
    const uint8_t *p2 = &my2[2];
    cout << static_cast<int32_t>(*p2++) << endl;
    cout << static_cast<int32_t>(*p2) << endl;

return 0;}

我的问题是，uint8_t& operator[](size_t ind)和const uint8_t& operator[](size_t ind) const的函数体完全相同，都是return bytes[ind];，需要重复编写两次相同代码，是否存在方法只需编写一次函数体，同时保证代码正常运行？

有几种实用方法可以避免重复编写这两个operator[]的代码：

1. 让非const版本调用const版本（推荐） #

这是C++里处理这类重复代码的经典手法，利用const版本的逻辑，通过const_cast安全地移除const属性——因为当前对象本身是非const的，所以这种转换不会导致未定义行为：

template<size_t size>
struct myClass {
    // ... 其他成员 ...

    const uint8_t& operator[] (size_t ind) const { 
        return bytes[ind];
    }

    uint8_t& operator[] (size_t ind) {
        // 先将当前对象转为const引用，调用const版本，再移除const属性
        return const_cast<uint8_t&>(static_cast<const myClass&>(*this)[ind]);
    }
};

这样只需要维护const版本的核心逻辑，非const版本直接复用，既安全又减少重复代码。

2. 提取私有辅助模板函数 #

把共同的逻辑封装到一个私有模板函数中，让两个operator[]都调用这个函数，模板会根据传入对象的const属性自动推导返回类型：

template<size_t size>
struct myClass {
private:
    template<typename T>
    static auto& get_element(T& obj, size_t ind) {
        return obj.bytes[ind];
    }

public:
    // ... 其他成员 ...

    uint8_t& operator[] (size_t ind) {
        return get_element(*this, ind);
    }

    const uint8_t& operator[] (size_t ind) const { 
        return get_element(*this, ind);
    }
};

3. C++20 用requires约束合并逻辑 #

如果使用C++20及以上版本，可以通过requires约束区分const和非const情况，甚至用constexpr if把逻辑合并到一个模板函数里：

template<size_t size>
struct myClass {
    // ... 其他成员 ...

    template<typename Self>
    auto& operator[] (size_t ind) requires std::same_as<std::remove_cvref_t<Self>, myClass> {
        if constexpr (std::is_const_v<Self>) {
            return std::as_const(static_cast<Self&>(*this).bytes)[ind];
        } else {
            return static_cast<Self&>(*this).bytes[ind];
        }
    }
};

这种方式把两个版本的逻辑整合到一个函数中，通过编译期分支处理不同const属性的情况。

4. 直接暴露bytes成员（按需选择） #

如果你的设计允许直接访问内部的bytes成员，那完全可以省略自定义的operator[]，让用户直接使用my.bytes[ind]。这种方式彻底避免重复代码，但只适用于不需要封装内部实现的场景。

内容的提问来源于stack exchange，提问作者coin cheung