简短的总结 (我也会把它放在顶部):

将指针视为地址通常是一个很好的学习工具，并且通常是普通数据类型指针的实际实现。

(1)但是在许多，也许是大多数编译器上，指向函数的指针不是地址，而是比地址大(通常是2倍，有时更多)，或者实际上是指向内存中结构体的指针，而不是包含函数地址和常量池之类的东西。

(2)指向数据成员的指针和指向方法的指针通常更奇怪。

(3)遗留的x86代码的FAR和NEAR指针问题

(4)几个例子，最著名的是IBM AS/400，具有安全的“胖指针”。

我相信你能找到更多。

细节:

UMMPPHHH ! !到目前为止，许多答案都是相当典型的“程序员菜鸟”答案——但不是编译器菜鸟或硬件菜鸟。因为我假装是一个硬件弱项，并且经常与编译器弱项一起工作，让我抛出我的意见:

在许多(可能是大多数)C编译器中，指向类型为T的数据的指针实际上是T的地址。

很好。

但是，即使在许多这样的编译器上，某些指针也不是地址。你可以通过sizeof(ThePointer)来判断。

For example, pointers to functions are sometimes quite a lot bigger than ordinary addresses. Or, they may involve a level of indirection. This article provides one description, involving the Intel Itanium processor, but I have seen others. Typically, to call a function you must know not only the address of the function code, but also the address of the function's constant pool - a region of memory from which constants are loaded with a single load instruction, rather than the compiler having to generate a 64 bit constant out of several Load Immediate and Shift and OR instructions. So, rather than a single 64 bit address, you need 2 64 bit addresses. Some ABIs (Application Binary Interfaces) move this around as 128 bits, whereas others use a level of indirection, with the function pointer actually being the address of a function descriptor that contains the 2 actual addresses just mentioned. Which is better? Depends on your point of view: performance, code size, and some compatibility issues - often code assumes that a pointer can be cast to a long or a long long, but may also assume that the long long is exactly 64 bits. Such code may not be standards compliant, but nevertheless customers may want it to work.

我们中的许多人都对旧的英特尔x86分段架构有痛苦的记忆，有NEAR指针和FAR指针。值得庆幸的是，这些几乎已经灭绝了，所以只有一个快速的总结:在16位实模式中，实际的线性地址是

LinearAddress = SegmentRegister[SegNum].base << 4 + Offset

而在保护模式下，它可能是

LinearAddress = SegmentRegister[SegNum].base + offset

with the resulting address being checked against a limit set in the segment. Some programs used not really standard C/C++ FAR and NEAR pointer declarations, but many just said *T --- but there were compiler and linker switches so, for example, code pointers might be near pointers, just a 32 bit offset against whatever is in the CS (Code Segment) register, while the data pointers might be FAR pointers, specifying both a 16 bit segment number and a 32 bit offset for a 48 bit value. Now, both of these quantities are certainly related to the address, but since they aren't the same size, which of them is the address? Moreover, the segments also carried permissions - read-only, read-write, executable - in addition to stuff related to the actual address.

A more interesting example, IMHO, is (or, perhaps, was) the IBM AS/400 family. This computer was one of the first to implement an OS in C++. Pointers on this machime were typically 2X the actual address size - e.g. as this presentation says, 128 bit pointers, but the actual addresses were 48-64 bits, and, again, some extra info, what is called a capability, that provided permissions such as read, write, as well as a limit to prevent buffer overflow. Yes: you can do this compatibly with C/C++ -- and if this were ubiquitous, the Chinese PLA and slavic mafia would not be hacking into so many Western computer systems. But historically most C/C++ programming has neglected security for performance. Most interestingly, the AS400 family allowed the operating system to create secure pointers, that could be given to unprivileged code, but which the unprivileged code could not forge or tamper with. Again, security, and while standards compliant, much sloppy non-standards compliant C/C++ code will not work in such a secure system. Again, there are official standards, and there are de-facto standards.

现在，我将放下我的安全演讲，并提到指针(各种类型)通常不是真正地址的其他一些方式:指向数据成员的指针，指向成员函数方法的指针，以及它们的静态版本比普通地址更大。正如这篇文章所说:

有许多方法可以解决这个问题[与单继承和多继承以及虚拟继承有关的问题]。Visual Studio编译器决定如何处理它:指向多重继承类的成员函数的指针实际上是一个结构。” 他们接着说:“强制转换函数指针可以改变它的大小!”

从我对安全性的评论中，您可能会猜到，我曾经参与过C/ c++硬件/软件项目，在这些项目中，指针更像是一种能力，而不是原始地址。

我还可以继续，但我希望你们能明白。

简短的总结 (我也会把它放在顶部):

(0)将指针视为地址通常是一个很好的学习工具，并且通常是普通数据类型指针的实际实现。

(1)但是在许多，也许是大多数编译器上，指向函数的指针不是地址，而是比地址大(通常是2X，有时更多)，或者实际上是指向内存中结构体的指针，而不是包含函数地址和常量池之类的东西。

(2)指向数据成员的指针和指向方法的指针通常更奇怪。

(3)遗留的x86代码的FAR和NEAR指针问题

(4)几个例子，最著名的是IBM AS/400，具有安全的“胖指针”。

我相信你能找到更多。

把指针看作地址是一种近似。像所有的近似值一样，它有时足够有用，但也不准确，这意味着依赖它会带来麻烦。

指针就像一个地址，它指出在哪里可以找到一个对象。这种类比的一个直接限制是，并非所有指针都实际包含地址。NULL是一个指针，它不是地址。指针变量的内容实际上可以是以下三种类型之一:

对象的地址，可以被解引用(如果p包含x的地址，则表达式*p与x的值相同); 一个空指针，null是一个例子; 无效内容，不指向对象(如果p不持有有效值，则*p可以做任何事情(“未定义行为”)，导致程序崩溃是相当常见的可能性)。

此外，更准确的说法是，一个指针(如果有效且非空)包含一个地址:指针指出在哪里可以找到一个对象，但还有更多与之相关的信息。

In particular, a pointer has a type. On most platforms, the type of the pointer has no influence at runtime, but it has an influence that goes beyond the type at compile time. If p is a pointer to int (int *p;), then p + 1 points to an integer which is sizeof(int) bytes after p (assuming p + 1 is still a valid pointer). If q is a pointer to char that points to the same address as p (char *q = p;), then q + 1 is not the same address as p + 1. If you think of pointer as addresses, it is not very intuitive that the “next address” is different for different pointers to the same location.

It is possible in some environments to have multiple pointer values with different representations (different bit patterns in memory) that point to the same location in memory. You can think of these as different pointers holding the same address, or as different addresses for the same location — the metaphor isn't clear in this case. The == operator always tells you whether the two operands are pointing to the same location, so on these environments you can have p == q even though p and q have different bit patterns.

甚至在某些环境中，指针携带除地址以外的其他信息，例如类型或权限信息。作为一名程序员，你很容易在生活中不会遇到这些问题。

在某些环境中，不同类型的指针具有不同的表示形式。你可以把它想象成不同类型的地址有不同的表示。例如，一些体系结构有字节指针和字指针，或者对象指针和函数指针。

总而言之，只要记住这一点，将指针视为地址并不太糟糕

它只有有效的，非空的地址指针; 同一个位置可以有多个地址; 你不能对地址进行算术运算，地址上也没有顺序; 指针还携带类型信息。

反过来就麻烦多了。并不是所有看起来像地址的东西都可以是指针。在深层的某个地方，任何指针都表示为可以作为整数读取的位模式，并且您可以说这个整数是一个地址。但反过来说，不是每个整数都是指针。

首先有一些众所周知的限制;例如，在程序地址空间之外指定位置的整数不能是有效指针。未对齐的地址不能为需要对齐的数据类型创建有效指针;例如，在int需要4字节对齐的平台上，0x7654321不能是有效的int*值。

然而，它远远不止于此，因为当您将指针设置为整数时，您就会遇到很多麻烦。这个问题的很大一部分是优化编译器在微优化方面比大多数程序员预期的要好得多，因此他们对程序如何工作的思维模型是严重错误的。仅仅因为指针具有相同的地址并不意味着它们是等价的。例如，考虑下面的代码片段:

unsigned int x = 0;
unsigned short *p = (unsigned short*)&x;
p[0] = 1;
printf("%u = %u\n", x, *p);

您可能会期望，在sizeof(int)==4和sizeof(short)==2的普通机器上，这要么打印1 = 1?(little-endian)还是65536 = 1?(大端)。但在我的64位Linux PC上，GCC 4.4:

$ c99 -O2 -Wall a.c && ./a.out 
a.c: In function ‘main’:
a.c:6: warning: dereferencing pointer ‘p’ does break strict-aliasing rules
a.c:5: note: initialized from here
0 = 1?

在这个简单的例子中，GCC会提醒我们哪里出了问题——在更复杂的例子中，编译器可能不会注意到。由于p与&x的类型不同，改变p指向的对象不会影响&x指向的对象(除了一些定义良好的异常)。因此，编译器可以自由地将x的值保存在寄存器中，而不会在*p更改时更新该寄存器。程序解引用两个指向相同地址的指针，得到两个不同的值!

The moral of this example is that thinking of a (non-null valid) pointer as an address is fine, as long as you stay within the precise rules of the C language. The flip side of the coin is that the rules of the C language are intricate, and difficult to get an intuitive feeling for unless you know what happens under the hood. And what happens under the hood is that the tie between pointers and addresses is somewhat loose, both to support “exotic” processor architectures and to support optimizing compilers.

因此，可以将指针作为地址作为理解的第一步，但不要过于遵循这种直觉。

指针是一种在C/ c++中本地可用的变量类型，包含一个内存地址。像任何其他变量一样，它有自己的地址并占用内存(数量是特定于平台的)。

由于混淆，您将看到的一个问题是试图通过简单地按值传递指针来更改函数中的引用。这将复制函数作用域内的指针，对这个新指针“指向”的地方的任何更改都不会改变调用该函数的作用域内指针的引用。为了修改函数中的实际指针，通常会将一个指针传递给另一个指针。

指针只是另一个变量，用来保存内存位置的地址(通常是另一个变量的内存地址)。

C或c++指针与简单内存地址的另一个不同之处是，我在其他答案中没有看到不同的指针类型(尽管考虑到它们的总大小，我可能忽略了它)。但它可能是最重要的一个，因为即使是经验丰富的C/ c++程序员也会被它绊倒:

编译器可能会假设不兼容类型的指针不指向相同的地址，即使它们很明显指向相同的地址，这可能会导致简单的pointer==address模型不可能出现的行为。考虑以下代码(假设sizeof(int) = 2*sizeof(short)):

unsigned int i = 0;
unsigned short* p = (unsigned short*)&i;
p[0]=p[1]=1;

if (i == 2 + (unsigned short)(-1))
{
  // you'd expect this to execute, but it need not
}

if (i == 0)
{
  // you'd expect this not to execute, but it actually may do so
}

注意，char*有一个例外，所以使用char*操作值是可能的(尽管不是很可移植)。

简短的总结 (我也会把它放在顶部):

将指针视为地址通常是一个很好的学习工具，并且通常是普通数据类型指针的实际实现。

(1)但是在许多，也许是大多数编译器上，指向函数的指针不是地址，而是比地址大(通常是2倍，有时更多)，或者实际上是指向内存中结构体的指针，而不是包含函数地址和常量池之类的东西。

(2)指向数据成员的指针和指向方法的指针通常更奇怪。

(3)遗留的x86代码的FAR和NEAR指针问题

(4)几个例子，最著名的是IBM AS/400，具有安全的“胖指针”。

我相信你能找到更多。

细节:

UMMPPHHH ! !到目前为止，许多答案都是相当典型的“程序员菜鸟”答案——但不是编译器菜鸟或硬件菜鸟。因为我假装是一个硬件弱项，并且经常与编译器弱项一起工作，让我抛出我的意见:

在许多(可能是大多数)C编译器中，指向类型为T的数据的指针实际上是T的地址。

很好。

但是，即使在许多这样的编译器上，某些指针也不是地址。你可以通过sizeof(ThePointer)来判断。

For example, pointers to functions are sometimes quite a lot bigger than ordinary addresses. Or, they may involve a level of indirection. This article provides one description, involving the Intel Itanium processor, but I have seen others. Typically, to call a function you must know not only the address of the function code, but also the address of the function's constant pool - a region of memory from which constants are loaded with a single load instruction, rather than the compiler having to generate a 64 bit constant out of several Load Immediate and Shift and OR instructions. So, rather than a single 64 bit address, you need 2 64 bit addresses. Some ABIs (Application Binary Interfaces) move this around as 128 bits, whereas others use a level of indirection, with the function pointer actually being the address of a function descriptor that contains the 2 actual addresses just mentioned. Which is better? Depends on your point of view: performance, code size, and some compatibility issues - often code assumes that a pointer can be cast to a long or a long long, but may also assume that the long long is exactly 64 bits. Such code may not be standards compliant, but nevertheless customers may want it to work.

我们中的许多人都对旧的英特尔x86分段架构有痛苦的记忆，有NEAR指针和FAR指针。值得庆幸的是，这些几乎已经灭绝了，所以只有一个快速的总结:在16位实模式中，实际的线性地址是

LinearAddress = SegmentRegister[SegNum].base << 4 + Offset

而在保护模式下，它可能是

LinearAddress = SegmentRegister[SegNum].base + offset

with the resulting address being checked against a limit set in the segment. Some programs used not really standard C/C++ FAR and NEAR pointer declarations, but many just said *T --- but there were compiler and linker switches so, for example, code pointers might be near pointers, just a 32 bit offset against whatever is in the CS (Code Segment) register, while the data pointers might be FAR pointers, specifying both a 16 bit segment number and a 32 bit offset for a 48 bit value. Now, both of these quantities are certainly related to the address, but since they aren't the same size, which of them is the address? Moreover, the segments also carried permissions - read-only, read-write, executable - in addition to stuff related to the actual address.

A more interesting example, IMHO, is (or, perhaps, was) the IBM AS/400 family. This computer was one of the first to implement an OS in C++. Pointers on this machime were typically 2X the actual address size - e.g. as this presentation says, 128 bit pointers, but the actual addresses were 48-64 bits, and, again, some extra info, what is called a capability, that provided permissions such as read, write, as well as a limit to prevent buffer overflow. Yes: you can do this compatibly with C/C++ -- and if this were ubiquitous, the Chinese PLA and slavic mafia would not be hacking into so many Western computer systems. But historically most C/C++ programming has neglected security for performance. Most interestingly, the AS400 family allowed the operating system to create secure pointers, that could be given to unprivileged code, but which the unprivileged code could not forge or tamper with. Again, security, and while standards compliant, much sloppy non-standards compliant C/C++ code will not work in such a secure system. Again, there are official standards, and there are de-facto standards.

现在，我将放下我的安全演讲，并提到指针(各种类型)通常不是真正地址的其他一些方式:指向数据成员的指针，指向成员函数方法的指针，以及它们的静态版本比普通地址更大。正如这篇文章所说:

有许多方法可以解决这个问题[与单继承和多继承以及虚拟继承有关的问题]。Visual Studio编译器决定如何处理它:指向多重继承类的成员函数的指针实际上是一个结构。” 他们接着说:“强制转换函数指针可以改变它的大小!”

从我对安全性的评论中，您可能会猜到，我曾经参与过C/ c++硬件/软件项目，在这些项目中，指针更像是一种能力，而不是原始地址。

我还可以继续，但我希望你们能明白。

简短的总结 (我也会把它放在顶部):

(0)将指针视为地址通常是一个很好的学习工具，并且通常是普通数据类型指针的实际实现。

(1)但是在许多，也许是大多数编译器上，指向函数的指针不是地址，而是比地址大(通常是2X，有时更多)，或者实际上是指向内存中结构体的指针，而不是包含函数地址和常量池之类的东西。

(2)指向数据成员的指针和指向方法的指针通常更奇怪。

(3)遗留的x86代码的FAR和NEAR指针问题

(4)几个例子，最著名的是IBM AS/400，具有安全的“胖指针”。

我相信你能找到更多。