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

Ссылка является ссылкой на экземпляр чего-то. Экземпляр чего-то не может иметь типа void. Любой экземпляр чего-то должен иметь определенный тип (и возможно базовые типы).

Вот сводка разных вещей, которые были сказаны, и что я думал.

Две главных причины, почему ссылка на пустоту запрещена

1 , Они были бы полностью бесполезны.

Действительно, если мы оглядываемся назад во времена C, пустые указатели имели две цели:

• управление памятью (например, malloc)
• Степень универсальности (пишущий функции, которые могут принять любой тип аргументов)

, Когда C++ вышел, шаблоны стали лучшим решением реализовать степень универсальности. Однако пользовательское управление памятью все еще должно было быть возможным, и совместимость между C++, и C был главным беспокойством, таким образом, пусто* был сохранен. Гипотетическая пустая ссылка не имела бы справки с управлением памятью, и степень универсальности уже охвачена, так в основном это имело бы почти быть бесполезное (за исключением гарантии непустых описанным ниже).

2 Вы не были бы в состоянии сделать что-либо с ним

При использовании пустого указателя, Нельзя разыменовать его; транспонированный к случаю ссылок, который означает, Вы не можете использовать (всегда гипотетический) пустая ссылка. Так

void *data = // something
// using *data and data-> is forbidden

void &data = // something
// using data is forbidden

Однако мы могли думать о варианте использования, где ссылка не должна будет быть "разыменована" (эта фраза является ужасно неправильной, но Вы понимаете мою мысль), но где мы только взяли бы ее адрес. Давайте предположим, что у меня есть следующая функция:

void foo(void *dataptr)
{
    assert(dataptr != NULL); // or != 0
    // do something with dataptr
}

Для предотвращения этого раздражения утверждают, я мог записать функции этот путь:

void foo(void &dataref)
{
    void *data = &dataref;
    // do something with data
}

Однако для этого для работы, &dataref потребности быть эквивалентным dataptr, , который не имеет место : &dataref эквивалентно &*dataptr!

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

С технической точки зрения все, что гарантируется, - то, что ссылка на объект является псевдонимом для него. Это при ссылочной передаче параметров капота сделано с указателями, деталь реализации. Это может сбивать с толку из-за ссылок, снова использующих & оператор, который является также адресом - но имеет в виду, что оператор на самом деле имеет различные значения в различных контекстах (в объявлении переменной или объявлении параметра это обозначает ссылочный тип, иначе это - адрес - кроме тех случаев, когда это является поразрядным - и). Поскольку это - технически просто псевдоним для объекта, ссылка 'всегда разыменовывается' как объясненный Worrier.

Можно думать о ссылке как о разыменованном указателе. Синтаксически Вы рассматриваете ссылку, как будто это не указатель: Вам не нужно * оператор для разыменования его, и можно использовать. вместо-> для доступа к его участникам.

Однако Вы не можете разыменовать void указатель. Как указано Двоичным Worrier, пытающимся сделать, который даст Вам ошибку компилятора. И если у Вас не может быть разыменованного пустого указателя, который означает, что у Вас не может быть пустой ссылки.

Если бы они были, они семантически не дифференцировались бы от указателей и составили бы синтаксический сахар. Ссылка говорит, "Я обращаюсь к чему-то, что имеет этот тип". Разрешение пусто или нулевая ссылка ослабило бы то различие от указателей.

Предоставленный, для ссылки все еще возможно относиться к объекту, который больше не существует, но это - исключение.

пустой что-то, что, по определению, не существует, таким образом, не логично иметь, это - адрес.

ОК, меня беспокоит одна вещь. Идея void * , как упоминалось выше, состоит в том, что у вас все еще есть допустимая переменная, содержащая адрес, но тип игнорируется. Это кажется допустимым, поскольку мы все еще можем работать с адресными данными - тип в этом контексте несколько избыточен (или менее важен). Разыменование это плохо, потому что попытаться получить доступ к члену не имеет смысла, например, p.mem . Мы не знаем, к какому классу обращаться, и, следовательно, к памяти, к которой нужно переходить, к указателям vtable, которым нужно следовать.

Однако, это ' Затем, кажется, имеет смысл, что p сам по себе будет в порядке, поскольку он будет ссылаться только на объект, но не на его данные. Для этого не требуется информация о классе, только адрес. Я понимаю, что это абсолютно бесполезно, но важно определить, когда что-то сломалось. Допуская это понятие, также имеет смысл ссылка на C ++ (постоянно разыменовываемая, но не имеющая доступа к чему-либо), например, void & ref = static_cast <& void> (obj) и, следовательно, допускает ссылки на void. Я не говорю, что кто-то должен обсуждать это с ответственными лицами, но с точки зрения «осмысления», это было бы правильно, не так ли?

Как указывал Люк Турайль выше (по крайней мере, это мой интерпретация), это может быть реализовано, но проблема является семантической. Разумное объяснение, к которому я мог прийти, заключалось в том, что, поскольку переменная объекта является «тегом» для последовательности памяти, тип имеет важное семантическое значение. Таким образом, указатель, рассматриваемый как переменная со значением адреса, рассматривает тип как несколько избыточный, а не ключ к его определению.

Кто-нибудь с этим согласится?

Ниже не защита понятия недействительных ссылок. Я предлагаю это как анекдот из дикой природы. Спросите себя, не пахнет ли это смешно.

Моя компания была одной из первых, кто использовал C ++ на коммерческой основе, и первоначально скомпилировал с использованием Cfront . Ранние разработчики все еще изучали язык и обычно использовали все приемы в книге (операторы везде!). Вот трюк, который они сочли классным:

void Foo::something(int action, ostream &os = *(ostream *)0)
{
   ostream *os_p = &os;
   if (&os == (ostream *)0) {
      os_p = &cerr;
   }
   // continue with method
}

Итак, у вас есть не ссылка на void, а типизированная ссылка с потенциально привязкой void ! Мгновенная мысль, вероятно, должна предложить лучшие альтернативы этой конкретной идиоме ...