Почему “длинен *” и “интервал *” не совместимый в 32-битном коде?

Since I don't particularly like any of the answers given so far, I went to the C++ standard:

4.7 Integral conversions [conv.integral]

1 An rvalue of an integer type can be converted to an rvalue of another integer type. An rvalue of an enumeration type can be converted to an rvalue of an integer type.

This says it is allowed to implicitly convert one integer to another, so the two types (as they are the same size), are interchangeable as rvalues.

4.10 Pointer conversions [conv.ptr]

1 An integral constant expression (expr.const) rvalue of integer type that evaluates to zero (called a null pointer constant) can be converted to a pointer type. The result is a value (called the null pointer value of that type) distinguishable from every pointer to an object or function. Two null pointer values of the same type shall compare equal. The conversion of a null pointer constant to a pointer to cv-qualified type is a single conversion, and not the sequence of a pointer conversion followed by a qualification conversion (conv.qual).

2 An rvalue of type "pointer to cv T," where T is an object type, can be converted to an rvalue of type "pointer to cv void." The result of converting a "pointer to cv T" to a "pointer to cv void" points to the start of the storage location where объект типа T находится, как если объект является наиболее производным объект ( intro.object ) типа T (то есть не подобъект базового класса).

3 rvalue типа "указатель на cv D," где D - тип класса, может быть преобразовано в rvalue типа "указатель на cv B", где B - основание класс ( класс. производный ) D. Если B - недоступный ( class.access ) или неоднозначный ( class.member.lookup ) базовый класс D, программа, которая требует этого преобразование плохо сформировано. Результат преобразования - это указатель на подобъект базового класса объект производного класса. Нуль значение указателя преобразуется в нуль pointer value of the destination type.

It is only allowed to implicitly convert:

• 0 to any pointer type (making it a null pointer)
• any pointer type to void* (properly cv-qualified)
• derived pointer to a base pointer (properly cv-qualified)

So even though the underlying machine type is the same, it is not allowed to implicitly convert between the two types.

Это потому, что на некоторых платформах long и int имеют разный размер.

16 bit:
long=32bits
int=16bits

32bit:
long=32bits
int=32bits

64bit(ILP64):
long=64bits
int=64bits

64bit(LP64):
long=64bits
int=32bits

64bit(LLP64): (what windows uses for whatever reason)
long long=64bits
long=32bits
int=32bits

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

long foo(int bar);
int foo(int bar);

int * и long * - разные типы, которые не обязательно совпадают. В каждой реальной реализации, я думаю, они есть, но это ни здесь, ни там для компилятора, соответствующего стандартам.

Я считаю, что это была одна из первых машин PDP, в которой char * был больше, чем int *. Причиной этого был странный размер int на этой архитектуре (36 бит). Таким образом, система будет упаковывать несколько 9-битных символов в один int, поэтому char * содержит адрес в формате (int *, смещение внутри int). **

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

* * Я не могу найти ссылки на это, так что источником этого мог быть теоретический (но все еще действительный) пример, а не реальная реализация. C ++ FAQ Lite

int и long определены как разные типы, поэтому вы можете программировать переносимые.

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

#include <stdio.h> 

void foo_int( int *a ){ printf("a: %i\n", *a ); }

#define foo_int(a)  foo_int( (int*)a ) 

int main(){
  long l = 12;
  foo_int( &l ); // no warning, runs as expected
  foo_int(  l ); // no warning, segmentation fault
}