Почему я должен переинтерпретировать указатели указателей?

int никак не связан с void. То же самое касается int** и void**, поэтому их нельзя преобразовать с помощью static_cast.

void*, однако, является особым. Любой тип указателя данных (включая int*) может быть static_cast в void* и обратно, несмотря на то, что ни один тип не связан с void (более того, преобразование в void* не требует приведения, поскольку оно неявно). int* не имеет этого свойства, как и void**, и ни один другой указатель, кроме void*.

Дополнительные свободы, предоставленные void*, сопровождаются дополнительными ограничениями. void* не может быть косвенным и не может использоваться с арифметикой указателя. Эти ограничения возможны только потому, что никогда не может быть объекта типа void. Или с противоположной точки зрения, объекты void не могут существовать из-за этих ограничений.

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

void* pn = static_cast<void*>(&n);

является неявным преобразованием; вы также можете написать

void *pn = &n;

Это означает, что pn хранит указатель на некоторый тип объекта; программист несет ответственность за знание того, что это за тип объекта. Чтобы отбросить, вам нужен static_cast:

int *pi = static_cast<int*>(pn);

Обратите внимание, что использование static_cast для приведения к любому типу, значительно отличающемуся от исходного (float существенно отличается, const int нет), является способом повторной интерпретации. Вы должны написать это reinterpret_cast неявное преобразование (или static_cast), за которым следует static_cast.

В этом вся цель void*, концепции, восходящей к C, где приведения записываются с приведением в стиле C, очевидно (не static_cast...), но в остальном имеют идентичные значения.

Возвращаясь к синтаксису объявлений в C и C++:

Объявление указателя на int равно int (*pi); (скобки бесполезны, но помогают проиллюстрировать суть), вы можете прочитать это так: Я объявляю, что выражение (*pi) имеет тип int. Вы можете прочитать объявление функции таким образом: в int f(int i); я заявляю, что если i имеет тип int, то f(i) имеет тип int.

Объявление void (*pi); выглядит как указатель на void, но не существует такой вещи, как объект типа void, выражение *pi даже неправильно сформировано, оно не имеет смысла. Это особый случай в системе типов: синтаксис говорит "указатель на пустоту", семантика говорит "указатель на что-то".

В C и C++ объект-указатель является объектом первого класса, и вы можете взять его адрес и получить указатель на указатель и т. д. (В отличие от Java, где ссылки, подобные другим фундаментальным типам, не являются объектами класса.)

Таким образом, вы можете иметь указатели int**, int***... на (указатели... на int); по той же причине вы можете объявить void**: как указатель на (указатель на пустоту), семантически указатель на (указатель на что-то).

Точно так же указатель на int не может быть назначен указателю на float без приведения:

float *f = &i; // ill-formed

из-за несоответствия типов тип, отличный от void**, не может быть присвоен void**: результатом разыменования void** должен быть объект void*.