关于c ++：“取消引用”指针是什么意思？

What does “dereferencing” a pointer mean?

请在解释中包括一个例子。

相关讨论

复习基本术语

通常情况下，设想一个指针包含一个数字内存地址就足够了(除非您正在编程汇编)，其中1表示进程内存中的第二个字节，2表示第三个字节，3表示第四个字节，依此类推……好的。

0和第一个字节发生了什么？好吧，我们稍后再讨论这个问题——见下面的空指针。
要更准确地定义指针存储的内容以及内存和地址之间的关系，请参阅"有关内存地址的更多信息，以及您可能不需要知道的原因"。

当您想要访问指针指向的内存中的数据/值-地址的内容和数字索引-然后您就取消了指针的引用。好的。

不同的计算机语言有不同的符号来告诉编译器或解释器，你现在对指向的值感兴趣-我集中在C和C++之上。好的。指针方案

在c中考虑，给定一个指针，如下面的p…好的。

1	const char* p ="abc";

…四个字节的数字值用于编码字母"a"、"b"、"c"，0字节表示文本数据的结尾，存储在内存的某个地方，数据的数字地址存储在p中。好的。

例如，如果字符串文本恰好位于地址0x1000，而p是32位指针位于0x2000，则内存内容将为：好的。

1
2
3
4
5
6
7

Memory Address (hex) Variable name Contents
1000 'a' == 97 (ASCII)
1001 'b' == 98
1002 'c' == 99
1003 0
...
2000-2003 p 1000 hex

注意，地址0x1000没有变量名/标识符，但是我们可以使用存储其地址的指针间接引用字符串文字：p。好的。取消指针引用

为了引用字符p指向，我们使用这些符号之一(同样，对于c)取消引用p：好的。

1
2
3
4
5

assert(*p == 'a'); // The first character at address p will be 'a'
assert(p[1] == 'b'); // p[1] actually dereferences a pointer created by adding
// p and 1 times the size of the things to which p points:
// In this case they're char which are 1 byte in C...
assert(*(p + 1) == 'b'); // Another notation for p[1]

您还可以在指向的数据中移动指针，并在移动时取消对它们的引用：好的。

1 2	++p; // Increment p so it's now 0x1001 assert(*p == 'b'); // p == 0x1001 which is where the 'b' is...

如果您有一些数据可以写入，那么您可以这样做：好的。

1
2
3
4

int x = 2;
int* p_x = &x; // Put the address of the x variable into the pointer p_x
*p_x = 4; // Change the memory at the address in p_x to be 4
assert(x == 4); // Check x is now 4

上面，您必须在编译时知道您需要一个名为x的变量，代码要求编译器安排存储它的位置，确保地址可以通过&x使用。好的。取消引用和访问结构数据成员

在C语言中，如果有一个变量是指向具有数据成员的结构的指针，则可以使用->取消引用运算符访问这些成员：好的。

1
2
3
4
5

typedef struct X { int i_; double d_; } X;
X x;
X* p = &x;
p->d_ = 3.14159; // Dereference and access data member x.d_
(*p).d_ *= -1; // Another equivalent notation for accessing x.d_

多字节数据类型

要使用指针，计算机程序还需要了解所指向的数据类型-如果该数据类型需要表示多个字节，则指针通常指向数据中编号最低的字节。好的。

所以，看一个稍微复杂一点的例子：好的。

1
2
3
4
5
6
7
8
9

double sizes[] = { 10.3, 13.4, 11.2, 19.4 };
double* p = sizes;
assert(p[0] == 10.3); // Knows to look at all the bytes in the first double value
assert(p[1] == 13.4); // Actually looks at bytes from address p + 1 * sizeof(double)
// (sizeof(double) is almost always eight bytes)
assert(++p); // Advance p by sizeof(double)
assert(*p == 13.4); // The double at memory beginning at address p has value 13.4
*(p + 2) = 29.8; // Change sizes[3] from 19.4 to 29.8
// Note: earlier ++p and + 2 here => sizes[3]

指向动态分配内存的指针

有时，在程序运行并查看向其抛出的数据之前，您不知道需要多少内存…然后可以使用malloc动态分配内存。通常的做法是将地址存储在指针中…好的。

1
2
3
4
5

int* p = malloc(sizeof(int)); // Get some memory somewhere...
*p = 10; // Dereference the pointer to the memory, then write a value in
fn(*p); // Call a function, passing it the value at address p
(*p) += 3; // Change the value, adding 3 to it
free(p); // Release the memory back to the heap allocation library

在C++中，内存分配通常是用EDCOX1×1×操作符来完成的，并且用EDCOX1 2来分配：好的。

1
2
3
4
5
6
7
8

int* p = new int(10); // Memory for one int with initial value 10
delete p;

p = new int[10]; // Memory for ten ints with unspecified initial value
delete[] p;

p = new int[10](); // Memory for ten ints that are value initialised (to 0)
delete[] p;

请参阅下面的C++智能指针。好的。丢失和泄漏地址

通常，指针可能是内存中存在某些数据或缓冲区的唯一指示。如果需要继续使用该数据/缓冲区，或者能够调用free()或delete以避免内存泄漏，那么程序员必须操作指针的副本…好的。

1
2
3
4
5
6
7
8
9
10

const char* p = asprintf("name: %s", name); // Common but non-Standard printf-on-heap

// Replace non-printable characters with underscores....
for (const char* q = p; *q; ++q)
if (!isprint(*q))
*q = '_';

printf("%s
", p); // Only q was modified
free(p);

…或小心安排任何变化的逆转…好的。

1
2
3
4

const size_t n = ...;
p += n;
...
p -= n; // Restore earlier value...

C++智能指针

在C++中，最好使用智能指针对象来存储和管理指针，在智能指针析构函数运行时自动释放它们。自从C++ 11以来，标准库提供了两个EDCOX1，5，当有一个被分配对象的所有者时…好的。

1
2
3
4
5

{
std::unique_ptr<T> p{new T(42,"meaning")};
call_a_function(p);
// The function above might throw, so delete here is unreliable, but...
} // p's destructor's guaranteed to run"here", calling delete

…和shared_ptr的股份所有权(使用参考计数法)好的。

1
2
3
4

{
std::shared_ptr<T> p(new T(3.14,"pi"));
number_storage.may_add(p); // Might copy p into its container
} // p's destructor will only delete the T if number_storage didn't copy

空指针

在C中，EDCOX1，7，EDCOX1，8，-另外，在C++中，EDCOX1，9，-可以用来指示指针当前不保存变量的内存地址，不应该在指针算术中被撤销或使用。例如：好的。

1
2
3
4
5
6
7
8

const char* p_filename = NULL; // Or"= 0", or"= nullptr" in C++
char c;
while ((c = getopt(argc, argv,"f:")) != EOF)
switch (c) {
case f: p_filename = optarg; break;
}
if (p_filename) // Only NULL converts to false
... // Only get here if -f flag specified

在C和C++中，正如内建的数字类型不一定默认为EDCOX1〔8〕，也不必EDCOX1对EDCOX1〔12〕11〕，指针不总是设置为EDCOX1〔7〕。当它们是EDOCX1、14个变量或(C++)静态对象或它们的基元的直接或间接成员变量时，所有这些都被设置为0 /假/空，或者进行零初始化(例如EDCOX1×15)和EDCOX1〔16〕在T的成员上执行零点初始化，包括指针，而EDCOX1〔17〕不成立。好的。

此外，当您将0、NULL和nullptr分配给指针时，指针中的位不一定全部重置：指针在硬件级别可能不包含"0"，或者在虚拟地址空间中引用地址0。如果编译器有理由的话，它可以在那里存储其他东西，但是不管它做什么——如果您来比较指向0、NULL、nullptr的指针或分配给其中任何一个指针的另一个指针，比较必须按预期工作。因此，在编译器级别的源代码下面，"NULL"在C语言和C++语言中可能有点"神奇"。好的。关于内存地址的更多信息，以及为什么您可能不需要知道

更严格地说，初始化指针存储一个位模式，标识NULL或(通常是虚拟的)内存地址。好的。

简单的情况是，这是对进程的整个虚拟地址空间的一个数字偏移；在更复杂的情况下，指针可能是相对于某些特定的内存区域的，CPU可以根据CPU"段"寄存器或以位模式编码的段ID的某种方式进行选择，和/或根据MAC查找不同的位置。使用地址对指令进行编码。好的。

例如，正确初始化以指向int变量的int*可能在转换为float*之后访问"gpu"内存中与int变量非常不同的值，然后一旦转换为函数指针，则可能指代保存该函数的机器操作码的不同内存。好的。

像C和C++这样的3GL编程语言倾向于隐藏这种复杂性，例如：好的。

如果编译器给你一个指向变量或函数的指针，你可以自由地取消引用它(只要变量没有同时被破坏/释放)，这是编译器的问题，例如某个特定的CPU寄存器需要预先恢复，还是使用了一个不同的机器代码指令好的。
如果您得到一个指向数组中某个元素的指针，您可以使用指针算法移动数组中的任何其他位置，或者甚至形成一个地址，该地址是一个超过数组末尾的地址，与数组中元素的其他指针进行比较是合法的(或者类似地，该地址也是通过指针算法移动到超过结束值的同一个地址)；同样，在C和C++，这取决于编译器来确保这个"只是工作"。好的。
特定的操作系统功能，例如共享内存映射，可能会给您提供指针，它们将在对它们有意义的地址范围内"正常工作"。好的。
尝试将法律指针移到这些边界之外，或者将任意数字投给指针，或者使用指针转换为无关类型，通常具有未定义的行为，因此在更高级别的库和应用程序中应该避免，但是OSES、设备驱动程序等代码可能需要依赖于C或C++未定义的行为，即NE。无垂直，由其特定硬件定义良好。好的。

好啊。

相关讨论

p[1] 和*(p + 1)是否相同？也就是说，p[1] 和*(p + 1)是否生成相同的指令？
"pacerier 6.5.2.1 / 2：虔诚的n1570 C标准草案(第一个在网上发现)"的定义是subscript运营商[是] [冰] E1 E2 identical两个(*((E1)+(E2)。"我不能想象任何理由为什么编译器不一他们立即convert T在一个identical representations早期大学编制，将optimisations afte一样R，，但我没有看到任何人，我当然可以试试《法典》将是每一个测量identical没有编译过的笔试。
"tonyd NO，我不是在说什么编译器的实现等，但我宁愿去官方标准，担保行为呢？在《新标准均C90，C99和C11。
"pacerier钢架的标准是：在observable behaviours必要的条款，但如何选择两个地图编译器的源代码的两个冰槽机的操作码家。
"pacerier：实际上，P = [ 1 ](P = a + 1)=(1 + P)= P [ 1 ]。你可以把第六单元阵列在一个城市的写作：[ 6 ]改编的。这是我identical似乎很长。
在你的部分"多字节数据类型"，不会是最后的两个表的大小assigning [ 3 ]和[ 2 ]槽的大小，从增量两线之前？
"哦selkathguy审计：在18 [2]修饰它，因为有人commented鸭，这是错误的++p自己错过了在当时是正确的第一次。将恢复。谢谢！
在《看不见的术语标准prefers间接取值过负荷时间(open-std.org / jtc1 sc22 wg21 / / / /文档/文件/ n3362.html 2012)
为什么要2000-2003p冰吗？为什么不是！这只是2000含1000 hex吗？
"亲爱的：《价值1000冰太大两个十六进制编码在一个单字节(8位)只读存储器：你可以大unsigned数从0到255的一个字节。婊子，你就不能大1000个十六进制地址"只是"2000年。而不是，一个32位的系统将使用32位，这是四个字节的地址从2000年与2003年的两个。一个64位的系统将使用64位的8个字节从2000年的两个。它的方式，解决茶叶基地2000 p就是：如果你有另一个指针，两个p它会有两个大的在其2000年四或八个字节。希望helps！干杯。
"tonydelroy联盟：如果一个数组包含uarrGCC和clang，都会认识，左值u.arr[i]可能会访问相同的存储为其他联盟的成员，但是这会不认识，我会做*(u.arr+i)左值的婊子。在我不确定是否这些编译器的作者认为《笑invokes UB的形式，或者说，"但他们应该invokes UB的工艺信息usefully无论如何，但他们明确的表达式为两景不同。
supercat："有趣！在那有一个空的全是代码混淆和Active会员银行联盟的规章和津贴为字符数组是用来混淆(鸭hence memcpy)。GCC和clang -fno-strict-aliasing有他们的支持。我不能告诉你是否从描述arr"或其他联盟成员"在你的场景是字符数组，或不管你是用-fno-strict-aliasing，但如果regardless似乎是一个奇怪的符号，而不是其他。制作一个问题也许值得什么呢？干杯！
"tonydelroy：标准的能力treats接入A struct联盟对象或使用的任何类型的值比其他的struct /联盟式和质量作为一个字符型的实施问题。但它没有说什么形式构建质量的实现等用于各种用途应该支持。GCC和clang质量表现为各种优化的实现等我是残疾人，但不幸的是，作者把代码的质量在使用在线编译器为"破碎"。
"supercat：嗯，听起来你方与莱纳斯……………………..在找到它的硬让我兴奋，给定的specifying -fno-strict-aliasing不是特别onerous。
@Tonydelroy：据我所知，没有任何有意义的规范来描述保证在-fstrict-aliasing模式下工作的操作。在这方面，标准是无用的，因为即使是普通的结构成员访问左值也会调用ub。可以肯定的是，使用-fno-strict-aliasing是可能的，但是如果gcc的设计使使用-fno-strict-aliasing作为某些代码是必要的，那么作者在别名优化上所做的任何努力都是浪费的，可以更好地用于其他地方。
@Tonydelroy：一个更大的问题是，没有办法告诉编译器不要以任何版本没有的方式进行优化，因此，没有任何方法可以使构建文件合理确定地与编译器的未来版本兼容，除非批量禁用大多数优化。否则，据我所知，GCC维护人员的态度是，他们认为随意破坏99%的依赖于任何"实现质量"UB的程序没有任何错误。
我很少看到指针和它们在C/C++中的用法，因此简明扼要地加以解释。
@超级卫星：这是一个大话题(太大了，无法在评论中适当涵盖)。完全同意GCC和Clang应该记录-fno-strict-aliasing所做的安全性，并尽量减少释放之间的回归。在这个空间中，我相信C++ 20仍然希望添加EDCOX1，4，这将有望取代一些EDCOX1×5和基于联合的类型双关UBS。即使是一个普通的结构成员访问lvalue也会调用ub"—您能详细描述或提供关于这个的链接吗？干杯
@Tonydelroy:安全和优化所需的不是"位转换"运算符，而是"受限指针"类型，在其生存期内，该类型要求使用受限指针访问的对象的所有部分都只能通过它进行访问，并且其构造函数可以获取任何类型的指针并导致访问通过被视为对原始类型的访问的受限指针进行的。大多数需要使用类型punning的代码都可以接受这样的构造，它允许许多有用的优化，这些优化将超越tbaa。
@Tonydelroy:在c11标准中，给定struct S {int x;} s;时，左值s.x的类型是int类型，但唯一可用于访问struct S存储值的左值类型是struct S和字符类型。我认为该标准的作者认为，任何未损坏的编译器都应该处理像s.x这样的情况，他们不需要显式地指定它，但他们可能也同样认为gcc和clang的作者似乎以拒绝没有-fno-strict-aliasing支持而自豪的一些访问模式。③

取消对指针的引用意味着获取存储在指针指向的内存位置中的值。运算符*用于执行此操作，称为解引用运算符。

1
2
3
4
5
6
7
8
9
10
11

int a = 10;
int* ptr = &a;

printf("%d", *ptr); // With *ptr I'm dereferencing the pointer.
// Which means, I am asking the value pointed at by the pointer.
// ptr is pointing to the location in memory of the variable a.
// In a's location, we have 10. So, dereferencing gives this value.

// Since we have indirect control over a's location, we can modify its content using the pointer. This is an indirect way to access a.

*ptr = 20; // Now a's content is no longer 10, and has been modified to 20.

相关讨论

指针不指向值，而是指向对象。
@KeithThompson指针不指向对象，它指向一个内存地址，对象(可能是原语)位于该地址。
@MG30RG：我不知道你有什么区别。指针值是地址。根据定义，对象是"执行环境中的数据存储区域，其内容可以表示值"。你说的"原始"是什么意思？C标准没有使用这个术语。
@基思汤普森，我几乎没有指出，你实际上没有给答案增加价值，你只是在吹毛求疵的术语(也做了错事)。指针值肯定是一个地址，这就是它"指向"内存地址的方式。OOP驱赶世界中的"对象"一词可能是误导性的，因为它可以被解释为"类实例"(YEP，我不知道这个问题被标记为[C]而不是[C++])，并且我用"原语"这个词作为"COMPLMEX"(数据结构如结构或类)的对立面。
@MG30RG：我支持我的原始语句：指针不指向值，而是指向对象。问题被更新以纠正这一点。术语很重要，不，我不认为我做错了什么。顺便说一下，C++对象对"对象"一词的定义非常类似于C语言，与OOP无关。"原语"听起来像是标准所说的"标量"；是的，指针指向的对象可能是标量类型，也可能不是标量类型，但我不确定是否添加了任何内容。
在这个答案的基础上，再加上数组下标运算符[]也会取消对指针的引用(a[b]的定义是指*(a + b))。
我经常发现第二个答案比第一个答案简洁得多。这个答案是另一个例子。
@cmaster：本标准可能定义了等效性，但GCC和Clang都将someUnion.array[i]和*(someUnion.array+i)视为不同的访问，将前者的访问(而不是后者)视为对联合对象的访问。
@Supercat我不知道"识别访问"是什么意思。我要说的是这样一个事实，当你编写someUnion.array[i]或*(someUnion.array + i)时，你a)命名一个数组(someUnion.array，你b)将该数组衰减成一个指针，你c)访问指针后面的字节。如果someUnion.array不是数组本身，而是指向某个动态内存的指针，但其余的在所有情况下都是相同的，则可以省略步骤b)。
@cmaster：给定if (u.arr1[i]) u.arr2[j]=1; return u.arr[i]，gcc和clang将返回函数返回时u.arr1[i]持有的值。将代码更改为if (*(u.arr1+i)) *(u.arr2+j)=1; return *(u.arr1+i);，即使写入u.arr2[j]修改了u.arr1[i]，它们也会返回测试条件时u.arr1[i]所保留的值。
@超级卫星，这是因为执行了超级卫星1号(16号)后，超级卫星1号(15号)在UB领土内。毕竟，你是在给另一个工会会员写信之后读到的。编译器可以决定返回粉红大象。所以想一想它到底返回了什么是没用的…
@cmaster:c99指定写入一个联合成员并读取另一个联合成员将重新解释位。如果写操作生成了一个位模式，该位模式将成为读取类型的陷阱表示，则会调用ub，但禁止uint16_t和uint32_t使用陷阱表示。

指针是对值的"引用"。就像图书馆的电话号码是对一本书的引用。"取消对"呼叫号码的引用实际上是在浏览和检索那本书。

1
2
3
4
5
6
7
8

int a=4 ;
int *pA = &a ;
printf("The REFERENCE/call number for the variable `a` is %p
", pA ) ;

// The * causes pA to DEREFERENCE... `a` via"callnumber" `pA`.
printf("%d
", *pA ) ; // prints 4..

如果书不在那里，图书管理员就开始叫喊，关闭图书馆，并且有几个人准备调查一个人找不到书的原因。

简单来说，取消引用意味着从指针指向的某个内存位置访问值。

指针基础的代码和解释：

The dereference operation starts at
the pointer and follows its arrow over
to access its pointee. The goal may be
to look at the pointee state or to
change the pointee state. The
dereference operation on a pointer
only works if the pointer has a
pointee -- the pointee must be
allocated and the pointer must be set
to point to it. The most common error
in pointer code is forgetting to set
up the pointee. The most common
runtime crash because of that error in
the code is a failed dereference
operation. In Java the incorrect
dereference will be flagged politely
by the runtime system. In compiled
languages such as C, C++, and Pascal,
the incorrect dereference will
sometimes crash, and other times
corrupt memory in some subtle, random
way. Pointer bugs in compiled
languages can be difficult to track
down for this reason.

1
2
3
4
5
6

void main() {
int* x; // Allocate the pointer x
x = malloc(sizeof(int)); // Allocate an int pointee,
// and set x to point to it
*x = 42; // Dereference x to store 42 in its pointee
}

相关讨论

我认为以前所有的答案都是错误的，因为它们声明取消引用意味着访问实际值。维基百科给出了正确的定义：https://en.wikipedia.org/wiki/dereference_operator网站

It operates on a pointer variable, and returns an l-value equivalent to the value at the pointer address. This is called"dereferencing" the pointer.

也就是说，我们可以不必再引用指针访问它指向的值。例如：

1 2	char p = NULL; p;

我们在不访问空指针的价值。或者我们可以这样做：

1 2	p1 = &(p); sz = sizeof(p);

同样，取消引用，但从不访问值。这样的代码不会崩溃：当您通过指针无效。然而，不幸的是，根据标准，取消对无效指针的引用是未定义的行为(除了少数例外)，即使你不尝试触摸实际数据。

简而言之：取消引用指针意味着应用取消对它的引用运算符。那个接线员只是返回一个L值供您将来使用。

相关讨论