blocks|key|53655|text|输入是一个const引用，它引用一个const指针。因此，引用是常量，指针是常量，但它所指向的值可以更改。|type|blockquote|depth|inlineStyleRanges|entityRanges|data|53656|不是这样的。参数p不能更改为指向另一个对象。p指向的对象的值也不能更改。|unstyled|offset|length|style|CODE|53657|输入是对指向常量整数的constant指针的const引用。|53658|说大也大吧。|53659|p是对指向const整数的const指针的引用。|53660|entityMap^0|0|8|1|M|1|0|0|0|0|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@$E|S|F|T|G|H]|$E|U|F|V|G|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|W|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|X|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Y|8|@$E|Z|F|10|G|H]]|9|@]|A|$]]|$1|O|3|-4|5|D|7|11|8|@]|9|@]|A|$]]]|P|$]]

<blockquote>
 The input is a const reference which refers to a const int pointer. Hence the reference is constant, and the pointer is constant, but the value it points to can be changed.
</blockquote>

Not true. The argument <code>p</code> cannot be changed to point to a different object. The value of the object that <code>p</code> points to cannot be changed either.

<blockquote>
 The input is a const reference to a const int pointer which points to a constant integer.
</blockquote>

Sort of.

<code>p</code> is a reference to a const pointer which points to a const integer.

blocks|key|979793|text|输入是指向const整数的const指针的引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|979794|const+int*+const&+p|code-block|syntax|javascript|979795|第一个const表示int对象本身是常量，不能更改。第二个const表示不能更改该int上的指针。那你就会发现这是个参考。您可以为引用再添加一个const，它将编译。就像这样：|979796|const+int*+const&+const+p|979797|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The input is a reference on a const pointer which point to the const integer.

<pre><code>const int* const&amp; p
</code></pre>

The first const indicates that the int object itself is constant and can't be changed. The second const indicated that the pointer on that int can't be changed. Then you see that it's a reference. You can add one more const for the reference and it will compile. Like that:

<pre><code>const int* const&amp; const p
</code></pre>

blocks|key|981250|text|您所拥有的是对指向常量整数的常量指针的引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|981251|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|$]]

What you have is a reference to a constant pointer to a constant integer.

blocks|key|979843|text|p是对指向const+int的const指针的引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|979844|引用本身不是const+--+"const引用“只是对const对象的引用。因此，"const引用指向const+int的指针“将被理解为相同的意思。|979845|entityMap^0|0|1|B|3|0|6|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

<code>p</code> is a reference to a const pointer to a const <code>int</code>.

Reference aren't <code>const</code> by themselves - "const references" are just references to const objects. Hence, "const reference to pointer to const int" would be understood to mean the same thing.

blocks|key|53821|text|const+int*+const&+P|type|blockquote|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|53822|P是指向常量整数的常量指针的引用(而不是常量引用，因为引用始终是常量)。|unstyled|53823|第一个常量用于整数，第二个常量用于指针(不是引用)。传递常量指针的引用是没有意义的，因为它是常量的。|53824|entityMap^0|0|J|0|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|$]]|$1|I|3|J|5|H|7|Q|8|@]|D|@]|E|$]]|$1|K|3|-4|5|H|7|R|8|@]|D|@]|E|$]]]|L|$]]

<blockquote>
 <code>const int* const&amp; P</code>
</blockquote>

P is a reference(not constant reference, as reference is always constant) to a constant pointer, which is pointing to constant integer.

The first constant is for integer &amp; second one is for pointer(not reference). There is no point of passing a reference of constant pointer as it is constant anyway.

blocks|key|981331|text|我认为下面的代码片段将回答您的问题，如果您可以运行它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|981332|我已经解释了如何创建、引用和传递参数const+int*+const&+p。|offset|length|style|CODE|981333|这是一个简单而棘手的函数，它只返回与传递给的数据类型相似的数据类型，只是引用了参数。加捻是康斯特函数，但在下面的情况下，它将意味着没有区别。|981334|#include+<iostream>

using+namespace+std;

class+Complex{
++++public:
++++++++const+int*+const+fun(const+int*+const&+p)+const;

};

const+int*+const+Complex::fun(const+int*+const&+p)+const{
++++return+p;
}


int+main(){

++++int+i+=10;
++++const+int*+j+=+&i;
++++const+int*+const&+p+=+j;

++++cout+<<+"i+=+"+<<+i+<<+"+is+stored+at+address+"+<<+&i+<<+endl;
++++cout+<<+"j+is+pointing+to+i's+address+"+<<+j+<<+"+at+j's+own+address+"+<<+&j+<<+endl;
++++cout+<<+"p+is+referencing+j's+address+at+"+<<+&p+<<+"+and+also+holds+the+value+same+as+j+which+is+i's+address+"+<<+p+<<+endl;
++++cout+<<+"j+can+get+the+show+in+i+with+expression+*j+which+will+output+"+<<+*j+<<endl;
++++cout+<<+"similary+p+can+show+the+value+in+i+with+express+*p+which+will+output+"+<<+*p+<<endl;

++++Complex+c;
++++cout+<<+c.fun(p)+<<+"+has+value+"+<<+*c.fun(p);
++++return+0;
}|code-block|syntax|javascript|981335|entityMap^0|0|I|J|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I think the below code snippet will answer your question if you could just run it.
I have explained how the argument <code>const int* const&amp; p</code> is created, referenced and passed.
This is a simple tricky function that just returns the similar data type as the one being passed into except that the argument is referenced. Added twist is the const function but in the below case it will mean no difference.
<pre><code>#include &lt;iostream&gt;

using namespace std;

class Complex{
 public:
 const int* const fun(const int* const&amp; p) const;

};

const int* const Complex::fun(const int* const&amp; p) const{
 return p;
}


int main(){

 int i =10;
 const int* j = &amp;i;
 const int* const&amp; p = j;

 cout &lt;&lt; &quot;i = &quot; &lt;&lt; i &lt;&lt; &quot; is stored at address &quot; &lt;&lt; &amp;i &lt;&lt; endl;
 cout &lt;&lt; &quot;j is pointing to i's address &quot; &lt;&lt; j &lt;&lt; &quot; at j's own address &quot; &lt;&lt; &amp;j &lt;&lt; endl;
 cout &lt;&lt; &quot;p is referencing j's address at &quot; &lt;&lt; &amp;p &lt;&lt; &quot; and also holds the value same as j which is i's address &quot; &lt;&lt; p &lt;&lt; endl;
 cout &lt;&lt; &quot;j can get the show in i with expression *j which will output &quot; &lt;&lt; *j &lt;&lt;endl;
 cout &lt;&lt; &quot;similary p can show the value in i with express *p which will output &quot; &lt;&lt; *p &lt;&lt;endl;

 Complex c;
 cout &lt;&lt; c.fun(p) &lt;&lt; &quot; has value &quot; &lt;&lt; *c.fun(p);
 return 0;
}
</code></pre>

<pre><code>const int* const fun(const int* const&amp; p) const;
</code></pre>

I'm trying to figure out about the input parameter at this given function prototype. I'm debating between these two, not sure which one is correct.

<ol>
<li>The input is a const reference which refers to a const int pointer. Hence the reference is constant, and the pointer is constant, but the value it points to can be changed.</li>
<li>The input is a const reference to a const int pointer which points to a constant integer. </li>
</ol>

meaning of const int* const fun(const int* const& p) const;

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

const int* const fun(const int* const& p) const;我试图在这个给定的函数原型中找出输入参数。我在这两个人之间争论，不知道哪一个是对的。输入是一个const引用，它引用一个const指针。因此，引用是常量，指针是常量，但它所指向的值可以更改。输入是对指向常量整数的consta...

问const int* const fun(const int* const& p) const；
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问const int* const fun(const int* const& p) const；EN