Почему массивы ссылок незаконны?

Следующий код не компилируется.

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 ++ Standard §8.3.2 / 4 :

Не должно быть ссылок на ссылки, массивов ссылок и указателей на ссылки.

Ссылки не являются объектами. У них нет собственного хранилища, они просто ссылаются на существующие объекты. По этой причине не имеет смысла иметь массивы ссылок.

Если вы хотите легкий объект который ссылается на другой объект, вы можете использовать указатель. Вы сможете использовать объект structсо ссылочным элементом в качестве объектов в массивах только в том случае, если вы предоставите явную инициализацию для всех ссылочных элементов для всех structэкземпляров. Ссылки не могут быть инициализированы по умолчанию.

Редактировать: Как отмечает jia3ep, в стандартном разделе объявлений есть явный запрет на массивы ссылок.

Это интересная дискуссия. Ясно, что массивы ссылок совершенно незаконны, но ИМХО причина, почему не так просто сказать «они не объекты» или «они не имеют размера». Я хотел бы отметить, что сами массивы не являются полноценными объектами в C / C ++ - если вы возражаете против этого, попробуйте создать экземпляр некоторых классов шаблонов stl, используя массив в качестве параметра шаблона 'class', и посмотрите, что произойдет. Вы не можете вернуть их, назначить их, передать их в качестве параметров. (параметр массива рассматривается как указатель). Но допустимо создавать массивы из массивов. Ссылки имеют размер, который компилятор может и должен рассчитать - вы не можете использовать 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 ++. За исключением (а) неудобно устанавливать более 3 или 4 элементов, и (б) он выполняет вычисления с использованием нескольких символов?: Что можно сделать с помощью индексации (а не с помощью обычной индексации семантики C-указателя-вычисления-семантики) , но индексация тем не менее). Я хотел бы видеть очень ограниченный тип «массив ссылок», который действительно может сделать это. Т.е. массив ссылок не будет рассматриваться как общий массив вещей, которые являются ссылками, а скорее будет новым «массивом ссылок» сделать с шаблонами).

это, вероятно, сработает, если вы не возражаете против такого рода мерзостей: переделайте '* this' в массив int * и верните ссылку, сделанную из одного: (не рекомендуется, но показывает, как правильно '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::vectorилиstd::array класс для своих целей.

Что касается редактируемой части: несмотря на то, что structэто элемент из C, вы определяете конструктор и операторные функции, которые делают его C ++ class. Следовательно, ваш structне будет компилироваться в чистом C!