为什么引用数组是非法的？

Question

以下代码无法编译。

int a = 1, b = 2, c = 3;
int& arr[] = {a,b,c,8};

C++ 标准对此有何评论？

我知道我可以声明一个包含引用的类，然后创建该类的数组，如下所示。但是我很想知道为什么上面的代码不能编译。

struct cintref
{
    cintref(const int & ref) : ref(ref) {}
    operator const int &() { return ref; }
private:
    const int & ref;
    void operator=(const cintref &);
};

int main() 
{
  int a=1,b=2,c=3;
  //typedef const int &  cintref;
  cintref arr[] = {a,b,c,8};
}

可以使用struct cintref 代替const int & 来模拟引用数组。

Answer 1

回答您关于标准的问题，我可以引用 C++ 标准 §8.3.2/4：

不得有对引用的引用，不得有引用数组，也不得有指向引用的指针。

那是因为引用不是对象，不占用内存，所以没有地址。您可以将它们视为对象的别名。声明一个什么都没有的数组没有多大意义。

Answer 2

引用不是对象。它们没有自己的存储空间，它们只是引用现有对象。因此，引用数组没有意义。

如果你想要一个引用另一个对象的轻量级对象，那么你可以使用指针。如果您为所有 struct 实例的所有引用成员提供显式初始化，您将只能使用带有引用成员的 struct 作为数组中的对象。引用不能默认初始化。

编辑：正如 jia3ep 所指出的，在声明的标准部分中，明确禁止引用数组。

Answer 3

这是一个有趣的讨论。显然，引用数组是完全非法的，但恕我直言，原因并不是说“它们不是对象”或“它们没有大小”那么简单。我要指出，数组本身并不是 C/C++ 中的成熟对象——如果你反对，请尝试使用数组作为“类”模板参数来实例化一些 stl 模板类，看看会发生什么。你不能返回它们，分配它们，将它们作为参数传递。 （数组参数被视为指针）。但是制作数组的数组是合法的。 引用确实具有编译器可以并且必须计算的大小 - 您不能 sizeof() 引用，但您可以创建一个只包含引用的结构。它的大小足以包含所有实现引用的指针。如果不初始化所有成员，就无法实例化这样的结构：

struct mys {
 int & a;
 int & b;
 int & c;
};
...
int ivar1, ivar2, arr[200];
mys my_refs = { ivar1, ivar2, arr[12] };

my_refs.a += 3  ;  // add 3 to ivar1

其实你可以在结构体定义中加入这一行

struct mys {
 ...
 int & operator[]( int i ) { return i==0?a : i==1? b : c; }
};

...现在我有一些看起来很像 refs 数组的东西：

int ivar1, ivar2, arr[200];
mys my_refs = { ivar1, ivar2, arr[12] };

my_refs[1] = my_refs[2]  ;  // copy arr[12] to ivar2
&my_refs[0];               // gives &my_refs.a == &ivar1

现在，这不是一个真正的数组，它是一个运算符重载；例如，它不会做数组通常会做的事情，例如 sizeof(arr)/sizeof(arr[0])。但它使用完全合法的 C++ 完成了我想要一组引用做的事情。 除了 (a) 设置超过 3 或 4 个元素很痛苦，并且 (b) 它正在使用一堆 ?: 进行计算，这可以使用索引来完成（不是使用普通的 C-pointer-calculation-semantics 索引，但仍然索引）。我希望看到一个非常有限的“引用数组”类型实际上可以做到这一点。 IE。引用数组不会被视为作为引用的事物的一般数组，而是它将是一个新的“引用数组”事物，它有效地映射到与上述类似的内部生成的类（但你不幸的是不能用模板制作）。

如果您不介意这种讨厌的事情，这可能会起作用：将 '*this' 重铸为 int * 的数组并返回一个引用：（不推荐，但它显示了正确的'array' 会起作用）：

 int & operator[]( int i ) { return *(reinterpret_cast<int**>(this)[i]); }

Answer 4

评论您的编辑：

更好的解决方案是std::reference_wrapper。

详情： http://www.cplusplus.com/reference/functional/reference_wrapper/

例子：

#include <iostream>
#include <functional>
using namespace std;

int main() {
    int a=1,b=2,c=3,d=4;
    using intlink = std::reference_wrapper<int>;
    intlink arr[] = {a,b,c,d};
    return 0;
}

Answer 5

数组可以隐式转换为指针，pointer-to-reference is illegal in C++

Answer 6

给定int& arr[] = {a,b,c,8};，sizeof(*arr) 是什么？

在其他任何地方，引用都被简单地视为事物本身，因此sizeof(*arr) 应该只是sizeof(int)。但这会使该数组上的数组指针算术错误（假设引用的宽度不同是整数）。为了消除歧义，这是禁止的。

Answer 7

因为就像许多人在这里所说的那样，引用不是对象。它们只是别名。确实，某些编译器可能将它们实现为指针，但标准并未强制/指定这一点。因为引用不是对象，所以你不能指向它们。将元素存储在数组中意味着存在某种索引地址（即指向某个索引处的元素）；这就是为什么你不能有引用数组的原因，因为你不能指向它们。

使用 boost::reference_wrapper 或 boost::tuple 代替；或者只是指针。

Answer 8

我相信答案很简单，它与引用的语义规则以及数组在 C++ 中的处理方式有关。

简而言之： 引用可以被认为是没有默认构造函数的结构，所以所有相同的规则都适用。

1) 从语义上讲，引用没有默认值。只能通过引用某些东西来创建引用。引用没有表示没有引用的值。

2) 当分配一个大小为 X 的数组时，程序会创建一个默认初始化对象的集合。由于引用没有默认值，因此创建这样的数组在语义上是非法的。

这条规则也适用于没有默认构造函数的结构/类。以下代码示例无法编译：

struct Object
{
    Object(int value) { }
};

Object objects[1]; // Error: no appropriate default constructor available

Answer 9

您可以非常接近这个模板结构。 但是，您需要使用指向 T 而不是 T 的指针的表达式进行初始化；因此，尽管您可以类似地轻松制作“fake_constref_array”，但您将无法像 OP 的示例（“8”）中那样将其绑定到右值；

#include <stdio.h>

template<class T, int N> 
struct fake_ref_array {
   T * ptrs[N];
  T & operator [] ( int i ){ return *ptrs[i]; }
};

int A,B,X[3];

void func( int j, int k)
{
  fake_ref_array<int,3> refarr = { &A, &B, &X[1] };
  refarr[j] = k;  // :-) 
   // You could probably make the following work using an overload of + that returns
   // a proxy that overloads *. Still not a real array though, so it would just be
   // stunt programming at that point.
   // *(refarr + j) = k  
}

int
main()
{
    func(1,7);  //B = 7
    func(2,8);     // X[1] = 8
    printf("A=%d B=%d X = {%d,%d,%d}\n", A,B,X[0],X[1],X[2]);
        return 0;
}

--> A=0 B=7 X = {0,8,0}

Answer 10

只是为了添加到所有对话中。 由于数组需要连续的内存位置来存储项目，所以如果我们创建一个引用数组，那么不能保证它们会在连续的内存位置，所以访问将是一个问题，因此我们甚至不能应用所有的数学运算数组。

Answer 11

参考对象没有大小。如果你写sizeof(referenceVariable)，它会给你referenceVariable引用的对象的大小，而不是引用本身的大小。它没有自己的大小，这就是编译器无法计算数组需要多少大小的原因。

Answer 12

当您在数组中存储某些内容时，需要知道其大小（因为数组索引依赖于大小）。根据 C++ 标准，未指定引用是否需要存储，因此无法对引用数组进行索引。

Answer 13

考虑一个指针数组。指针实际上是一个地址；因此，当您初始化数组时，您类似地告诉计算机，“分配这块内存来保存这些 X 数字（它们是其他项目的地址）。”然后，如果您更改其中一个指针，您只是在更改它所指向的内容；它仍然是一个数字地址，它本身就在同一个位置。

引用类似于别名。如果你要声明一个引用数组，你基本上会告诉计算机，“分配这个由分散在各处的所有这些不同项目组成的无定形内存块。”

Answer 14

实际上，这是 C 和 C++ 语法的混合体。

您应该或者使用纯 C 数组，它不能是引用，因为引用只是 C++ 的一部分。 或者您采用 C++ 方式并使用 std::vector 或 std::array 类来实现您的目的。

至于编辑部分：尽管struct 是来自C 的元素，但您定义了构造函数和运算符函数，使其成为C++ class。因此，您的 struct 不会在纯 C 中编译！