C++中如何实现数组元素镜像共享值？有无更优方案？

1. 索引映射表：提升可维护性 #

如果后续需要调整镜像的索引配对，硬编码switch的扩展性很差。用一个索引映射数组，把外部索引和内部存储位置做关联，能让代码更简洁易改：

#include <iostream>

struct MirroredArray
{
private:
    int data[2]; // 内部实际存储：0对应原a，1对应原b
    // 外部索引到内部存储的映射：0、1都指向data[0]，2指向data[1]
    const int index_map[3] = {0, 0, 1};

public:
    int& operator[](int index)
    {
        return data[index_map[index]];
    }

    const int& operator[](int index) const
    {
        return data[index_map[index]];
    }
};

int main()
{
    MirroredArray arr;
    arr[0] = 3;
    std::cout << arr[1] << std::endl; // 输出3
    arr[1] = 10;
    std::cout << arr[0] << std::endl; // 输出10
    return 0;
}

优势：修改镜像关系只需要改动index_map数组，不用碰运算符逻辑；新增索引映射也只需要在数组里加对应值，扩展性拉满。

2. 指针数组：支持动态调整镜像 #

如果需要在运行时修改镜像规则（比如临时让arr[2]也和arr[0]共享值），用指针数组实现动态映射是更好的选择：

#include <iostream>

struct DynamicMirroredArray
{
private:
    int data[2];
    int* ptrs[3]; // 每个外部索引对应一个指向内部存储的指针

public:
    DynamicMirroredArray()
    {
        // 初始化默认映射：0、1指向data[0]，2指向data[1]
        ptrs[0] = &data[0];
        ptrs[1] = &data[0];
        ptrs[2] = &data[1];
    }

    // 提供修改映射的接口，方便运行时调整
    void setMirror(int index, int target_data_idx)
    {
        if (index >= 0 && index < 3 && target_data_idx >= 0 && target_data_idx < 2)
        {
            ptrs[index] = &data[target_data_idx];
        }
    }

    int& operator[](int index)
    {
        return *ptrs[index];
    }

    const int& operator[](int index) const
    {
        return *ptrs[index];
    }
};

int main()
{
    DynamicMirroredArray arr;
    arr[0] = 3;
    std::cout << arr[1] << std::endl; // 输出3
    arr.setMirror(2, 0); // 让索引2也映射到data[0]
    arr[2] = 15;
    std::cout << arr[0] << std::endl; // 输出15
    return 0;
}

优势：完全支持运行时动态调整镜像关系，适合需求灵活的场景；指针的语义直观，逻辑清晰。

3. 引用变量：极简固定镜像方案 #

如果镜像关系完全固定且简单，用成员引用可以把代码写得更简洁：

#include <iostream>

struct SimpleMirroredArray
{
    int a;
    int& arr1 = a; // arr1直接是a的引用
    int b;

    int& operator[](int index)
    {
        return (index == 0 || index == 1) ? a : b;
    }

    const int& operator[](int index) const
    {
        return (index == 0 || index == 1) ? a : b;
    }
};

优势：代码极简，没有额外的映射结构，适合固定且简单的镜像场景。

内容的提问来源于stack exchange，提问作者The Rizzler