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

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标准:

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，但在另一个系统上使用相同的代码/值可能会使程序崩溃)。

结果比我想象的要长……

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.

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

例如，给定:

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的值更大。

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

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

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