你得到的保证是sizeof(char) == 1。没有其他保证，包括没有保证sizeof(int *) == sizeof(double *)。

在实践中，指针的大小在16位系统上为2(如果您能找到一个)，在32位系统上为4，在64位系统上为8，但是依赖于给定的大小并不能获得任何东西。

从技术上讲，C标准只保证sizeof(char) == 1，其余的取决于实现。但在现代x86架构(例如Intel/AMD芯片)上，这是相当可预测的。

You've probably heard processors described as being 16-bit, 32-bit, 64-bit, etc. This usually means that the processor uses N-bits for integers. Since pointers store memory addresses, and memory addresses are integers, this effectively tells you how many bits are going to be used for pointers. sizeof is usually measured in bytes, so code compiled for 32-bit processors will report the size of pointers to be 4 (32 bits / 8 bits per byte), and code for 64-bit processors will report the size of pointers to be 8 (64 bits / 8 bits per byte). This is where the limitation of 4GB of RAM for 32-bit processors comes from -- if each memory address corresponds to a byte, to address more memory you need integers larger than 32-bits.

出于完整性和历史兴趣，在64位世界中，对于长类型和长类型的大小有不同的平台约定，分别命名为LLP64和LP64，主要在unix类型系统和Windows之间。一个名为ILP64的旧标准也使int = 64位宽。

微软保留了LLP64，其中longlong = 64位宽，但long保留为32位宽，以便于移植。

Type           ILP64   LP64   LLP64
char              8      8       8
short            16     16      16
int              64     32      32
long             64     64      32
long long        64     64      64
pointer          64     64      64

来源:https://stackoverflow.com/a/384672/48026

如果您正在为64位机器编译，那么它可能是8。

The size of the pointer basically depends on the architecture of the system in which it is implemented. For example the size of a pointer in 32 bit is 4 bytes (32 bit ) and 8 bytes(64 bit ) in a 64 bit machines. The bit types in a machine are nothing but memory address, that it can have. 32 bit machines can have 2^32 address space and 64 bit machines can have upto 2^64 address spaces. So a pointer (variable which points to a memory location) should be able to point to any of the memory address (2^32 for 32 bit and 2^64 for 64 bit) that a machines holds.

由于这个原因，我们看到指针的大小在32位机器中是4字节，在64位机器中是8字节。

除了人们所说的64位(或其他)系统，还有其他类型的指针，而不是指向对象的指针。

指向成员的指针几乎可以是任何大小，这取决于编译器如何实现它们:它们甚至不一定都是相同的大小。尝试一个POD类的指向成员的指针，然后尝试一个继承自具有多个基类的基类之一的指向成员的指针。什么乐趣。