blocks|key|759818|text|你说得对，对于调用者来说，这完全没有区别。但对于函数的编写者来说，它可以是一个安全网“好吧，我需要确保我没有把这一点指向错误的事情”。不是很有用，但也不是无用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|759819|这基本上与程序中有一个int+const+the_answer+=+42是一样的。|offset|length|style|CODE|759820|entityMap^0|0|B|P|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

You're right, for the caller it makes absolutely no difference. But for the writer of the function it can be a safety net "okay, I need to make sure I don't make this point to the wrong thing". Not very useful but not useless either.

It's basically the same as having an <code>int const the_answer = 42</code> in your program.

blocks|key|543255|text|指针并没有什么特别之处，你永远不会希望它们是const。正如您可以拥有类成员的常量int值一样，您也可以出于类似的原因而拥有常量指针:您希望确保任何人都不会更改指向的内容。C%2B%2B引用在某种程度上解决了这个问题，但指针行为继承自C。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|543256|entityMap^0|15|3|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

There's nothing special about pointers where you would never want them to be const. Just as you can have class member constant <code>int</code> values, you can also have constant pointers for similar reasons: You want to make sure that no one ever changes what's being pointed to. C++ references somewhat address this, but the pointer behavior is inherited from C.

blocks|key|759892|text|我相信这将防止代码递增或递减函数体中的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|759893|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|$]]

I believe this would prevent code from incrementing or decrementing the pointer within the function body.

blocks|key|759939|text|将常量指针传递给函数意义不大，因为它无论如何都是通过值传递的。这只是通用语言设计所允许的事情之一。仅仅因为它没有意义而禁止它只会使语言规范。大一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|759940|如果你在一个函数中，那当然是另一种情况。拥有一个不能改变它所指向的内容的指针是一个使代码更清晰的断言。|759941|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|$]]

Passing a const pointer to a function makes little sense, as it will be passed by value anyways. It's just one of those things that are allowed by the general language design. Prohibiting it just because it doesn't make sense would just make the language spec. larger.

If you are inside a function it is of course another case. Having a pointer that cannot change what it points to is an assertion that makes the code clearer.

blocks|key|543395|text|我猜一个好处是编译器可以在函数内部执行更积极的优化，因为知道这个指针不能改变。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|543396|它还避免了例如。将此指针传递给子函数，该子函数接受非常数指针引用(因此可能会像void+f(int+*&p)一样更改指针)，但我同意，在这种情况下，它的用处是有限的。|offset|length|style|CODE|543397|entityMap^0|0|13|F|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I guess an advantage would be that the compiler can perform more aggressive optimizations inside the function knowing that this pointer cannot change.

It also avoids eg. passing this pointer to a subfunction which accepts a non-const pointer reference (and could therefore change the pointer like <code>void f(int *&amp;p)</code>), but I agree, that the usefulness is somewhat limited in this case.

blocks|key|543466|text|int+iVal+=+10；int+*const+ipPtr+=+&iVal；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|543467|就像普通的常量变量一样，常量指针必须在声明时初始化为一个值，并且它的值不能改变。|543468|这意味着常量指针将始终指向相同的值。在上述情况下，ipPtr将始终指向iVal的地址。但是，因为指向的值仍然是非常量，所以可以通过取消引用指针来更改指向的值：|543469|*ipPtr+=+6；//允许，因为pnPtr指向非常数int|543470|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

int iVal = 10;
int *const ipPtr = &iVal;

Just like a normal const variable, a const pointer must be initialized to a value upon declaration, and its value can not be changed. 

This means a const pointer will always point to the same value. In the above case, ipPtr will always point to the address of iVal. However, because the value being pointed to is still non-const, it is possible to change the value being pointed to via dereferencing the pointer:

*ipPtr = 6; // allowed, since pnPtr points to a non-const int

blocks|key|543507|text|同样的问题也可以问到任何其他类型(不仅仅是指针)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|543508|/*+Why+is+n+const?+*/
const+char+*expand(const+int+n)+{
++++if+(n+==+1)+return+"one";
++++if+(n+==+2)+return+"two";
++++if+(n+==+3)+return+"three";
++++return+"many";
}|code-block|syntax|javascript|543509|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Same question can be asked about any other type (not just pointers):

<pre><code>/* Why is n const? */
const char *expand(const int n) {
 if (n == 1) return "one";
 if (n == 2) return "two";
 if (n == 3) return "three";
 return "many";
}
</code></pre>

blocks|key|760162|text|你的问题更多的是为什么要将任何变量定义为常量，而不仅仅是函数的常量指针参数。当您将任何变量定义为常量时，如果它是函数的参数、成员变量或局部变量，则相同的规则也适用于此处。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|760163|在你的特殊情况下，当你声明一个局部变量为const时，它在功能上不会像在许多其他情况下一样有区别，但它确实限制了你不能修改这个变量。|760164|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|$]]

Your question is really more about why define any variable as a const not just const pointer parameter to a function. The same rules apply here as when you define any variable as constant, if its a parameter to function or member variable or a local variable. 

In your particular case, functionally it doesn't make difference like in many other cases when you declare a local variable as const but it does put a restriction that you can't modify this variable.

blocks|key|543655|text|如果您在具有内存映射设备的情况下进行嵌入式系统或设备驱动程序编程，则通常会使用两种形式的“const”，一种是为了防止指针被重新分配(因为它指向固定的硬件地址)。而且，如果它指向的外围寄存器是只读硬件寄存器，那么另一个const将在编译时而不是运行时检测到许多错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|543656|只读16位外设芯片寄存器可能如下所示：|543657|static+const+unsigned+short+*const+peripheral+=+(unsigned+short+*)0xfe0000UL;|offset|length|style|CODE|543658|然后，您可以轻松地读取硬件寄存器，而不必求助于汇编语言：|543659|input_word+=+*peripheral;|543660|entityMap^0|0|0|0|25|0|0|0|P|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@$F|S|G|T|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@$F|W|G|X|H|I]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|O|$]]

If you do embedded systems or device driver programming where you have memory mapped devices then both forms of 'const' are often used, one to prevent the pointer from being reassigned (since it points to a fixed hardware address.) and, if the peripheral register it points to is a read-only hardware register then another const will detect a lot of errors at compile time rather than runtime.

A read-only 16 bit peripheral chip register might look something like:

<code>static const unsigned short *const peripheral = (unsigned short *)0xfe0000UL;</code> 

Then you can easily read the hardware register without having to resort to assembly language:

<code>input_word = *peripheral;</code>

I'm not talking about pointers to const values, but const pointers themselves.

I'm learning C and C++ beyond the very basic stuff and just until today I realized that pointers are passed by value to functions, which makes sense. 
This means that inside a function I can make the copied pointer point to some other value without affecting the original pointer from the caller.

So what's the point of having a function header that says:

<pre><code>void foo(int* const ptr);
</code></pre>

Inside such a function you cannot make ptr point to something else because it's const and you don't want it to be modified, but a function like this:

<pre><code>void foo(int* ptr);
</code></pre>

Does the work just as well! because the pointer is copied anyways and the pointer in the caller is not affected even if you modify the copy. So what's the advantage of const?

What's the point of const pointers?

设备驱动程序

嵌入式系统

内存映射

编译器

我说的不是指向const值的指针，而是const指针本身。除了最基本的东西之外，我还在学习C和C++，直到今天我才意识到指针是通过值传递给函数的，这是有意义的。这意味着在函数内部，我可以让复制的指针指向其他值，而不会影响调用者的原始指针。那么，拥有一个函数头有什么意义呢？void foo(int* const ptr)...

问常量指针的意义是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问常量指针的意义是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问常量指针的意义是什么？
EN