blocks|key|1447188|text|你得到的保证是sizeof(char)+==+1。没有其他保证，包括不保证sizeof(int+*)+==+sizeof(double+*)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1447189|在实践中，16位系统上的指针大小为2(如果可以找到的话)，32位系统上的指针大小为4，64位系统上的指针大小为8，但是依赖于给定的大小没有任何好处。|1447190|entityMap^0|7|H|11|X|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

The guarantee you get is that <code>sizeof(char) == 1</code>. There are no other guarantees, including no guarantee that <code>sizeof(int *) == sizeof(double *)</code>.

In practice, pointers will be size 2 on a 16-bit system (if you can find one), 4 on a 32-bit system, and 8 on a 64-bit system, but there's nothing to be gained in relying on a given size.

blocks|key|1447360|text|即使在普通的x86+32位平台上，您也可以获得各种指针大小，请尝试以下示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447361|struct+A+{};

struct+B+:+virtual+public+A+{};

struct+C+{};

struct+D+:+public+A,+public+C+{};

int+main()
{
++++cout+<<+"A:"+<<+sizeof(void+(A::*)())+<<+endl;
++++cout+<<+"B:"+<<+sizeof(void+(B::*)())+<<+endl;
++++cout+<<+"D:"+<<+sizeof(void+(D::*)())+<<+endl;
}|code-block|syntax|javascript|1447362|在Visual+C%2B%2B+2008下，成员函数指针的大小分别为4、12和8。|1447363|Raymond+Chen谈到了这个here。|offset|length|1447364|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/oldnewthing/archive/2004/02/09/70002.aspx^0|0|0|0|H|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Even on a plain x86 32 bit platform, you can get a variety of pointer sizes, try this out for an example:

<pre><code>struct A {};

struct B : virtual public A {};

struct C {};

struct D : public A, public C {};

int main()
{
 cout &lt;&lt; "A:" &lt;&lt; sizeof(void (A::*)()) &lt;&lt; endl;
 cout &lt;&lt; "B:" &lt;&lt; sizeof(void (B::*)()) &lt;&lt; endl;
 cout &lt;&lt; "D:" &lt;&lt; sizeof(void (D::*)()) &lt;&lt; endl;
}
</code></pre>

Under Visual C++ 2008, I get 4, 12 and 8 for the sizes of the pointers-to-member-function.

Raymond Chen talked about this <a href="http://blogs.msdn.com/oldnewthing/archive/2004/02/09/70002.aspx" rel="noreferrer">here</a>.

blocks|key|1661718|text|如果你是为64位机器编译，那么它可能是8。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1661719|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

if you are compiling for a 64-bit machine, then it may be 8.

blocks|key|1447328|text|从技术上讲，C标准只保证sizeof(char)+==为1，其余的取决于实现。但在现代x86架构(例如英特尔/AMD芯片)上，这是相当可预测的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447329|您可能听说过处理器是16位、32位、64位等等。这通常意味着处理器使用N位表示整数。由于指针存储内存地址，而内存地址是整数，这有效地告诉您指针将使用多少位。sizeof通常以字节为单位进行度量，因此针对32位处理器编译的代码将报告指针大小为4+(32位/8位/字节)，而针对64位处理器的代码将报告指针大小为8+(64位/8位/字节)。这就是32位处理器的4+4GB限制的原因--如果每个内存地址对应一个字节，为了寻址更多的内存，您需要大于32位的整数。|1447330|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Technically speaking, the C standard only guarantees that sizeof(char) == 1, and the rest is up to the implementation. But on modern x86 architectures (e.g. Intel/AMD chips) it's fairly predictable.

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.

blocks|key|1447491|text|指针的大小基本上取决于实现它的系统的体系结构。例如，在64位机器中，32位指针的大小是4字节(32位)和8字节(64位)。机器中的位类型只是它可以拥有的内存地址。32位机器可以有2%5E32地址空间，64位机器可以有最多2%5E64地址空间。因此，指针(指向内存位置的变量)应该能够指向机器持有的任何内存地址(2%5E32+for+32+bit+and+2%5E64+for+64+bit)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1447492|由于这个原因，我们看到指针的大小在32位机器中为4字节，在64位机器中为8字节。|1447493|entityMap^0|2H|4|30|4|47|Z|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

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 <code>2^32</code> address space and 64 bit machines can have upto <code>2^64</code> address spaces. So a pointer (variable which points to a memory location) should be able to point to any of the memory address (<code>2^32 for 32 bit and 2^64 for 64 bit</code>) that a machines holds.

Because of this reason we see the size of a pointer to be 4 bytes in 32 bit machine and 8 bytes in a 64 bit machine.

blocks|key|1447232|text|除了16/32/64位的差异之外，还可能发生更奇怪的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447233|有些机器的sizeof(int+*)是一个值，可能是4，但sizeof(char+*)更大。为了正确实现C/C%2B%2B标准，自然寻址单词而不是字节的机器必须“扩充”字符指针，以指定您真正想要的单词的哪一部分。|1447234|现在这是非常不寻常的，因为硬件设计人员已经了解了字节可寻址的价值。|1447235|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

In addition to the 16/32/64 bit differences even odder things can occur.

There have been machines where sizeof(int *) will be one value, probably 4 but where sizeof(char *) is larger. Machines that naturally address words instead of bytes have to "augment" character pointers to specify what portion of the word you really want in order to properly implement the C/C++ standard.

This is now very unusual as hardware designers have learned the value of byte addressability.

blocks|key|1447409|text|在大多数低调微控制器中使用8位和16位指针。这意味着每台洗衣机、微型洗衣机、冰箱、老式电视，甚至是汽车。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447410|你可以说这些与现实世界的编程没有任何关系。但这里有一个现实世界的例子:+Arduino具有1-2-4k内存(取决于芯片)和2个字节的指针。|1447411|它是最新的，便宜的，每个人都可以使用的，值得编码。|1447412|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

8 bit and 16 bit pointers are used in most low profile microcontrollers. That means every washing machine, micro, fridge, older TVs, and even cars.

You could say these have nothing to do with real world programming.
But here is one real world example:
Arduino with 1-2-4k ram (depending on chip) with 2 byte pointers.

It's recent, cheap, accessible for everyone and worths coding for.

blocks|key|1447273|text|除了人们所说的64位(或其他)系统之外，还有其他类型的指针，而不是指向对象的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447274|指向成员的指针几乎可以是任何大小，这取决于编译器如何实现它们:它们甚至不一定都是相同的大小。尝试指向POD类的成员的指针，然后尝试从具有多个基类的某个基类继承的指向成员的指针。太好了。|1447275|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In addition to what people have said about 64-bit (or whatever) systems, there are other kinds of pointer than pointer-to-object. 

A pointer-to-member might be almost any size, depending how they're implemented by your compiler: they aren't necessarily even all the same size. Try a pointer-to-member of a POD class, and then a pointer-to-member inherited from one of the base classes of a class with multiple bases. What fun.

blocks|key|1447032|text|在我的记忆中，它是基于内存地址的大小。因此，在使用32位地址方案的系统上，sizeof将返回4，因为这是4个字节。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447033|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

From what I recall, it's based on the size of a memory address. So on a system with a 32-bit address scheme, sizeof will return 4, since that's 4 bytes.

blocks|key|1447122|text|一般来说，当你在不同的平台上编译时，sizeof(几乎任何东西)都会改变。在32位平台上，指针的大小始终相同。在其他平台上(64位是最明显的例子)，这种情况可能会改变。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447123|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In general, sizeof(pretty much anything) will change when you compile on different platforms. On a 32 bit platform, pointers are always the same size. On other platforms (64 bit being the obvious example) this can change.

blocks|key|1662005|text|不，指针的大小可能会根据架构的不同而有所不同。有许多例外。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1662006|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

No, the size of a pointer may vary depending on the architecture. There are numerous exceptions.

blocks|key|1662251|text|在windows+32位机器上的Turbo+C编译器中，指针和int的大小为2字节。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1662252|所以指针的大小是特定于编译器的。但通常大多数编译器被实现为支持32位的4字节指针变量和64位机器的8字节指针变量)。|1662253|因此，指针的大小在所有机器上并不相同。|1662254|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Size of pointer and int is 2 bytes in Turbo C compiler on windows 32 bit machine. 

So size of pointer is compiler specific. But generally most of the compilers are implemented to support 4 byte pointer variable in 32 bit and 8 byte pointer variable in 64 bit machine). 

So size of pointer is not same in all machines.

blocks|key|1661827|text|指针大小为4字节的原因是因为您正在编译32位体系结构。正如FryGuy所指出的，在64位架构上，您将看到8。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1661828|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The reason the size of your pointer is 4 bytes is because you are compiling for a 32-bit architecture. As FryGuy pointed out, on a 64-bit architecture you would see 8.

blocks|key|1447140|text|指针只是一个地址的容器。在32位机器上，您的地址范围是32位，因此指针将始终是4字节。在64位机器上，如果你有一个64位的地址范围，一个指针将是8个字节。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447141|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A pointer is just a container for an address. On a 32 bit machine, your address range is 32 bits, so a pointer will always be 4 bytes. On a 64 bit machine were you have an address range of 64 bits, a pointer will be 8 bytes.

blocks|key|1447556|text|仅仅为了完整性和历史意义，在64位世界中，对于long和long+long类型的大小有不同的平台约定，名为LLP64和LP64，主要在Unix类型的系统和Windows之间。名为ILP64的旧标准也使int+=64位宽。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447557|微软保留了LLP64，其中龙龙=+64位宽，但为了更容易移植，长时间保持在32位。|1447558|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|code-block|syntax|javascript|1447559|来源：https://stackoverflow.com/a/384672/48026|offset|length|1447560|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/384672/48026^0|0|0|0|3|14|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Just for completeness and historic interest, in the 64bit world there were different platform conventions on the sizes of long and long long types, named LLP64 and LP64, mainly between Unix-type systems and Windows. An old standard named ILP64 also made int = 64-bit wide.

Microsoft maintained LLP64 where longlong = 64 bit wide, but long remained at 32, for easier porting.

<pre><code>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
</code></pre>

Source: <a href="https://stackoverflow.com/a/384672/48026">https://stackoverflow.com/a/384672/48026</a>

For example:
<code>sizeof(char*)</code> returns 4. As does <code>int*</code>, <code>long long*</code>, everything that I've tried. Are there any exceptions to this?

Is the sizeof(some pointer) always equal to four?

微控制器

编译器

Windows

容器

Unix

例如：sizeof(char*)返回4。int*、long long*以及我尝试过的所有内容也是如此。这有什么例外吗？

问sizeof(某个指针)总是等于4吗？
EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问sizeof(某个指针)总是等于4吗？EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问sizeof(某个指针)总是等于4吗？
EN