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

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

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

指针是一个保存内存地址的变量，而不是地址本身。但是，您可以解除对指针的引用-并访问内存位置。

例如:

int q = 10; /*say q is at address 0x10203040*/
int *p = &q; /*means let p contain the address of q, which is 0x10203040*/
*p = 20; /*set whatever is at the address pointed by "p" as 20*/

就是这样。就是这么简单。

一个演示我所说内容的程序，其输出如下:

http://ideone.com/rcSUsb

程序:

#include <stdio.h>

int main(int argc, char *argv[])
{
  /* POINTER AS AN ADDRESS */
  int q = 10;
  int *p = &q;

  printf("address of q is %p\n", (void *)&q);
  printf("p contains %p\n", (void *)p);

  p = NULL;
  printf("NULL p now contains %p\n", (void *)p);
  return 0;
}

你是对的，是理智的。通常，指针只是一个地址，因此您可以将其强制转换为整数并进行任何算术运算。

但有时指针只是地址的一部分。在一些体系结构上，指针被转换为一个增加了基数的地址或使用另一个CPU寄存器。

但是现在，在PC和ARM架构上，使用平面内存模型和原生编译的C语言，可以认为指针是指向一维可寻址RAM中某个位置的整数地址。

我不确定你的来源，但你描述的语言类型来自C标准:

6.5.3.2地址和间接操作符 […] 3.一元&操作符产生其操作数的地址。[…]

所以…是的，指针指向内存地址。至少这是C标准所暗示的意思。

更清楚地说，指针是保存某个地址值的变量。对象的地址(可以存储在指针中)使用一元&操作符返回。

我可以将地址“42 Wallaby Way, Sydney”存储在一个变量中(该变量将是某种“指针”，但由于这不是一个内存地址，所以我们不能正确地称之为“指针”)。您的计算机有内存桶的地址。指针存储地址的值(例如，指针存储值“42 Wallaby Way, Sydney”，这是一个地址)。

编辑:我想对Alexey Frunze的评论进行扩展。

指针到底是什么?让我们看看C标准:

6.2.5类型 […] 20.[…] 指针类型可以从函数类型或对象类型派生，称为引用类型。指针类型描述了一个对象，该对象的值提供了对所引用类型实体的引用。从引用类型T派生的指针类型有时称为“指向T的指针”。从引用类型构造指针类型称为“指针类型派生”。指针类型是一个完整的对象类型。

从本质上讲，指针存储一个值，该值提供对某些对象或函数的引用。种。指针用于存储提供对某些对象或函数引用的值，但情况并非总是如此:

6.3.2.3指针 […] 5. 整数可以转换为任何指针类型。除非像前面指定的那样，否则结果是由实现定义的，可能没有正确对齐，可能没有指向引用类型的实体，并且可能是陷阱表示。

The above quote says that we can turn an integer into a pointer. If we do that (that is, if we stuff an integer value into a pointer instead of a specific reference to an object or function), then the pointer "might not point to an entity of reference type" (i.e. it may not provide a reference to an object or function). It might provide us with something else. And this is one place where you might stick some kind of handle or ID in a pointer (i.e. the pointer isn't pointing to an object; it's storing a value that represents something, but that value may not be an address).

是的，正如Alexey Frunze所说，指针可能没有存储对象或函数的地址。有可能一个指针存储的是某种“句柄”或ID，你可以通过给指针赋某个任意整数值来做到这一点。这个句柄或ID表示什么取决于系统/环境/上下文。只要您的系统/实现能够理解这个值，您就处于良好的状态(但这取决于具体的值和具体的系统/实现)。

通常，指针存储对象或函数的地址。如果它没有存储实际的地址(到对象或函数)，则结果是实现定义的(这意味着究竟发生了什么以及指针现在表示什么取决于您的系统和实现，因此它可能是特定系统上的句柄或ID，但在另一个系统上使用相同的代码/值可能会使程序崩溃)。

结果比我想象的要长……

C标准没有在内部定义指针是什么以及它在内部是如何工作的。这样做的目的是为了不限制平台的数量，在这些平台上，C可以作为编译或解释语言实现。

指针值可以是某种ID或句柄，也可以是几个ID的组合(对x86段和偏移量说你好)，不一定是真正的内存地址。这个ID可以是任何东西，甚至是固定大小的文本字符串。非地址表示可能对C解释器特别有用。

指针只是另一个变量，它通常包含另一个变量的内存地址。指针是一个变量，它也有一个内存地址。

很难确切地说出这些书的作者到底是什么意思。指针是否包含地址取决于如何定义地址和如何定义指针。

从所有的回答来看，有些人认为(1)地址必须是整数，(2)指针不需要是虚的，因为规范中没有这么说。根据这些假设，显然指针不一定包含地址。

然而，我们看到，虽然(2)可能是真的，(1)可能不一定是真的。根据@ corn秸秆的答案，&被称为操作符的地址，这是怎么回事?这是否意味着规范的作者希望指针包含地址?

我们可以说，指针包含一个地址，但地址不一定是整数?也许吧。

我认为所有这些都是废话连篇的迂腐语义学。实际上，这是毫无价值的。你能想到一个编译器以这样的方式生成代码，指针的值不是一个地址吗?如果有，是什么?我也是这么想的……

我认为这本书的作者(第一个摘录声称指针不一定只是地址)可能指的是指针自带固有类型信息这一事实。

例如,

 int x;
 int* y = &x;
 char* z = &x;

y和z都是指针，但y+1和z+1是不同的。如果它们是内存地址，难道这些表达式不会给你相同的值吗?

在这里，把指针当作地址的想法通常会导致悲伤。之所以会出现bug，是因为人们将指针视为地址，而这通常会导致不幸。

55555可能不是指针，尽管它可能是一个地址，但(int*)55555是一个指针。55555+1 = 55556，但是(int*)55555+1是55559(在sizeof(int)方面的+/-差异)。

在这幅图中，

Pointer_p是一个位于0x12345的指针，它指向0x34567的变量variable_v。

它说“因为它让那些不知道地址是什么的人感到困惑”——而且，这是真的:如果你知道地址是什么，你就不会困惑了。从理论上讲，指针是一个指向另一个变量的变量，实际上保存着一个地址，即它所指向的变量的地址。我不知道为什么要隐瞒这个事实，这又不是什么高深的科学。如果你理解了指针，你就离理解计算机的工作原理更近了一步。去吧!

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

指针就像一个地址，它指出在哪里可以找到一个对象。这种类比的一个直接限制是，并非所有指针都实际包含地址。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.

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

指针是表示内存位置的抽象。请注意，这句话并没有说把指针当作内存地址是错误的，它只是说它“通常会导致悲伤”。换句话说，它会让你产生错误的期望。

The most likely source of grief is certainly pointer arithmetic, which is actually one of C's strengths. If a pointer was an address, you'd expect pointer arithmetic to be address arithmetic; but it's not. For example, adding 10 to an address should give you an address that is larger by 10 addressing units; but adding 10 to a pointer increments it by 10 times the size of the kind of object it points to (and not even the actual size, but rounded up to an alignment boundary). With an int * on an ordinary architecture with 32-bit integers, adding 10 to it would increment it by 40 addressing units (bytes). Experienced C programmers are aware of this and put it to all kinds of good uses, but your author is evidently no fan of sloppy metaphors.

There's the additional question of how the contents of the pointer represent the memory location: As many of the answers have explained, an address is not always an int (or long). In some architectures an address is a "segment" plus an offset. A pointer might even contain just the offset into the current segment ("near" pointer), which by itself is not a unique memory address. And the pointer contents might have only an indirect relationship to a memory address as the hardware understands it. But the author of the quote cited doesn't even mention representation, so I think it was conceptual equivalence, rather than representation, that they had in mind.

在理解指针之前，我们需要先理解对象。对象是存在的实体，具有一个称为地址的位置说明符。指针与C语言中的其他变量一样，是一个类型为指针的变量，其内容被解释为支持以下操作的对象的地址。

+ : A variable of type integer (usually called offset) can be added to yield a new pointer
- : A variable of type integer (usually called offset) can be subtracted to yield a new pointer
  : A variable of type pointer can be subtracted to yield an integer (usually called offset)
* : De-referencing. Retrieve the value of the variable (called address) and map to the object the address refers to.
++: It's just `+= 1`
--: It's just `-= 1`

指针是根据它当前引用的对象类型进行分类的。唯一重要的信息是物体的大小。

任何对象都支持& (address of)操作，该操作将对象的位置说明符(地址)作为指针对象类型检索。这将减少围绕命名的混乱，因为调用&作为对象的操作而不是作为结果类型为对象类型的指针的指针是有意义的。

注意:在整个解释中，我省略了内存的概念。

Come to think about it, I think it's a matter of semantics. I don't think the author is right, since the C standard refers to a pointer as holding an address to the referenced object as others have already mentioned here. However, address!=memory address. An address can be really anything as per C standard although it will eventually lead to a memory address, the pointer itself can be an id, an offset + selector (x86), really anything as long as it can describe (after mapping) any memory address in the addressable space.

C指针非常类似于内存地址，但是抽象了与机器相关的细节，以及一些在低级指令集中找不到的特性。

例如，C指针是相对丰富的类型。如果在一个结构数组中增加一个指针，它会很好地从一个结构跳到另一个结构。

指针服从转换规则，并提供编译时类型检查。

有一个特殊的“空指针”值，它在源代码级别是可移植的，但其表示可能不同。如果将值为0的整型常量赋给指针，则该指针的值为空指针。同样，如果你用这种方式初始化一个指针。

指针可以用作布尔变量:如果指针不是null，则为true;如果指针为null，则为false。

在机器语言中，如果空指针是一个有趣的地址，如0xFFFFFFFF，那么您可能必须对该值进行显式测试。C把它藏起来了。即使空指针是0xFFFFFFFF，你也可以使用if (ptr != 0) {/* not null!* /}。

Uses of pointers which subvert the type system lead to undefined behavior, whereas similar code in machine language might be well defined. Assemblers will assemble the instructions you have written, but C compilers will optimize based on the assumption that you haven't done anything wrong. If a float *p pointer points to a long n variable, and *p = 0.0 is executed, the compiler is not required to handle this. A subsequent use of n will not necessary read the bit pattern of the float value, but perhaps, it will be an optimized access which is based on the "strict aliasing" assumption that n has not been touched! That is, the assumption that the program is well-behaved, and so p should not be pointing at n.

在C语言中，指向代码的指针和指向数据的指针是不同的，但在许多体系结构中，它们的地址是相同的。可以开发具有“胖”指针的C编译器，即使目标体系结构没有。胖指针意味着指针不仅仅是机器地址，还包含其他信息，例如用于边界检查的被指向对象的大小信息。可移植编写的程序将很容易移植到这样的编译器。

所以你可以看到，在机器地址和C指针之间有很多语义上的区别。

以下是我过去是如何向一些困惑的人解释的: 指针有两个影响其行为的属性。它有一个值(在典型环境中)是一个内存地址，还有一个类型(告诉您它所指向的对象的类型和大小)。

例如，给定:

union {
    int i;
    char c;
} u;

你可以有三个不同的指针都指向同一个对象:

void *v = &u;
int *i = &u.i;
char *c = &u.c;

如果你比较这些指针的值，它们都是相等的:

v==i && i==c

但是，如果对每个指针加1，就会发现它们所指向的类型变得相关了。

i++;
c++;
// You can't perform arithmetic on a void pointer, so no v++
i != c

此时，变量i和c将具有不同的值，因为i++使i包含下一个可访问的整数的地址，而c++使c指向下一个可寻址的字符。通常，整数比字符占用更多的内存，所以在它们都加一之后，i的值将比c的值更大。

A pointer, like any other variable in C, is fundamentally a collection of bits which may be represented by one or more concatenated unsigned char values (as with any other type of cariable, sizeof(some_variable) will indicate the number of unsigned char values). What makes a pointer different from other variables is that a C compiler will interpret the bits in a pointer as identifying, somehow, a place where a variable may be stored. In C, unlike some other languages, it is possible to request space for multiple variables, and then convert a pointer to any value in that set into a pointer to any other variable within that set.

Many compilers implement pointers by using their bits store actual machine addresses, but that is not the only possible implementation. An implementation could keep one array--not accessible to user code--listing the hardware address and allocated size of all of the memory objects (sets of variables) which a program was using, and have each pointer contain an index into an array along with an offset from that index. Such a design would allow a system to not only restrict code to only operating upon memory that it owned, but also ensure that a pointer to one memory item could not be accidentally converted into a pointer to another memory item (in a system that uses hardware addresses, if foo and bar are arrays of 10 items that are stored consecutively in memory, a pointer to the "eleventh" item of foo might instead point to the first item of bar, but in a system where each "pointer" is an object ID and an offset, the system could trap if code tried to index a pointer to foo beyond its allocated range). It would also be possible for such a system to eliminate memory-fragmentation problems, since the physical addresses associated with any pointers could be moved around.

Note that while pointers are somewhat abstract, they're not quite abstract enough to allow a fully-standards-compliant C compiler to implement a garbage collector. The C compiler specifies that every variable, including pointers, is represented as a sequence of unsigned char values. Given any variable, one can decompose it into a sequence of numbers and later convert that sequence of numbers back into a variable of the original type. Consequently, it would be possible for a program to calloc some storage (receiving a pointer to it), store something there, decompose the pointer into a series of bytes, display those on the screen, and then erase all reference to them. If the program then accepted some numbers from the keyboard, reconstituted those to a pointer, and then tried to read data from that pointer, and if user entered the same numbers that the program had earlier displayed, the program would be required to output the data that had been stored in the calloc'ed memory. Since there is no conceivable way the computer could know whether the user had made a copy of the numbers that were displayed, there would be no conceivable may the computer could know whether the aforementioned memory might ever be accessed in future.

马克·贝西(Mark Bessey)已经说过了，但这一点需要再次强调，直到人们理解为止。

指针与变量的关系比与文字3的关系更大。

指针是一个值(地址)和类型(带有其他属性，如只读)的元组。类型(以及附加参数(如果有的话)可以进一步定义或限制上下文;如。__far ptr， __near ptr:地址的上下文是什么:堆栈，堆，线性地址，某处的偏移量，物理内存或其他。

正是type的属性使得指针算术与整数算术略有不同。

指针不是变量的反例太多了，不容忽视

fopen返回FILE指针。(变量在哪里) 堆栈指针或帧指针通常是不可寻址的寄存器 *(int *)0x1231330 = 13;——将任意整数值转换为pointer_of_integer类型，并在不引入变量的情况下写入/读取整数值

在c程序的生命周期中，会有许多其他没有地址的临时指针实例——因此它们不是变量，而是带有编译时相关类型的表达式/值。

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

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

(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，具有安全的“胖指针”。

我相信你能找到更多。

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*操作值是可能的(尽管不是很可移植)。

快速总结:C地址是一个值，通常表示为具有特定类型的机器级内存地址。

非限定词“指针”有歧义。C语言有指针对象(变量)、指针类型、指针表达式和指针值。

使用“指针”这个词来表示“指针对象”是非常常见的，这可能会导致一些混淆——这就是为什么我试图将“指针”作为形容词而不是名词使用。

C标准，至少在某些情况下，使用“指针”这个词来表示“指针值”。例如，malloc的描述说它“返回空指针或指向已分配空间的指针”。

那么C中的地址是什么呢?它是一个指针值，即某个特定指针类型的值。(除了空指针值不一定被称为“地址”，因为它不是任何东西的地址)。

标准对一元&操作符的描述说它“产生其操作数的地址”。在C标准之外，单词“address”通常用于指(物理或虚拟)内存地址，通常是一个单词大小(无论给定系统上的“word”是什么)。

C“地址”通常实现为机器地址——就像C int值通常实现为机器字一样。但是C地址(指针值)不仅仅是一个机器地址。它是一个通常表示为机器地址的值，它是一个具有特定类型的值。

A pointer value is an address. A pointer variable is an object that can store an address. This is true because that's what the standard defines a pointer to be. It's important to tell it to C novices because C novices are often unclear on the difference between a pointer and the thing it points to (that is to say, they don't know the difference between an envelope and a building). The notion of an address (every object has an address and that's what a pointer stores) is important because it sorts that out.

然而，标准在特定的抽象层次上进行讨论。作者所说的那些“知道地址是关于什么的”，但对C不熟悉的人，必须在不同的抽象级别上学习地址——也许是通过编写汇编语言。不能保证C实现使用与cpu操作码相同的地址表示(在本文中称为“存储地址”)，这些人已经知道。

He goes on to talk about "perfectly reasonable address manipulation". As far as the C standard is concerned there's basically no such thing as "perfectly reasonable address manipulation". Addition is defined on pointers and that is basically it. Sure, you can convert a pointer to integer, do some bitwise or arithmetic ops, and then convert it back. This is not guaranteed to work by the standard, so before writing that code you'd better know how your particular C implementation represents pointers and performs that conversion. It probably uses the address representation you expect, but it it doesn't that's your fault because you didn't read the manual. That's not confusion, it's incorrect programming procedure ;-)

简而言之，C使用了比作者更抽象的地址概念。

The author's concept of an address of course is also not the lowest-level word on the matter. What with virtual memory maps and physical RAM addressing across multiple chips, the number that you tell the CPU is "the store address" you want to access has basically nothing to do with where the data you want is actually located in hardware. It's all layers of indirection and representation, but the author has chosen one to privilege. If you're going to do that when talking about C, choose the C level to privilege!

Personally I don't think the author's remarks are all that helpful, except in the context of introducing C to assembly programmers. It's certainly not helpful to those coming from higher level languages to say that pointer values aren't addresses. It would be far better to acknowledge the complexity than it is to say that the CPU has the monopoly on saying what an address is and thus that C pointer values "are not" addresses. They are addresses, but they may be written in a different language from the addresses he means. Distinguishing the two things in the context of C as "address" and "store address" would be adequate, I think.

地址用于标识一个固定大小的存储空间，通常为每个字节，作为一个整数。这被精确地称为字节地址，它也被ISO c使用。可以有一些其他方法来构造地址，例如为每一位。然而，只有字节地址是如此经常使用，我们通常省略“字节”。

从技术上讲，一个地址在C中从来都不是一个值，因为在(ISO) C中术语“值”的定义是:

对象的内容在解释为具有特定类型时的精确含义

(我强调了一下。)然而，在C语言中没有这样的“地址类型”。

指针不一样。指针是C语言中的一种类型。有几种不同的指针类型。它们不一定遵守相同的语言规则集，例如++对int*类型值和char*类型值的影响。

C语言中的值可以是指针类型。这叫做指针值。需要明确的是，指针值在C语言中不是指针。但是我们习惯把它们混在一起，因为在C语言中，它不太可能是模棱两可的:如果我们把表达式p称为“指针”，它只是一个指针值，而不是一个类型，因为C语言中的命名类型不是由表达式表示，而是由type-name或typedef-name表示。

其他一些事情是微妙的。作为C语言的使用者，首先要知道object是什么意思:

数据存储在执行环境中的区域，其中的内容可以表示 值

对象是表示特定类型的值的实体。指针是一种对象类型。因此，如果我们声明int* p;，则p表示“指针类型的对象”，或“指针对象”。

Note there is no "variable" normatively defined by the standard (in fact it is never being used as a noun by ISO C in normative text). However, informally, we call an object a variable, as some other language does. (But still not so exactly, e.g. in C++ a variable can be of reference type normatively, which is not an object.) The phrases "pointer object" or "pointer variable" are sometimes treated like "pointer value" as above, with a probable slight difference. (One more set of examples is "array".)

由于指针是一种类型，而地址在C语言中实际上是“无类型的”，因此指针值大致“包含”一个地址。指针类型的表达式可以产生一个地址，例如。

Iso c11 6.5.2.3

一元&操作符产生其操作数的地址。

请注意，这个措辞是由WG14/N1256引入的，即ISO C99:TC3。在C99中有

一元&操作符返回其操作数的地址。

它反映了委员会的观点:地址不是由一元操作符&返回的指针值。

尽管有上述措辞，但即使在标准上也存在一些混乱。

Iso c11 6.6

地址常量是一个空指针，一个指向左值的指针，该左值指定一个static对象 存储持续时间，或指向函数指示符的指针

Iso c++ 11 5.19

3.一个地址 常量表达式是指针类型的prvalue核心常量表达式，计算结果为对象的地址 具有静态存储持续时间的对象，转换为函数的地址、空指针值或prvalue核心 类型std::nullptr_t. ...的常量表达式

(最近的c++标准草案使用了另一种措辞，所以不存在这个问题。)

实际上，C中的“地址常量”和c++中的“地址常量表达式”都是指针类型的常量表达式(或者至少从c++ 11开始是“类指针”类型)。

内置的一元&运算符在C和c++中被称为“address-of”;类似地，std::addressof是在c++ 11中引入的。

这些命名可能会带来误解。结果表达式是指针类型的，所以它们被解释为:结果包含/产生一个地址，而不是一个地址。

简单地说，指针实际上是分割机制的偏移部分，分割后转换为线性地址，分页后转换为物理地址。物理地址实际上是从ram中寻址的。

       Selector  +--------------+         +-----------+
      ---------->|              |         |           |
                 | Segmentation | ------->|  Paging   |
        Offset   |  Mechanism   |         | Mechanism |
      ---------->|              |         |           |
                 +--------------+         +-----------+
        Virtual                   Linear                Physical