Законно ли переинтерпретировать_приведение к пустоте*

Всегда допустимо преобразование указателя на тип в указатель на другой тип, включая void, поэтому, если T является типом, это допустимо в C++:

T* x;
void *y = reinterpret_cast<void *>(x);

В реальном мире он никогда не используется, потому что void * — это особый случай, и вы получаете то же значение с static_cast:

void *y = static_cast<void *>(x); // equivalent to previous reinterpret_cast

(на самом деле приведенное выше преобразование является неявным и может быть записано просто как void *y = x; - спасибо Майклу Кензелу за то, что он это заметил)

Чтобы быть более точным, стандарт даже говорит в проекте n4659 для C++ 17 8.2.10 Reinterpret cast [expr.reinterpret.cast], §7

Когда prvalue v типа указателя объекта преобразуется в тип указателя объекта «указатель на cv T», результатом является static_cast<cv T*>(static_cast<cv void*>(v)).

Когда вы ссылаетесь на то, что byte и char являются единственными допустимыми типами, просто допустимо разыменование преобразованного указателя только для этих типов. void сюда не включено, потому что вы никогда не сможете разыменовать void *.

Чтобы конкретно ответить на ваш вопрос

.. Я привожу от int** к void*. И в конце концов я переведу из void* обратно в int**.

Стандарт гарантирует, что первое преобразование является стандартным (читай, неявным):

Значение prvalue типа «указатель на cv T», где T — тип объекта, может быть преобразовано в значение prvalue типа «указатель на cv void». Значение указателя (6.9.2) при этом преобразовании не изменяется.

Так что это всегда законно:

int **i = ...;
void *v = i;

Для обратного кастинга стандарт говорит (в static_cast параграфе):

Значение prvalue типа «указатель на cv1 void» может быть преобразовано в значение prvalue типа «указатель на cv2 T»,

Так это тоже законно

int **j = static_cast<int **>(v);

и стандарт гарантирует, что j == i.

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

Соответствующий раздел cppreference на reinterpret_cast:

(Любой тип указателя объекта T1* может быть преобразован в другой тип указателя объекта cv T2*. Это точно эквивалентно static_cast<cv T2*>(static_cast<cv void*>(expression)) (что означает, что если требование выравнивания T2 не более строгое, чем требование T1, значение указателя не не изменяется, и преобразование результирующего указателя обратно в его исходный тип дает исходное значение). В любом случае результирующий указатель может быть безопасно разыменован только в том случае, если это разрешено правилами псевдонимов типов)

При возврате к исходному типу AliasedType и DynamicType одинаковы, поэтому они похожи, что является первым случаем, указанным в правилах псевдонимов, где допустимо разыменование результата reinterpret_cast :

Всякий раз, когда предпринимается попытка прочитать или изменить сохраненное значение объекта типа DynamicType через glvalue типа AliasedType, поведение не определено, если не выполняется одно из следующих условий:

• AliasedType и DynamicType похожи.
• AliasedType — это (возможно, квалифицированный по резюме) signed или unsigned вариант DynamicType.
• AliasedType равно std::byte, (начиная с C++17) char или unsigned char: это позволяет исследовать объектное представление любого объекта в виде массива байтов.

[expr.reinterpret.cast]/7 :

Указатель объекта может быть явно преобразован в указатель объекта другого типа.

[basic.compound]/3:

Тип указателя на cv void или указатель на тип объекта называется типом указателя объекта.

Однако вам не нужно использовать reinterpret_cast. Каждый тип указателя на объект, чей указанный тип является cv-unqualified, неявно преобразуется в void*, а обратное может быть сделано с помощью static_cast.