为什么引用数组不合法？

以下代码无法编译。

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 &模拟引用数组。

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

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

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

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

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

这是一个有趣的讨论。显然，裁判的排列完全是非法的，但是恕我直言，其原因并不像说“它们不是对象”或“它们没有大小”那样简单。我要指出的是，数组本身并不是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; }
};

...现在我有一些东西看起来像很多参考：

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指针计算语义索引） ，但仍会建立索引）。我想看到一个非常有限的“引用数组”类型，它实际上可以做到这一点。也就是说，引用数组不会被视为是引用的事物的通用数组，而是一个新的“引用数组” 用模板制作）。

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

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

评论您的编辑：

更好的解决方案是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;
}

数组可以隐式转换为指针，并且在C ++中，指向引用的指针是非法的

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

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

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

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

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

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

1）在语义上，引用没有默认值。引用只能通过引用某些内容来创建。引用没有值来表示没有引用。

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

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

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

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

您可以使用此模板结构相当接近。但是，您需要使用指向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}

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

当您将某物存储在数组中时，需要知道其大小（因为数组索引依赖于大小）。根据C ++标准，尚不确定引用是否需要存储，因为无法对引用数组进行索引。

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

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

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

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

应该要么使用纯C数组，不能引用的，因为参考是唯一的C ++一部分。或者，您采用C ++的方式并根据需要使用std::vectoror std::array类。

至于被编辑的部分：即使structC是来自C的元素，您也可以定义一个构造函数和运算符函数，使其成为C ++ class。因此，您struct将无法在纯C中编译！