如何访问一系列const变量作为const数组

Question

很明显我可以：

const TYPE a();
const TYPE b();
const TYPE c();

我可以拥有

const TYPE all[] = {
  TYPE(),
  TYPE(),
  TYPE(),
};

但是我想同时使用 - 直接和数组访问。

无论如何，内存布局应该相同。union的想法想到了。沿着：

的线

union FOO {
  struct index_t {
    TYPE a;
    TYPE b;
    TYPE c;
  } index;
  TYPE all[];
};
const FOO foo;
foo.index.a;
foo.all[0];

天真的方法是仅在数组中使用参考

const TYPE a();
const TYPE b();
const TYPE c();
const TYPE all[3] = {
  a,
  b,
  c,
};

问题是：我可以确定这些只是3个实例，还是将它们变成6个实例？根本没有内存的内存？

那么最好走哪种方式？两者都是可行的吗？

注意：当然也可以选择使用一系列指针 - 但目标是找到一种仅引用的方法。

Answer 1

阵列 is 一个变量序列(从技术上讲对象，但区别在这里不重要(。您不需要另一个。

TYPE all[3]; // use std::array instead if you can

这就是所需的一切。const在这里并不特别重要，将其添加或删除为Reuied。

现在，如果您渴望句法糖，并且想要以all[0]为a等，这是可能的，但是这种可能性很可能会带来成本。

TYPE &a=all[0], &b=all[1], &c=all[2]; 

编译器可能会为A，B和C分配存储空间，尤其是当它们是班级成员时(这是您的费用(。当它们是静态变量或自动变量时，它可能会或可能不会优化它们。

应该强调的是，a，b和c不是所需的。他们只是为已经存在的对象all[i]提供替代名称。

实现这一目标的另一种方法如下

inline TYPE & a() { return all[0]; } // etc

这不太可能具有任何运行时的成本，因为编译器非常擅长优化此类琐碎功能。缺点是您需要编写a()而不是a。

联合方法，即使您设法使它为您工作，也很危险，不推荐，因为它一定会调用未定义的行为。

Answer 2

您可以拥有类似的东西：

struct FOO {
    struct INDEX {
        const TYPE a; // Can even initialize in place, e.g. const int a = 8;
        const TYPE b;
        const TYPE c;
    };
    // From here on boilerplate
    Index index;
    FOO() : all{this} {}
    struct ALL {
        ALL(FOO* p): parent{p} {}
        const TYPE& operator[](unsigned index) {
            // Some pointer magic
            return *(static_cast<TYPE*>(static_cast<void*>(parent) + index * sizeof(TYPE)));
        }
        FOO* parent;
    };
    ALL all;
};

您只有parent指针的其他内存开销(如果您计划拥有许多变量，则可以忽略不计(。而且还将有运行时开销 - 两个静态铸件，一个整数乘法和一个添加，但这将具有您瞄准的访问语法，并且不会复制变量。