Можно ли использовать неинициализированные указатели в C или C++?

Это очень специализированный оптимизированный корпус для видеоигр (в основном встроенная система). Раньше мы использовали их для поведения данных «Загрузка на месте» в наших видеоиграх, чтобы ускорить загрузку (и избежать фрагментации).

По сути, мы создаем объекты на стороне консоли (Playstation) в варочном устройстве для ПК. Затем, чтобы уменьшить перегрузку фрагментацией, мы упаковываем объекты данных в непрерывный буфер с помощью одного alloc. Затем ссылки на объекты данных в этом буфере будут изменены, чтобы вычесть базу из указателей на смещения (вызов unfix — у нас также были виртуальные вызовы fix/unfix, которые брали базу буфера и могли конвертировать между смещениями и указателями).

Когда мы загружали данные, они загружались одним большим блоком. Все данные, на которые ссылается корень, были вне корневого объекта. Мы могли бы сделать «новое» на месте в корне, которое инициализировало бы правильные таблицы VF для объекта и исправило бы все присоединенные блоки (выполнив новое на месте, а затем исправив присоединенные блоки соответственно).

Нам нужны были вызываемые конструкторы (вместо новых) для создания правильных VF-таблиц в объектах. Однако если бы указатели были автоматически очищены до NULL во время конструктора, мы бы потеряли данные смещения и не смогли бы воссоздать указатели между объектами в непрерывном блоке.

FWIW, это обычная техника в мире видеоигр. Эта статья Gamasutra (не написанная мной или моими коллегами) объясняет в подробно опишите то же самое, что они сделали в другой компании:

Кроме того, эта тема обсуждения на SourceForge.

Было даже проведено несколько выступлений на GDC (Конференция разработчиков игр) на эту тему.

Поиск в Google по запросу «загрузка на месте» даст много других примеров людей, использующих этот метод, который в основном требует неинициализированных указателей.

ПРИМЕЧАНИЕ. В настоящее время это единственный ответ, который фактически отвечает на заданный вопрос («Есть ли применение для неинициализированных указателей в C или C++?»), Указав конкретное использование указателей, которые должны оставаться унитаризированными.

Все остальные ответы являются лучшими ответами на исходный вопрос, на который ссылается («[C++] Почему указатели не инициализируются NULL по умолчанию?»), что заставило автора задать этот вопрос.

Прежде всего, инициализация указателей (или любых других переменных) по умолчанию не нарушает совместимость с C. И C, и C++ утверждают, что значение неинициализированной переменной неопределенно; на практике это означает, что он может содержать любое значение (включая представление ловушки), но обратите внимание, что 0 принадлежит множеству «любых значений»! Таким образом, соответствующая реализация может прекрасно инициализировать все указатели на 0. Однако ваша программа, если она будет полагаться на это, не будет соответствовать требованиям.

Теперь о том, почему вы можете не захотеть, чтобы ваш указатель был инициализирован: в основном, когда он записывается впоследствии. Например:

void foo(int*& p) {
   p = new int;
}

int* p; // why initialize? we overwrite it anyway
foo(p);

Вы можете сказать, что компилятор должен быть в состоянии оптимизировать это. К сожалению, он не может этого сделать, если определение foo недоступно (например, глобальные оптимизации времени компоновки отключены или они включены, но функция находится в DLL), поскольку он не знает, попытается ли foo прочитать из p (и тогда нужна была бы инициализация), или если бы он просто писал в нее (и тогда инициализация не нужна). Более того, могут быть случаи, которые труднее анализировать; Например:

bool try_parse_int(const char* s, int& n)
{
    // if parsed successfully, assign result to n and return true
    // if there was error parsing, don't touch n and return false
    ...
}

int n;
if (try_parse_int(s, n)) {
    // use n here
    ...
} else {
   // don't use n here
   ...
}

Компилятору гораздо труднее проанализировать его, даже если у него есть полные определения всех функций.

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

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

Использовать для унифицированного указателя? См. std::strtol().

char * bad;
long n = std::strtol( "123xyz", &bad, 10 );

после этого вызова bad будет содержать указатель на 'x'. Нет смысла его инициализировать.

Если бы вы написали программу в стиле C на C++, но предположили, что указатели были инициализированы, а затем вернули эту программу компилятору C, она бы не работала. Это единственная причина, по которой я мог представить, что это имеет значение.

Это не нарушит совместимости с C — реализация C, в которой все неинициализированные указатели на самом деле инициализируются 0 (или вообще чем угодно!) будет идеально соответствовать.

Отсутствие необходимости платить за то, что вам не нужно, здесь не для совместимости с C. Это также один из самых важных принципов C++.

Неинициализированный указатель полезен для одного и только для одного: присваивания ему чего-либо. Единственная причина, по которой вы когда-либо захотите его, заключается в том, что у вас нет фиксированного начального значения, но вы планируете назначить его в какой-то момент в будущем, и, таким образом, его инициализация является пустой тратой времени. Вы можете присвоить ему значение NULL, если хотите, или что-то еще.

Поскольку в C++ вы можете объявлять переменные в любом месте области видимости, а не только в начале, это больше не актуально, поскольку вы можете просто объявить их там, где используете.

Короткий ответ, однако, нет. Просто присвойте ему значение NULL.

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

Предположим, у вас есть функция, которая является обработчиком прерываний, требующим большого количества переменных стека указателей:

void interruptHandler()
{
    char* ptr0;
    ...
    char* ptrX-1;
    char* ptrX;
}

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