Правильный способ литья типов указателей

Question

Учитывая following code (и тот факт, что VirtualAlloc() returns a void*):

BYTE* pbNext = reinterpret_cast<BYTE*>(
    VirtualAlloc(NULL, cbAlloc, MEM_COMMIT, PAGE_READWRITE)); 

reinterpret_cast почему выбран вместо static_cast?

Раньше я думал, что reinterpret_cast в порядке, например. (например, DWORD_PTR), но для отливки от void* до BYTE* не является static_cast ОК?

Есть ли какие-либо (тонкие?) Различия в данном конкретном случае, или они являются как действительными, так и действительными указателями?

Есть ли стандарт C++ для этого случая, предлагая путь вместо другого?

Answer 1

Либо акцент допустим для указателей на основные типы, поэтому вы правы, что static_cast в порядке.

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

Здесь два отливки отличаются. static_cast сделает соответствующую настройку. reinterpret_cast избежит изменения хранимого значения указателя.

По этой причине, это хорошее общее правило static_cast между типами указателей, если вы не знаете что reinterpret_cast желателен.

Answer 2

Использование static_cast для указания места на картинке и обратно от void*.

reinterpret_cast, с другой стороны, гарантирует, что если вы отбросите указатель от одного типа к другому и вернитесь к исходному типу, адрес будет сохранен.

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

И с C++11 Я помню, что использование reinterpret_cast для void* имеет четко определенное поведение. До этого такое поведение было запрещено.

It is not permitted to use reinterpret_cast to convert between pointers to object type and pointers to void. 

Предлагаемая резолюция (август, 2010):

Изменить пункт 7 5.2.10 [expr.reinterpret.cast] следующим образом:

указатель на объект может быть явно конвертировано в указатель объекта другой тип. Когда prvalue v типа «указатель на T1» равен , преобразованный в тип «указатель на cv T2», результатом является static_cast (static_cast (v)), если оба T1 и T2 являются стандартными макетами типов (3.9 [ basic.types]), а требования к выравниванию T2 не являются более строгими, чем требования к T1, или если любой тип недействителен.

Преобразование prvalue типа «указатель на Т1» к типу «указатель на Т2» (где T1 и T2 типы объектов и где требования к выравниванию Т2 не являются более жесткими, чем T1) и обратно его исходный тип дает исходное значение указателя. Результат любого другого такого преобразования указателя не указан.

Дополнительная информация here.

Jesse Good для связи.

Answer 3

Вы должны static_cast. Используйте static_cast в тех случаях, когда вы уничтожаете неявное преобразование.

В этом конкретном случае, однако, нет разницы, потому что вы конвертируете с void*. Но в целом, reinterpret_cast ния между двумя указателями объекта определяется как (§5.2.10/7):

указатель на объект может быть явно преобразован в указатель на объект такого типа, ди и далее различны. Когда prvalue v типа «указатель на T1» преобразуются к типу «указателю на сорт T2», результата static_cast<cv T2*>(static_cast<cv void*>(v)) если оба T1 и T2 являются типами стандартного макета и требование выравнивания T2 которые нет жестче, чем те, от T1, или если один из типов - void. Преобразование указателя типа «указатель на« T1 »в тип« указатель на T2 »(где T1 и T2 - это типы объектов, а требования к выравниванию T2 не более строгие, чем значения T1) и обратно к исходному типу дает оригинал значение указателя. Результат любого другого такого преобразования указателя не определен.

Emphasis mine. С T1 для вас уже void*, литой до void* в reinterpret_cast ничего не делает. Это не верно, в общем, что и Drew Dormann is saying:

#include <iostream> 

template <typename T> 
void print_pointer(const volatile T* ptr) 
{ 
    // this is needed by oversight in the standard 
    std::cout << static_cast<void*>(const_cast<T*>(ptr)) << std::endl; 
} 

struct base_a {}; 
struct base_b {}; 
struct derived : base_a, base_b {}; 

int main() 
{ 
    derived d; 

    base_b* b = &d; // implicit cast 

    // undo implicit cast with static_cast 
    derived* x = static_cast<derived*>(b); 

    // reinterpret the value with reinterpret_cast 
    derived* y = reinterpret_cast<derived*>(b); 

    print_pointer(&d); 
    print_pointer(x); 
    print_pointer(y); 
} 

Выход:

00CBFD5B
00CBFD5B
00CBFD5C

(Обратите внимание, что из-за y на самом деле не точка до derived, используя это неопределенное поведение.)

Здесь reinterpret_cast имеет другое значение, так как оно проходит через void*. Вот почему вы должны использовать static_cast, когда можете, и reinterpret_cast, когда вам нужно.