const的用法，特别是用在函数后面

最新推荐文章于 2024-01-04 22:40:55 发布
最新推荐文章于 2024-01-04 22:40:55 发布
阅读量329 收藏
点赞数
分类专栏： C/C++ 
<span style="line-height: 0.47cm;  font-family: FangSong_GB2312;"><strong></strong></span>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">在普通的非 </span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">成员函数中，</span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">的类型是一个指向类类型的 </span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">指针</span><span style="font-family: FangSong_GB2312;">。可以改变</span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">所指向的值，但不能改变 </span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">所保存的地址。
在 </span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">成员函数中，</span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">的类型是一个指向 </span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">类类型对象的 </span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">指针。既不能改变 </span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">所指向的对象，也不能改变 </span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">所保存的地址。</span></span></strong>
<strong><span style="font-family: FangSong_GB2312;"><span style="font-size:14px;"></span></span></strong>
<div style="text-align: left;"><span style="font-family:FangSong_GB2312;font-size:14px;"><span style="line-height: 17.7637786865234px; white-space: pre-wrap;"><strong>
</strong></span></span></div>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">
</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">看到</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">关键字，</span><span style="font-family: FangSong_GB2312;">C++</span><span style="font-family: FangSong_GB2312;">程序员首先想到的可能是</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">常量。这可不是良好的条件反射。如果只知道用</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">定义常量，那么相当于把火药仅用于制作鞭炮。</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">更大的魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">const </span><span style="font-family: FangSong_GB2312;">是</span><span style="font-family: FangSong_GB2312;">constant</span><span style="font-family: FangSong_GB2312;">的缩写，“恒定不变”的意思。被</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。所以很多</span><span style="font-family: FangSong_GB2312;">C++</span><span style="font-family: FangSong_GB2312;">程序设计书籍建议：“</span><span style="font-family: FangSong_GB2312;">Useconst whenever you need”</span><span style="font-family: FangSong_GB2312;">。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">
</span></span></strong>
<div style="text-align: left; line-height: 0.47cm; white-space: pre-wrap;"><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>     1.</strong></span><span style=" line-height: 0.47cm; text-indent: 0.74cm; font-family: FangSong_GB2312;"><strong><span style="background: rgb(255, 255, 0);">用const</span><span style="background: rgb(255, 255, 0);">修饰函数的参数</span></strong></span></div><div style="text-align: left;"><span style="font-family:FangSong_GB2312;font-size:14px;"><span style="line-height: 17.7637786865234px; white-space: pre-wrap;"><strong>
</strong></span></span></div>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;"><span style="background: rgb(255, 255, 0);">
</span></span></span></strong>
<span style="font-weight: bold;"><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">修饰，否则该参数将失去输出功能。<span style="font-family: 'AR PL UMing HK', serif;"><span style="background: rgb(0, 255, 255);">const</span></span><span style="background: rgb(0, 255, 255);">只能修饰输入参数：</span></span></span></span>
<strong><span style="font-family: FangSong_GB2312;"><u><span style="font-size:14px;">如果输入参数采用“指针传递”，那么加const修饰可以防止意外地改动该指针，起到保护作用。</span></u></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">例如</span><span style="font-family: FangSong_GB2312;">StringCopy</span><span style="font-family: FangSong_GB2312;">函数：</span></span></strong>
<strong><span style="font-family: FangSong_GB2312;"><span style="font-size:14px;">void StringCopy(char*strDestination, const char *strSource);</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">其中</span><span style="font-family: FangSong_GB2312;">strSource</span><span style="font-family: FangSong_GB2312;">是输入参数，</span><span style="font-family: FangSong_GB2312;">strDestination</span><span style="font-family: FangSong_GB2312;">是输出参数。给</span><span style="font-family: FangSong_GB2312;">strSource</span><span style="font-family: FangSong_GB2312;">加上</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">修饰后，<u>如果函数体内的语句试图改动strSource的内容，编译器将指出错误。</u></span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">修饰。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">例如不要将函数</span><span style="font-family: FangSong_GB2312;">voidFunc1(int x) </span><span style="font-family: FangSong_GB2312;">写成</span><span style="font-family: FangSong_GB2312;">voidFunc1(const int x)</span><span style="font-family: FangSong_GB2312;">。同理不要将函数</span><span style="font-family: FangSong_GB2312;">voidFunc2(A a) </span><span style="font-family: FangSong_GB2312;">写成</span><span style="font-family: FangSong_GB2312;">voidFunc2(const A a)</span><span style="font-family: FangSong_GB2312;">。其中</span><span style="font-family: FangSong_GB2312;">A</span><span style="font-family: FangSong_GB2312;">为用户自定义的数据类型。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">对于非内部数据类型的参数而言，象</span><span style="font-family: FangSong_GB2312;">voidFunc(A a) </span><span style="font-family: FangSong_GB2312;">这样声明的函数注定效率比较底。因为函数体内将产生</span><span style="font-family: FangSong_GB2312;">A</span><span style="font-family: FangSong_GB2312;">类型的临时对象用于复制参数</span><span style="font-family: FangSong_GB2312;">a</span><span style="font-family: FangSong_GB2312;">，而临时对象的构造、复制、析构过程都将消耗时间。</span></span></strong>
<strong><span style="font-family: FangSong_GB2312;"><u><span style="font-size:14px;">为了提高效率，可以将函数声明改为voidFunc(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数voidFunc(A &a) 存在一个缺点：</span></u></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">“</span><span style="font-family: FangSong_GB2312;">引用传递”有可能改变参数</span><span style="font-family: FangSong_GB2312;">a</span><span style="font-family: FangSong_GB2312;">，这是我们不期望的。解决这个问题很容易，加</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">修饰即可，因此函数最终成为</span><span style="font-family: FangSong_GB2312;">voidFunc(const A &a)</span><span style="font-family: FangSong_GB2312;">。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">以此类推，是否应将</span><span style="font-family: FangSong_GB2312;">voidFunc(int x) </span><span style="font-family: FangSong_GB2312;">改写为</span><span style="font-family: FangSong_GB2312;">voidFunc(const int&x)</span><span style="font-family: FangSong_GB2312;">，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">问题是如此的缠绵，我只好将“</span><span style="font-family: FangSong_GB2312;">const&”</span><span style="font-family: FangSong_GB2312;">修饰输入参数的用法总结一下。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312; color: rgb(255, 0, 0);">对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const</span><span style="font-family: FangSong_GB2312; color: rgb(255, 0, 0);">引用传递”，目的是提高效率</span><span style="font-family: FangSong_GB2312;">。例如将</span><span style="font-family: FangSong_GB2312;">voidFunc(A a) </span><span style="font-family: FangSong_GB2312;">改为</span><span style="font-family: FangSong_GB2312;">voidFunc(const A &a)</span><span style="font-family: FangSong_GB2312;">。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">对于内部数据类型的输入参数，不要将“值传递”的方式改为“</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如</span><span style="font-family: FangSong_GB2312;">voidFunc(int x) </span><span style="font-family: FangSong_GB2312;">不应该改为</span><span style="font-family: FangSong_GB2312;">voidFunc(const int &x)</span><span style="font-family: FangSong_GB2312;">。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">
</span></span></strong>
<div style="text-align: left; line-height: 0.47cm; white-space: pre-wrap;"><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>     2</strong></span><span style=" line-height: 0.47cm; text-indent: 0.74cm; font-family: FangSong_GB2312;"><strong><span style="background: rgb(255, 255, 0);">用const</span><span style="background: rgb(255, 255, 0);">修饰函数的返回值</span></strong></span></div><div style="text-align: left;"><span style="font-family:FangSong_GB2312;font-size:14px;"><span style="line-height: 17.7637786865234px; white-space: pre-wrap;"><strong>
</strong></span></span></div>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;"><span style="background: rgb(255, 255, 0);">
</span></span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">如果给以“指针传递”方式的函数返回值加</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">修饰，那么函数返回值（即指针）的内容不能被修改，<u>该返回值只能被赋给加const修饰的同类型指针。例如函数
</u></span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">constchar * GetString(void);</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">如下语句将出现编译错误：</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">char*str = GetString();</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">正确的用法是</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">constchar *str =GetString();</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">修饰没有任何价值。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">例如不要把函数</span><span style="font-family: FangSong_GB2312;">intGetInt(void) </span><span style="font-family: FangSong_GB2312;">写成</span><span style="font-family: FangSong_GB2312;">constint GetInt(void)</span><span style="font-family: FangSong_GB2312;">。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">同理不要把函数</span><span style="font-family: FangSong_GB2312;">AGetA(void) </span><span style="font-family: FangSong_GB2312;">写成</span><span style="font-family: FangSong_GB2312;">constA GetA(void)</span><span style="font-family: FangSong_GB2312;">，其中</span><span style="font-family: FangSong_GB2312;">A</span><span style="font-family: FangSong_GB2312;">为用户自定义的数据类型。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">如果返回值不是内部数据类型，将函数</span><span style="font-family: FangSong_GB2312;">AGetA(void) </span><span style="font-family: FangSong_GB2312;">改写为</span><span style="font-family: FangSong_GB2312;">constA &GetA(void)</span><span style="font-family: FangSong_GB2312;">的确能提高效率。但此时千万千万要小心，一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了，否则程序会出错。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">例如：</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">classA</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">{</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">A & operate = (const A &other); // </span><span style="font-family: FangSong_GB2312;">赋值函数</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">};</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">Aa, b, c; // a, b, c </span><span style="font-family: FangSong_GB2312;">为</span><span style="font-family: FangSong_GB2312;">A</span><span style="font-family: FangSong_GB2312;">的对象</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">
</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">a= b = c; // </span><span style="font-family: FangSong_GB2312;">正常的链式赋值</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">(a= b) = c; // </span><span style="font-family: FangSong_GB2312;">不正常的链式赋值，但合法</span></span></strong>
<div style="text-align: left; line-height: 0.47cm; white-space: pre-wrap;"><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>如果将赋值函数的返回值加</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>const</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>修饰，那么该返回值的内容不允许被改动。上例中，语句</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>a= b = c </strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>仍然正确，但是语句</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>(a= b) = c </strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>则是非法的。</strong></span></div><div style="text-align: left;"><span style="font-family:AR PL UMing HK, serif;font-size:14px;"><span style="line-height: 17.7637786865234px; white-space: pre-wrap;"><strong>
</strong></span></span></div><span style="font-size:14px;font-weight: bold; line-height: 0.47cm; white-space: pre-wrap;"></span><div style="text-align: left;"><span style="line-height: 0.47cm; font-family: 'AR PL UMing HK', serif;"><span style="background: rgb(255, 255, 0);">3const </span></span><span style="font-family: FangSong_GB2312; line-height: 0.47cm; background: rgb(255, 255, 0);">成员函数</span></div>
<span style="font-weight: bold;"><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;"><span style="font-family: 'AR PL UMing HK', serif;"><span style="background: rgb(255, 255, 0);">
</span></span></span></span></span>
<span style="font-weight: bold;"><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;"><span style="font-family: 'AR PL UMing HK', serif;"><span style="background: rgb(255, 255, 0);">3const </span></span><span style="background: rgb(255, 255, 0);">成员函数</span></span></span></span>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">
</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312; color: rgb(255, 0, 0);">任何不会修改数据成员的函数都应该声明为const</span><span style="font-family: FangSong_GB2312; color: rgb(255, 0, 0);">类型。</span><span style="font-family: FangSong_GB2312;">如果在编写</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">成员函数时，不慎修改了数据成员，或者调用了其它非</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">成员函数，编译器将指出错误，这无疑会提高程序的健壮性。以下程序中，类</span><span style="font-family: FangSong_GB2312;">stack</span><span style="font-family: FangSong_GB2312;">的成员函数</span><span style="font-family: FangSong_GB2312;">GetCount</span><span style="font-family: FangSong_GB2312;">仅用于计数，从逻辑上讲</span><span style="font-family: FangSong_GB2312;">GetCount</span><span style="font-family: FangSong_GB2312;">应当为</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">函数。编译器将指出</span><span style="font-family: FangSong_GB2312;">GetCount</span><span style="font-family: FangSong_GB2312;">函数中的错误。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">classStack</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">{</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">public:</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">void Push(int elem);</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">int Pop(void);</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">intGetCount(void) const; // const </span><span style="font-family: FangSong_GB2312;">成员函数</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">private:</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">intm_num;</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">int m_data[100];</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">};</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">int Stack::GetCount(void)const</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">{</span></span></strong>
<div style="text-align: left;"><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>++ m_num; // </strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>编译错误，企图修改数据成员</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>m_num</strong></span></div><strong></strong><div style="text-align: left;"><span style="font-family: FangSong_GB2312;font-size:14px; line-height: 0.47cm;">Pop();// </span></div>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">Pop();// </span><span style="font-family: FangSong_GB2312;">编译错误，企图调用非</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">函数</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">returnm_num;</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">}</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">const </span><span style="font-family: FangSong_GB2312;">成员函数的声明看起来怪怪的：</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">关键字只能放在函数声明的尾部，大概是因为其它地方都已经被占用了。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">关于</span><span style="font-family: FangSong_GB2312;">Const</span><span style="font-family: FangSong_GB2312;">函数的几点规则：</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">
</span></span></strong>
<div style="text-align: left;"><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>a.const</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>对象只能访问</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>const</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>成员函数</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>,</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>而非</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>const</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>对象可以访问任意的成员函数</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>,</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>包括</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>const</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>成员函数</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>.</strong></span></div><strong></strong><div style="text-align: left;"><span style="font-family: FangSong_GB2312;font-size:14px; line-height: 0.47cm;">b.const</span></div>
<div style="text-align: left;"><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>b.const</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>对象的成员是不可修改的</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>,</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>然而</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>const</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>对象通过指针维护的对象却是可以修改的</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>.</strong></span></div><strong></strong><div style="text-align: left;"><span style="font-family: FangSong_GB2312;font-size:14px; line-height: 0.47cm;">c.const</span></div>
<div style="text-align: left;"><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>c.const</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>成员函数不可以修改对象的数据</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>,</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>不管对象是否具有</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>const</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>性质</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>.</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>它在编译时</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>,</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>以是否修改成员数据为依据</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>,</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>进行检查</strong></span><span style=" line-height: 0.47cm; font-family: FangSong_GB2312;"><strong>.</strong></span></div><strong></strong><div style="text-align: left;"><span style="font-family: FangSong_GB2312;font-size:14px; line-height: 0.47cm;">e.</span></div>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">e.</span><span style="font-family: FangSong_GB2312;">然而加上</span><span style="font-family: FangSong_GB2312;">mutable</span><span style="font-family: FangSong_GB2312;">修饰符的数据成员</span><span style="font-family: FangSong_GB2312;">,</span><span style="font-family: FangSong_GB2312;">对于任何情况下通过任何手段都可修改</span><span style="font-family: FangSong_GB2312;">,</span><span style="font-family: FangSong_GB2312;">自然此时的</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">成员函数是可以修改它的</span></span></strong>
<strong><span style="font-family: FangSong_GB2312;"><span style="font-size:14px;"> </span></span></strong>
<strong><span style="font-family: FangSong_GB2312;"><span style="font-size:14px;"> </span></span></strong>
<strong><span style="font-family: FangSong_GB2312;"><span style="font-size:14px;">补充：</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">标题</span><span style="font-family: FangSong_GB2312;">:const</span><span style="font-family: FangSong_GB2312;">放在后面有什么意思？</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">--------------------------------------------------------------------------------</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">一个函数</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">AcGePoint3dstartPoint() const;</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">放在后面跟前面有区别么</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">==></span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">准确的说</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">是修饰</span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">指向的对象的</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">譬如，我们定义了</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">classA{</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">public:</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">f(int);</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">};</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">这里</span><span style="font-family: FangSong_GB2312;">f</span><span style="font-family: FangSong_GB2312;">函数其实有两个参数，第一个是</span><span style="font-family: FangSong_GB2312;">A*const this, </span><span style="font-family: FangSong_GB2312;">另一个才是</span><span style="font-family: FangSong_GB2312;">int</span><span style="font-family: FangSong_GB2312;">类型的参数</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">如果我们不想</span><span style="font-family: FangSong_GB2312;">f</span><span style="font-family: FangSong_GB2312;">函数改变参数的值，可以把函数原型改为</span><span style="font-family: FangSong_GB2312;">f(constint),</span><span style="font-family: FangSong_GB2312;">但如果我们不允许</span><span style="font-family: FangSong_GB2312;">f</span><span style="font-family: FangSong_GB2312;">改变</span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">指向的对象呢？因为</span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">是隐含参数，</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">没法直接修饰它，就加在函数的后面了，表示</span><span style="font-family: FangSong_GB2312;">this</span><span style="font-family: FangSong_GB2312;">的类型是</span><span style="font-family: FangSong_GB2312;">constA *constthis</span><span style="font-family: FangSong_GB2312;">。</span></span></strong>
<strong><span style="font-size:14px;"><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">修饰</span><span style="font-family: FangSong_GB2312;">*this</span><span style="font-family: FangSong_GB2312;">是本质，至于说“表示该成员函数不会修改类的数据。否则会编译报错”之类的说法只是一个现象，根源就是因为</span><span style="font-family: FangSong_GB2312;">*this</span><span style="font-family: FangSong_GB2312;">是</span><span style="font-family: FangSong_GB2312;">const</span><span style="font-family: FangSong_GB2312;">类型的</span></span></strong>
Jngfirst
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
const的用法，特别是用在函数前面与后面的区别！
han_itrus的专栏
12-18 626
在普通的非 const成员函数中，this的类型是一个指向类类型的 const指针。可以改变this所指向的值，但不能改变 this所保存的地址。 在 const成员函数中，this的类型是一个指向 const类类型对象的 const指针。既不能改变 this所指向的对象，也不能改变 this所保存的地址。  关键字：Const，Const函数，Const变量，函数后面的Const 看到con
函数末尾加const的作用
磊磊的博客
01-05 1847
#include <iostream> using namespace std; class Test { int num; public: Test() { num=10; } void print1() { cout<<num<<endl; } void print2() const { cout<<num<<endl; .
函数后面加一个const关键字的作用
qq_656236576的博客
11-25 5596
非静态成员函数后面加const（加到非成员函数或静态成员后面会产生编译错误），表示成员函数隐含传入的this指针为const指针，决定了在该成员函数中，任意修改它所在的类的成员的操作都是不允许的（因为隐含了对this指针的const引用）；唯一的例外是对于mutable修饰的成员。加了const的成员函数可以被非const对象和const对象调用，但不加const的成员函数只能被非const对象调用。 class A { private: int m_a; public: A
在函数后面加const
qq_55621259的博客
08-13 1万+
表示函数不可以修改类中的成员！一旦我们想要改变类成员的值便会报错！这样的好处在于：1、提高了代码的可读性，别人看到你这个就知道你这个函数没有改变类成员。2、提高代码的可靠性，即前面说的若想改变改变则会报错！首先，我们要确认一点。在函数后面加const只能在类的成员函数中实现！普通的函数是无法进行这样的操作的！如果我们想克服这种限制，可以选择在想修改的成员变量前用mutable来修饰表示是可修改的！相信大家都见过在函数前面加const的情况，即修饰函数的返回值！那么在函数后面加const的作用是什么呢？...
const在函数前后的意义
doubleintfloat的博客
10-27 7497
const在函数前后的意义 一、const在函数后面 1、只允许在类的非静态成员函数后面加const；(加到非成员函数 或 静态成员后面会产生编译错); 2、后面加的const其实是对隐含传入参数this指向类对象的修饰，即 *this 是被const修饰，那this所指向的类对象的成员都是不允许被修改的； (备注：有人认为const修饰的是this指针，那么不能改变的就是this指针本身，而不是this指针指向的成员，其实这个const修饰的是this和(*this),下面代码有详细解释,tis指针的实
C++ 中const修饰虚函数实例详解
10-19
当`const`放在函数声明后面的圆括号外时，它修饰的是函数的返回值，表示函数不会改变其返回的对象。而当`const`修饰函数参数或者放在函数定义的末尾时，它表示该函数不会修改对象的状态（即对象的非`const`成员变量...
Const,Const函数,Const变量,函数后面的Const.txt
06-11
### 关于Const、Const函数与Const变量的理解 在C++编程语言中，`const`关键字是一种类型限定符，被广泛用于提升代码的安全性与可读性。本文将深入探讨`const`的不同用法及其背后的原理。 #### 1. `const`修饰参数 ...
C语言中const与指针使用方法总结
08-29
在C语言中，`const` 关键字是用来声明常量或只读变量的，它可以用于修饰变量、函数参数、返回值等。当`const`与指针结合使用时，会带来一些特殊的用法和规则，这有助于提升代码的可读性和安全性。下面将详细介绍`...
C/C++中CONST用法总结(推荐)
08-30
六、Const 在函数声明中的使用 Const 修饰符可以用于修饰函数的返回值和形参，例如 `int func() const;`。Const 修饰返回值主要用于操作符的重载。 七、Const 与 Define 宏定义的区别 Const 常量和 Define 宏定义...
C++中const应放在类型前还是后
09-02
在类的成员函数中，`const`关键字可以修饰成员函数，表明这个函数不会修改对象的状态。这有助于编译器进行类型检查，并且在某些情况下允许`const`对象调用`const`成员函数。 总结起来，`const`在C++中的位置可以...
C++ const和&在函数参数中的含义
见牛羊的博客
06-29 9400
知识点小结 C++中有的函数参数会用const来传递，同时配合&取地址符一起使用，形式如 void form(const int &a)。一开始并不懂其中深意，后来查了一下，发现这种用法和值传递的效果是一样的。但是因为引用的效率较高，所以在参数是复杂的数据类型的时候，采用这种常量引用的方法。这样既使用了引用，又使用const限制了对参数的修改。具体代码如下图所示： #inc...
const&和int& const 理解笔记（图、代码、讲解）
xuelang532777032的博客
05-11 2929
因为const的缘故，你必须返回常量！而行参里面是const int&也就是说你必须返回常引用，而你返回的是x+3或者x+4这种是变量（变量这个词只是为了方便理解！因为x对a进行了深度拷贝，你可以理解成复制了一个 b=10,然后函数里b=3,打印b，这就跟a没关系，不改变a的值。我们是让他返回int型，是有一个返回复制了 x*3(也就是返回复制了a*3)的过程，而你返回引用则不会。下面这是常量的引用，被const定义的是常量，不能修改值。相反，返回的是对象本身。所以结果就变成啥了，变成你只能传啥返回啥！
const的作用和用法
热门推荐
weixin_43282440的博客
02-11 1万+
一、const的作用 1.为给读你代码的人传达非常有用的信息，声明一个参数为常量是为了告诉用户这个参数的应用目的； 2.通过给优化器一些附加信息，使关键字const也许能产生更紧凑的代码； 3.合理使用关键字const可以使编译器很自然的保护那些不希望被修改的参数，防止无意的代码修改，可以减少bug的出现； 二、const的用法 常变量： const 类型说明符 变量名 常引用：...
【C++】const关键字详解 && volatile关键字了解
Suk_god的博客
03-23 2473
const的特性 详解 volatile关键字 const volatile的组合关键字含义
const & 指针 & 引用
qq_55185342的博客
11-25 724
const & 指针 & 引用
C++ const用法总结（菜鸟笔记）
最新发布
m0_51221159的博客
01-04 1296
const 是 constant 的缩写，本意是不变的，不易改变的意思。
函数名后面加上const的作用
墨非
10-08 3172
在C++中，非静态成员函数的函数名后面可以加上const关键字（静态函数和非成员函数都不能加，加上后编译会出错），加上后该函数隐式传入的this指针将const指针。 例如执行下面的代码： #include #include #include using namespace std; class Sale_Date { public : void isbn() { cout << ty
C++之const关键字详解
janeqi1987的专栏
09-17 2994
const变量 它的值不能被改变，只读的变量。const对象一旦创建后其值就不能再改变，所以const对象必须初始化。初始值可以是任意复杂的表达式： const int bufSize = get_size(); //正确：运行时初始化 const int size = 42; //正确：运行时初始化 const int size; ...
C++ const 详解
顺其自然~专栏
05-26 1万+
2）如果函数名、参数、返回值都相同的const成员函数和非const成员函数是可以构成重载，那么const对象调用const成员函数，非const对象默认调用非const的成员函数。上面定义一个可变的指针，指向一个const 的值，这个是不允许的。value为成员变量，func函数为const成员函数，如果要返回value的引用，这里的func函数返回值必须要加上const，改为，但是，即使用引用，如果只是作为输入用，最好加上const 修饰，这样就不会改变实参的值，如果刻意修改，编译器会报错。
C++ const 函数的作用和用法
06-06
C++中的const函数是指在函数的参数列表后面加上const关键字，表示该函数不会修改所操作的对象。const函数可以用来保护对象的数据成员，确保在函数调用期间它们不会被修改，从而提高程序的健壮性和安全性。 const...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值