Как мне обрабатывать преобразование из «void*» в «int» с потерей точности при компиляции 32-битного кода на 64-битной машине?

Проблема в том, что в 32-битном формате int (32-битное целое число) будет содержать значение указателя.

Когда вы переходите на 64-битный, вы больше не можете хранить указатель в int - он недостаточно велик для хранения 64-битного указателя. Для этого предназначен тип intptr_t.

Ваш код не работает. Он не станет менее сломанным, если игнорировать предупреждения, которые дает вам компилятор.

Как вы думаете, произойдет, если вы попытаетесь сохранить 64-битный указатель в 32-битное целое число? Половина ваших данных будет выброшена. Я не могу представить много случаев, когда это правильно или где это не вызовет ошибок.

Исправьте свой код. Или оставайтесь на 32-битной платформе, на которой сейчас работает код.

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

Если эти типы недоступны, size_t или ptrdiff_t также достаточно велики, чтобы содержать указатель на большинстве (не на всех) платформах. Или используйте long (обычно 64-битный на 64-битных платформах в компиляторе GCC) или long long (тип C99, который большинство, но не все компиляторы, поддерживают в C++), или какой-либо другой целочисленный тип, определяемый реализацией, который, по крайней мере, Ширина 64 бита на 64-битной платформе.

Я предполагаю, что ситуация OP заключается в том, что void* используется в качестве общего хранилища для int, где void* больше, чем int. Так, например:

int i = 123;
void *v = (void*)i;    // 64bit void* being (ab)used to store 32bit value
[..]
int i2 = (int)v;       // we want our 32bits of the 64bit void* back

Компилятору не нравится последняя строка.

Я не собираюсь рассуждать о том, правильно или неправильно так злоупотреблять пустотой*. Если вы действительно хотите обмануть компилятор, следующая техника работает даже с -Wall:

int i2 = *((int*)&v);

Здесь он берет адрес v, преобразует адрес в указатель нужного типа данных, а затем следует за указателем.

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

Даже если бы компилятор не выдал ошибки, код, скорее всего, не заработал бы. Код необходимо изменить и проверить на совместимость с 64-битной системой.

Приведение указателя к int ужасно с точки зрения переносимости. Размер int определяется сочетанием компилятора и архитектуры. Вот почему был создан заголовок stdint.h, чтобы вы могли явно указать размер типа, который вы используете на разных платформах с разными размерами слов.

Вам лучше перейти к uintptr_t или intptr_t (из stdint.h и выбрать тот, который лучше всего соответствует нужной вам подписи).

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

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

Если вы подавите ошибки, это может даже работать какое-то время. Пока указатель указывает на адрес в первых 4 ГБ, старшие 32 бита будут равны 0, и вы не потеряете никаких данных. Но как только вы получите адрес> 4 ГБ, ваш код начнет «таинственным образом» не работать.

Что вам нужно сделать, так это изменить любой int, который может содержать указатель на intptr_t.

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

Подавление предупреждений — плохая идея, но может быть флаг компилятора для использования 64-битных целых чисел, в зависимости от вашего компилятора и архитектуры, и это безопасный способ решить проблему (при условии, что что код также не предполагал, что целые числа являются 32-разрядными). Для gcc флаг -m64.

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

Как определено текущим стандартом C++, не существует целочисленного типа, который гарантированно содержит указатель. Некоторые платформы будут иметь intptr_t, но это не стандартная функция C++. По сути, обработка битов указателя, как если бы они были целыми числами, не является переносимой задачей (хотя это можно заставить работать на многих платформах).

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

typedef void * handle_t;

Если причиной приведения является выполнение арифметики указателя с байтовой гранулярностью, то, вероятно, лучший способ - это привести к (char const *) и выполнить математику с этим.

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

Я столкнулся с подобной проблемой. Я решил это следующим образом:

 #ifdef 64BIT
 typedef uint64_t tulong;
 #else
 typedef uint32_t tulong;
 #endif

 void * ptr = NULL; //Whatever you want to keep it.
 int  i;
 i = (int)(tulong)ptr;

Я думаю, проблема заключается в приведении указателя к более короткому типу данных. Но для более крупного типа до int работает нормально.

Я преобразовал эту проблему из приведения типа указателя к long в приведение типа 64-битного целого числа к 32-битному целому, и это сработало нормально. Я все еще ищу вариант компилятора в GCC/Clang.

Иногда разумно разделить 64-битный элемент на два 32-битных элемента. Вот как вы это сделаете:

Заголовочный файл:

//You only need this if you haven't got a definition of UInt32 from somewhere else
typedef unsigned int UInt32;

//x, when cast, points to the lower 32 bits
#define LO_32(x) (*( (UInt32 *) &x))

//address like an array to get to the higher bits (which are in position 1)
#define HI_32(x) (*( ( (UInt32 *) &x) + 1)) 

Исходный файл:

//Wherever your pointer points to
void *ptr = PTR_LOCATION 

//32-bit UInt containing the upper bits
UInt32 upper_half = HI_32(ptr); 

//32-bit UInt containing the lower bits
UInt32 lower_half = LO_32(ptr);