blocks|key|4606850|text|不要被指针所蒙蔽。同样的道理也适用于普通int：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4606851|const+int+a+=+42;
int+b+=+a;+//+How+can+I+assign+a+const+int+to+a+non-const+int?
int+c+=+4;+//+Come+to+think+of+it,+the+literal+4+is+a+constant+too
void+foo+(int+x)+{+std::cout+<<+x;+}
foo(a);+//+How+come+I+can+call+foo+with+a+const+int?|code-block|syntax|javascript|4606852|总之，const分别应用于每个对象。const对象的副本也不需要是const。|offset|length|style|CODE|4606853|entityMap^0|0|0|3|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Don't get fooled by the pointer. The same holds for plain ints:

<pre><code>const int a = 42;
int b = a; // How can I assign a const int to a non-const int?
int c = 4; // Come to think of it, the literal 4 is a constant too
void foo (int x) { std::cout &lt;&lt; x; }
foo(a); // How come I can call foo with a const int?
</code></pre>

In summary, <code>const</code> applies to each object individually. A copy of a const object doesn't need to be const too.

blocks|key|3196108|text|我的问题是，如果arr是一个常量指针，为什么我可以把它发送给一个没有接收常量指针的函数呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3196109|？|blockquote|3196110|3196111|3196112|arr+(在main()中)不是常量指针，它是一个数组。数组类型在传递给函数时会衰减为指针类型。|offset|length|style|CODE|3196113|Increment中的arr+(参数)保存参数arr+(通过main()的值传递)地址的副本。|3196114|3196115|+//+arr%2B%2B+//+ileagal，因为它是一个常量指针|3196116|3196117|3196118|这是非法的，因为arr是不可修改的lvalue。|3196119|entityMap^0|0|0|0|0|0|3|6|6|0|0|9|B|3|N|3|U|6|0|0|0|0|0|8|3|H|6|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|11|8|@$I|12|J|13|K|L]|$I|14|J|15|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|16|8|@$I|17|J|18|K|L]|$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|P|3|Q|5|D|7|1G|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1J|8|@$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|W|$]]

<blockquote>
 My question is if arr is a const pointer, how come i can send it to a function that doesn't receive a const pointer?
</blockquote>

<code>arr</code> (inside <code>main()</code> )is not a const pointer, it is an array. An array type decays into a pointer type when passed to a function. 

<code>arr</code> (parameter) inside <code>Increment</code> holds a copy of the address of the argument <code>arr</code> (passed by value from <code>main()</code>).

<blockquote>
 // arr++ // ileagal because its a const pointer
</blockquote>

It is illegal because <code>arr</code> is a non-modifiable <code>lvalue</code>.

blocks|key|4606815|text|你不能在main中增加int+arr[]的原因是因为它是不可修改的左值。该标准说：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4606816|4606817|可修改的左值是一个左值，它没有数组类型，没有不完整的类型，没有常量限定类型，如果它是结构或联合，则没有任何成员(递归地包括所有包含的聚合或联合的任何成员或元素)具有常量限定类型。|blockquote|4606818|4606819|4606820|增量运算符%2B%2B需要一个可修改的左值(在它修改时)。然而，Increment函数中的指针是一个可修改的左值(它不是数组类型，它是一个指针)，这就是为什么它在那里是合法的。|4606821|entityMap^0|4|4|B|9|0|0|0|0|0|5|2|S|9|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|U|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|V|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|W|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|X|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|O|$]]

The reason why you can't increment <code>int arr[]</code> in <code>main</code> is because it's not modifiable lvalue. The standard says:

<blockquote>
 A modifiable lvalue is an lvalue that
 does not have array type, does not
 have an incomplete type, does not have
 a const-qualified type, and if it is a
 structure or union, does not have any
 member (including, recursively, any
 member or element of all contained
 aggregates or unions) with a
 const-qualified type.
</blockquote>

The increment operator <code>++</code> requires a modifiable lvalue (as it modifies). However the pointer in the <code>Increment</code> function is a modifiable lvalue (it's not of an array type, it's a pointer), which is why it's legal in there.

blocks|key|1860670|text|不是在main()中递增数组，而是在Increment()中递增局部变量(参数)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860671|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|$]]

You don't increment the array in main(), you increment the local variable (parameter) in Increment()

blocks|key|1860745|text|函数中的“arr”与main中的“arr”类型不同。你只是给他们起了同样的名字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860746|main的是一个数组，我很惊讶它的声明能被编译。通常你会这样做：|1860747|int+arr[]+=+{1,2,3,4,5};|code-block|syntax|javascript|1860748|但是函数中的“arr”只是一个普通的指针，所以它可以递增。|1860749|如果您在main中添加，|1860750|int+*arr2+=+arr;|1860751|然后你会有更好的运气递增arr2。或者，您可以添加一个可以递增的索引，用于索引arr数组。|1860752|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

The 'arr' inside the function is a different type from the 'arr' in main. You just gave them the same name.

main's is an array and I'm surprised its declaration compiles. Normally you'd do:

<pre><code>int arr[] = {1,2,3,4,5};
</code></pre>

But the 'arr' in the function is just a plain pointer, so it can be incremented.

If you add, in main,

<pre><code>int *arr2 = arr;
</code></pre>

Then you'd have better luck incrementing arr2. Or, you could add an index that could be incremented and used to index into the arr array.

blocks|key|1863829|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1863830|我的问题是arr是否为常量指针|blockquote|1863831|1863832|1863833|它不是一个const指针。|offset|length|style|CODE|1863834|下面是如何声明常量指针的方法。|1863835|const+char+constArray[]+=+{+'H',+'e',+'l',+'l',+'o',+'\0'+};|code-block|syntax|javascript|1863836|1863837|+C标准(C99+6.3.2.1/3)规定：“除非是sizeof运算符或一元&运算符的操作数，或者是用于初始化数组的字符串文字，否则类型为‘’array‘’的表达式将转换为类型为‘’pointer+type‘’的表达式，该类型指向数组对象的初始元素，而不是左值。|1863838|1863839|1863840|int+b[100];++++//+b+is+an+array+of+100+ints.
int*+p;++++++++//+p+is+a+pointer+to+an+int.
p+=+b;+++++++++//+Assigns+the+address+of+first+element+of+b+to+p.
p+=+&b[0];+++++//+Exactly+the+same+assignment+as+above.

p+=+b;+++//+Legal+--+p+is+not+a+constant.
b+=+p;+++//+ILLEGAL+because+b+is+a+constant,+altho+the+correct+type.|1863841|来源：http://www.fredosaurus.com/notes-cpp/arrayptr/26arraysaspointers.html|1863842|entityMap|0|LINK|mutability|MUTABLE|url|http://www.fredosaurus.com/notes-cpp/arrayptr/26arraysaspointers.html^0|0|0|0|0|5|5|0|0|0|0|0|0|0|0|3|1X|0|0^^$0|@$1|2|3|-4|4|5|6|19|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1A|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1B|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1D|7|@$H|1E|I|1F|J|K]]|8|@]|9|$]]|$1|L|3|M|4|5|6|1G|7|@]|8|@]|9|$]]|$1|N|3|O|4|P|6|1H|7|@]|8|@]|9|$Q|R]]|$1|S|3|-4|4|5|6|1I|7|@]|8|@]|9|$]]|$1|T|3|U|4|C|6|1J|7|@]|8|@]|9|$]]|$1|V|3|-4|4|5|6|1K|7|@]|8|@]|9|$]]|$1|W|3|-4|4|5|6|1L|7|@]|8|@]|9|$]]|$1|X|3|Y|4|P|6|1M|7|@]|8|@]|9|$Q|R]]|$1|Z|3|10|4|5|6|1N|7|@]|8|@$H|1O|I|1P|1|1Q]]|9|$]]|$1|11|3|-4|4|5|6|1R|7|@]|8|@]|9|$]]]|12|$13|$4|14|15|16|9|$17|18]]]]

<blockquote>
 My question is if arr is a const pointer
</blockquote>

Its not a <code>const</code> pointer.

Here's how you declare a const pointer.

<pre><code>const char constArray[] = { 'H', 'e', 'l', 'l', 'o', '\0' };
</code></pre>

<blockquote>
 C Standard (C99 6.3.2.1/3) says "Except when it is the operand of the sizeof operator or the unary &amp; operator, or is a string literal used to initialize an array, an expression that has type ‘‘array of type’’ is converted to an expression with type ‘‘pointer to type’’ that points to the initial element of the array object and is not an lvalue.
</blockquote>

<pre><code>int b[100]; // b is an array of 100 ints.
int* p; // p is a pointer to an int.
p = b; // Assigns the address of first element of b to p.
p = &amp;b[0]; // Exactly the same assignment as above.

p = b; // Legal -- p is not a constant.
b = p; // ILLEGAL because b is a constant, altho the correct type.
</code></pre>

Source: <a href="http://www.fredosaurus.com/notes-cpp/arrayptr/26arraysaspointers.html" rel="nofollow">http://www.fredosaurus.com/notes-cpp/arrayptr/26arraysaspointers.html</a>

blocks|key|1118063|text|arr是一个int类型的常量指针，它保存了第一个元素的地址，这里是值1的地址。const定义了arr中包含的地址不能改变。这个语句Increment(+arr+)；传递包含在arr中的地址，它的类型是int+*这就是编译器不会报错的原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1118064|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|$]]

arr is a const pointer of type int which holds the address of the first element, here the address of value 1. const defines that the address which is contain in arr cannot be changed.
This statement 
 Increment(arr);
passes the address which is contain in arr, which is of type int * 
Thats why the compiler does not complain.

blocks|key|3196182|text|这是因为函数Increment只改变了它的arr的本地版本，而main()作用域中的arr实际上并没有改变。因此，就函数参数而言，忽略变量上的常量。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3196183|void+func(void*+param)+{}

int+main()+{
++void+*a;
++void+*const+b;
++void+const+*c;
++void+const+*const+d;
++func(a);++//+legal
++func(b);++//+legal,+constantness+of+variable+doesn't+matter,+because+the+function+can't+change+it+anyway
++func(c);++//+illegal
++func(d);++//+illegal
}|code-block|syntax|javascript|3196184|entityMap^0|6|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

It is because the function <code>Increment</code> is only changing its local version of arr, and arr in main() scope is not actually changed. Therefore, const on the variables is disregarded in terms of function parameters.

<pre><code>void func(void* param) {}

int main() {
 void *a;
 void *const b;
 void const *c;
 void const *const d;
 func(a); // legal
 func(b); // legal, constantness of variable doesn't matter, because the function can't change it anyway
 func(c); // illegal
 func(d); // illegal
}
</code></pre>

Consider the following code:

<pre><code>void Increment(int *arr) {
 arr++;
}

int main() {
 int arr[] = {1,2,3,4,5};
 // arr++ // illegal because its a const pointer
 Increment(arr); // legal
}
</code></pre>

My question is if <code>arr</code> is a const pointer, how come I can send it to a function that doesn't receive a const pointer? 

The code compiles without the warning of discarding const qualifiers.

Array as const pointer

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

考虑以下代码：void Increment(int *arr) {    arr++;}int main() {    int arr[] = {1,2,3,4,5};    // arr++  // illegal because its a const pointer    Increment(arr);   // legal}我的问题是，如果arr是一个常量指针，为什么我可以把它发送给一个没

问数组作为常量指针
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问数组作为常量指针EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问数组作为常量指针
EN