c++中 const的幾個(gè)作用是什么？

c++中 const的幾個(gè)作用是什么？

（1）可以定義const常量，具有不可變性。例如：constintMax=100;intArray[Max];（2）便于進(jìn)行類型檢查，使編譯器對(duì)處理內(nèi)容有更多了解，消除了一些隱患。

例如：voidf(constinti){………}編譯器就會(huì)知道i是一個(gè)常量，不允許修改;（3）可以避免意義模糊的數(shù)字出現(xiàn)，同樣可以很方便地進(jìn)行參數(shù)的調(diào)整和修改。

同宏定義一樣，可以做到不變則已，一變都變！如（1）中，如果想修改Max的內(nèi)容，只需要：constintMax=youwant;即可！（4）可以保護(hù)被修飾的東西，防止意外的修改，增強(qiáng)程序的健壯性。還是上面的例子，如果在函數(shù)體內(nèi)修改了i，編譯器就會(huì)報(bào)錯(cuò);例如：voidf(constinti){i=10;//error!}（5）為函數(shù)重載提供了一個(gè)參考。classA{……voidf(inti){……}//一個(gè)函數(shù)voidf(inti)const{……}//上一個(gè)函數(shù)的重載……};（6）可以節(jié)省空間，避免不必要的內(nèi)存分配。例如：#definePI3.14159//常量宏constdoulbePi=3.14159;//此時(shí)并未將Pi放入ROM中……doublei=Pi;//此時(shí)為Pi分配內(nèi)存，以后不再分配！doubleI=PI;//編譯期間進(jìn)行宏替換，分配內(nèi)存doublej=Pi;//沒有內(nèi)存分配doubleJ=PI;//再進(jìn)行宏替換，又一次分配內(nèi)存！const定義常量從匯編的角度來看，只是給出了對(duì)應(yīng)的內(nèi)存地址，而不是象#define一樣給出的是立即數(shù)，所以，const定義的常量在程序運(yùn)行過程中只有一份拷貝，而#define定義的常量在內(nèi)存中有若干個(gè)拷貝。

（7）提高了效率。編譯器通常不為普通const常量分配存儲(chǔ)空間，而是將它們保存在符號(hào)表中，這使得它成為一個(gè)編譯期間的常量，沒有了存儲(chǔ)與讀內(nèi)存的操作，使得它的效率也很高。

const的作用是什么?

一、const int 和int 的區(qū)別
1、返回值
const int & 是返回這個(gè)數(shù)值的一個(gè)常量的引用。
而int 是返回這個(gè)數(shù)值的一個(gè)拷貝。

int 是進(jìn)行拷貝構(gòu)造，而const int & 是返回的引用。

拷貝構(gòu)造更消耗時(shí)間，與此同時(shí)還用析構(gòu)函數(shù)。因?yàn)楫a(chǎn)生了一個(gè)拷貝，你就可以輕易地修改拷貝的內(nèi)容。
2、取指針
const int類型一旦定義以后就不能修改，int類型是隨時(shí)可以修改的。
在取指針方面，const有略復(fù)雜的東西，但是常規(guī)的、合理的操作不應(yīng)該涉及到，因?yàn)閏onst int是用來保存一些全局常量的，這些常量在編譯期可以改，在運(yùn)行期不能改。

聽起來這像宏，其實(shí)這確實(shí)就是用來取代宏的： #define PI 3.14 const float Pi = 3.14; 如果你的代碼里用到了100次PI（宏），你的代碼中會(huì)保存100個(gè)3.14這個(gè)常數(shù)。
鑒于使用常數(shù)進(jìn)行運(yùn)算的機(jī)器代碼很多時(shí)候會(huì)比使用變量來的長(zhǎng)，如果你換用100次Pi（const float)，程序編譯后的機(jī)器碼里就不需要出現(xiàn)100次常量3.14，只要在需要的時(shí)候引用存有3.14的常量就行了。
特別在復(fù)雜的運(yùn)算里，3.14這個(gè)常量（其實(shí)是無(wú)法修改的變量）會(huì)被一直裝載在寄存器里帶來一些性能提升。

3、內(nèi)容
constint* p; //p可變，p指向的內(nèi)容不可變，int const* p; //p可變，p指向的內(nèi)容不可變。?int* const p; //p不可變，p指向的內(nèi)容可變?const int* const p; //p和p指向的內(nèi)容都不可變。
二、const的作用：
1、可以定義const常量，具有不可變性。

例如：const int Max=100; Max++會(huì)產(chǎn)生錯(cuò)誤;
2、便于進(jìn)行類型檢查，使編譯器對(duì)處理內(nèi)容有更多了解，消除了一些隱患。
例如： void f(const int i) { ………} 編譯器就會(huì)知道i是一個(gè)常量，不允許修改;
3、可以避免意義模糊的數(shù)字出現(xiàn)，同樣可以很方便地進(jìn)行參數(shù)的調(diào)整和修改。 同宏定義一樣，可以做到不變則已，一變都變！
如1中，如果想修改Max的內(nèi)容，只需要它修改成：const int Max=you want;即可！
4、可以保護(hù)被修飾的東西，防止意外的修改，增強(qiáng)程序的健壯性。

還是上面的例子，如果在函數(shù)體內(nèi)修改了i，編譯器就會(huì)報(bào)錯(cuò);
例如： void f(const int i) { i=10;//error! }
5、可以節(jié)省空間，避免不必要的內(nèi)存分配。

擴(kuò)展資料
當(dāng)const修飾的是指針類型，那么指針的值就不能改變，即不能指向其他地址，但是可以通過指針修改其指向地址里面的值。
當(dāng)const修飾時(shí)指針指向的類型時(shí)候，那么指針被指向其他地址，但是不能通過指針修改指針里面的值。
1）先從const int i說起。

使用const修飾的i我們稱之為符號(hào)常量。即，i不能在其他地方被重新賦值了。注意：const int i與int const i是等價(jià)的，相同的，即const與int的位置無(wú)所謂。
2）const int *p
看例子：
int i1=30;
int i2=40;
const int *p=&i1;
p=&i2; //此處，p可以在任何時(shí)候重新賦值一個(gè)新的內(nèi)存地址。

i2=80; //這里能用*p=80來代替嗎？答案是不能
printf(\”%d\”,*p); //輸出80
分析：p的值是可以被修改的，即它可以重新指向另一個(gè)地址。但是不能通過*p來修改i2的值。
首先，const修飾的是整個(gè)*p(注意，是*p而不是p)，所以*p是常量，是不能被賦值的。雖然p所指的i2是變量而不是常量;
其次，p前并沒有用const修飾，所以p是指針變量。

能被賦值重新指向另一個(gè)內(nèi)存地址。

C語(yǔ)言const的這個(gè)優(yōu)點(diǎn)怎么解釋？

這種說法,個(gè)人認(rèn)為不是很確切,顯然沒有考慮編譯器優(yōu)化的可能性,const修飾的變量完全有可能被編譯器直接優(yōu)化為常量另外,那個(gè)例子也是完全錯(cuò)誤的這里double i=Pi; file://此/時(shí)為Pi分配內(nèi)存，以后不再分配！ double I=PI; file://編/譯期間進(jìn)行宏替換，分配內(nèi)存 （//宏替換，，為啥分配內(nèi)存？）double j=Pi; file://沒/有內(nèi)存分配double J=PI; file://再/進(jìn)行宏替換，又一次分配內(nèi)存！被分配到內(nèi)存的是變量i I j J,而不是Pi,這里最多只能說這樣的做法有可能增大程序本身的大小(注意,只是可能,編譯器極有可能優(yōu)化的)再次,即便不考慮編譯器優(yōu)化,如果你用const修飾,看似ms是減小了內(nèi)存的消耗,但是,當(dāng)你要訪問const變量時(shí),你不是還要讀取內(nèi)存么,這就大大降低了程序運(yùn)行的速度,讀取內(nèi)存的速度可是遠(yuǎn)遠(yuǎn)低于直接使用立即數(shù)的

const 作用是

詳細(xì)內(nèi)容： 1、什么是const? 常類型是指使用類型修飾符const說明的類型，常類型的變量或?qū)ο蟮闹凳遣荒鼙桓碌?。（?dāng)然，我們可以偷梁換柱進(jìn)行更新：） 2、為什么引入const？ const 推出的初始目的，正是為了取代預(yù)編譯指令，消除它的缺點(diǎn)，同時(shí)繼承它的優(yōu)點(diǎn)。

3、cons有什么主要的作用？ （1）可以定義const常量，具有不可變性。

例如： const int Max=100; int Array[Max]; （2）便于進(jìn)行類型檢查，使編譯器對(duì)處理內(nèi)容有更多了解，消除了一些隱患。例如： void f(const int i) { ………} 編譯器就會(huì)知道i是一個(gè)常量，不允許修改; （3）可以避免意義模糊的數(shù)字出現(xiàn)，同樣可以很方便地進(jìn)行參數(shù)的調(diào)整和修改。 同宏定義一樣，可以做到不變則已，一變都變！如（1）中，如果想修改Max的內(nèi)容，只需要：const int Max=you want;即可！ （4）可以保護(hù)被修飾的東西，防止意外的修改，增強(qiáng)程序的健壯性。 還是上面的例子，如果在函數(shù)體內(nèi)修改了i，編譯器就會(huì)報(bào)錯(cuò); 例如： void f(const int i) { i=10;//error! } （5） 為函數(shù)重載提供了一個(gè)參考。

class A { …… void f(int i) {……} //一個(gè)函數(shù) void f(int i) const {……} //上一個(gè)函數(shù)的重載 …… }; （6） 可以節(jié)省空間，避免不必要的內(nèi)存分配。 例如： #define PI 3.14159 //常量宏 const doulbe Pi=3.14159; //此時(shí)并未將Pi放入ROM中 …… double i=Pi; //此時(shí)為Pi分配內(nèi)存，以后不再分配！ double I=PI; //編譯期間進(jìn)行宏替換，分配內(nèi)存 double j=Pi; //沒有內(nèi)存分配 double J=PI; //再進(jìn)行宏替換，又一次分配內(nèi)存！ const定義常量從匯編的角度來看，只是給出了對(duì)應(yīng)的內(nèi)存地址，而不是象#define一樣給出的是立即數(shù)，所以，const定義的常量在程序運(yùn)行過程中只有一份拷貝，而#define定義的常量在內(nèi)存中有若干個(gè)拷貝。 （7） 提高了效率。

編譯器通常不為普通const常量分配存儲(chǔ)空間，而是將它們保存在符號(hào)表中，這使得它成為一個(gè)編譯期間的常量，沒有了存儲(chǔ)與讀內(nèi)存的操作，使得它的效率也很高。 4、如何使用const？ （1）修飾一般常量 一般常量是指簡(jiǎn)單類型的常量。這種常量在定義時(shí)，修飾符const可以用在類型說明符前，也可以用在類型說明符后。

例如： int const x=2; 或 const int x=2; （2）修飾常數(shù)組 定義或說明一個(gè)常數(shù)組可采用如下格式： int const a[5]={1, 2, 3, 4, 5}; const int a[5]={1, 2, 3, 4, 5}; （3）修飾常對(duì)象 常對(duì)象是指對(duì)象常量，定義格式如下： class A; const A a; A const a; 定義常對(duì)象時(shí)，同樣要進(jìn)行初始化，并且該對(duì)象不能再被更新，修飾符const可以放在類名后面，也可以放在類名前面。 （4）修飾常指針 const int *A; //const修飾指向的對(duì)象，A可變，A指向的對(duì)象不可變 int const *A; //const修飾指向的對(duì)象，A可變，A指向的對(duì)象不可變 int *const A; //const修飾指針A， A不可變，A指向的對(duì)象可變 const int *const A;//指針A和A指向的對(duì)象都不可變 （5）修飾常引用 使用const修飾符也可以說明引用，被說明的引用為常引用，該引用所引用的對(duì)象不能被更新。其定義格式如下： const double & v; （6）修飾函數(shù)的常參數(shù) const修飾符也可以修飾函數(shù)的傳遞參數(shù)，格式如下： void Fun(const int Var); 告訴編譯器Var在函數(shù)體中的無(wú)法改變，從而防止了使用者的一些無(wú)意的或錯(cuò)誤的修改。

（7）修飾函數(shù)的返回值： const修飾符也可以修飾函數(shù)的返回值，是返回值不可被改變，格式如下： const int Fun1(); const MyClass Fun2(); （8）修飾類的成員函數(shù)： const修飾符也可以修飾類的成員函數(shù)，格式如下： class ClassName { public: int Fun() const; ….. }; 這樣，在調(diào)用函數(shù)Fun時(shí)就不能修改類里面的數(shù)據(jù) （9）在另一連接文件中引用const常量 extern const int i;//正確的引用 extern const int j=10;//錯(cuò)誤！常量不可以被再次賦值 另外，還要注意，常量必須初始化！ 例如： const int i=5; 5、幾點(diǎn)值得討論的地方： （1）const究竟意味著什么？ 說了這么多，你認(rèn)為const意味著什么？一種修飾符？接口抽象？一種新類型？ 也許都是，在Stroustup最初引入這個(gè)關(guān)鍵字時(shí)，只是為對(duì)象放入ROM做出了一種可能，對(duì)于const對(duì)象，C++既允許對(duì)其進(jìn)行靜態(tài)初始化，也允許對(duì)他進(jìn)行動(dòng)態(tài)初始化。理想的const對(duì)象應(yīng)該在其構(gòu)造函數(shù)完成之前都是可寫的，在析夠函數(shù)執(zhí)行開始后也都是可寫的，換句話說，const對(duì)象具有從構(gòu)造函數(shù)完成到析夠函數(shù)執(zhí)行之前的不變性，如果違反了這條規(guī)則，結(jié)果都是未定義的！雖然我們把const放入ROM中，但這并不能夠保證const的任何形式的墮落，我們后面會(huì)給出具體的辦法。無(wú)論const對(duì)象被放入ROM中，還是通過存儲(chǔ)保護(hù)機(jī)制加以保護(hù)，都只能保證，對(duì)于用戶而言這個(gè)對(duì)象沒有改變。換句話說，廢料收集器（我們以后會(huì)詳細(xì)討論，這就一筆帶過）或數(shù)據(jù)庫(kù)系統(tǒng)對(duì)一個(gè)const的修改怎沒有任何問題。

（2）位元const V.S. 抽象const? 對(duì)于關(guān)鍵字const的解釋有好幾種方式，最常見的就是位元const 和 抽象const。下面我們看一個(gè)例子： class A { public: …… A f(const A& a); …… }; 如果采用抽象const進(jìn)行解釋，那就是f函數(shù)不會(huì)去改變所引用對(duì)象的抽象值，如果采用位元const進(jìn)行解釋，那就成了f函數(shù)不會(huì)去改變所引用對(duì)象的任何位元。 我們可以看到位元解釋正是c++對(duì)const問題的定義，const成員函數(shù)不被允許修改它所在對(duì)象的任何一個(gè)數(shù)據(jù)成員。 為什么這樣呢？因?yàn)槭褂梦辉猚onst有2個(gè)好處： **的好處是可以很容易地檢測(cè)到違反位元const規(guī)定的事件：編譯器只用去尋找有沒有對(duì)數(shù)據(jù)成員的賦值就可以了。

另外，如果我們采用了位元const，那么，對(duì)于一些比較簡(jiǎn)單的const對(duì)象，我們就可以把它安全的放入ROM中，對(duì)于一些程序而言，這無(wú)疑是一個(gè)很重要的優(yōu)化方式。（關(guān)于優(yōu)化處理，我們到時(shí)候?qū)ｉT進(jìn)行討論） 當(dāng)然，位元const也有缺點(diǎn)，要不然，抽象const也就沒有產(chǎn)生的必要了。 首先，位元const的抽象性比抽象const的級(jí)別更低！實(shí)際上，大家都知道，一個(gè)庫(kù)接口的抽象性級(jí)別越低，使用這個(gè)庫(kù)就越困難。 其次，使用位元const的庫(kù)接口會(huì)暴露庫(kù)的一些實(shí)現(xiàn)細(xì)節(jié)，而這往往會(huì)帶來一些負(fù)面效應(yīng)。

所以，在庫(kù)接口和程序?qū)崿F(xiàn)細(xì)節(jié)上，我們都應(yīng)該采用抽象const。 有時(shí)，我們可能希望對(duì)const做出一些其它的解釋，那么，就要注意了，目前，大多數(shù)對(duì)const的解釋都是類型不安全的，這里我們就不舉例子了，你可以自己考慮一下，總之，我們盡量避免對(duì)const的重新解釋。 （3）放在類內(nèi)部的常量有什么限制？ 看看下面這個(gè)例子： class A { private: const int c3 = 7; // ??? static int c4 = 7; // ??? static const float c5 = 7; // ??? …… }; 你認(rèn)為上面的3句對(duì)嗎？呵呵，都不對(duì)！使用這種類內(nèi)部的初始化語(yǔ)法的時(shí)候，常量必須是被一個(gè)常量表達(dá)式初始化的整型或枚舉類型，而且必須是static和const形式。

這顯然是一個(gè)很嚴(yán)重的限制！ 那么，我們的標(biāo)準(zhǔn)委員會(huì)為什么做這樣的規(guī)定呢？一般來說，類在一個(gè)頭文件中被聲明，而頭文件被包含到許多互相調(diào)用的單元去。但是，為了避免復(fù)雜的編譯器規(guī)則，C++要求每一個(gè)對(duì)象只有一個(gè)單獨(dú)的定義。如果C++允許在類內(nèi)部定義一個(gè)和對(duì)象一樣占據(jù)內(nèi)存的實(shí)體的話，這種規(guī)則就被破壞了。

（4）如何初始化類內(nèi)部的常量？ 一種方法就是static 和 const 并用，在內(nèi)部初始化，如上面的例子; 另一個(gè)很常見的方法就是初始化列表： class A { public: A(int i=0):test(i) {} private: const int i; }; 還有一種方式就是在外部初始化，例如： class A { public: A() {} private: static const int i;//注意必須是靜態(tài)的！ }; const int A::i=3; （5）常量與數(shù)組的組合有什么特殊嗎？ 我們給出下面的代碼： const int size[3]={10,20,50}; int array[size[2]]; 有什么問題嗎？對(duì)了，編譯通不過！為什么呢？ Const可以用于**，但編譯器不能把一個(gè)**存放在它的符號(hào)表里，所以必須分配內(nèi)存。在這種情況下，const意味著“不能改變的一塊存儲(chǔ)”。然而，其值在編譯時(shí)不能被使用，因?yàn)榫幾g器在編譯時(shí)不需要知道存儲(chǔ)的內(nèi)容。自然，作為數(shù)組的大小就不行了：） 你再看看下面的例子： class A { public: A(int i=0):test[2]({1,2}) {}//你認(rèn)為行嗎？ private: const int test[2]; }; vc6下編譯通不過，為什么呢？ 關(guān)于這個(gè)問題，前些時(shí)間，njboy問我是怎么回事？我反問他：“你認(rèn)為呢？”他想了想，給出了一下解釋，大家可以看看：我們知道編譯器堆初始化列表的操作是在構(gòu)造函數(shù)之內(nèi)，顯式調(diào)用可用代碼之前，初始化的次序依據(jù)數(shù)據(jù)聲明的次序。

初始化時(shí)機(jī)應(yīng)該沒有什么問題，那么就只有是編譯器對(duì)數(shù)組做了什么手腳！其實(shí)做什么手腳，我也不知道，我只好對(duì)他進(jìn)行猜測(cè)：編譯器搜索到test發(fā)現(xiàn)是一個(gè)非靜態(tài)的數(shù)組，于是，為他分配內(nèi)存空間，這里需要注意了，它應(yīng)該是一下分配完，并非先分配test[0],然后利用初始化列表初始化，再分配test[1],這就導(dǎo)致數(shù)組的初始化實(shí)際上是賦值！然而，常量不允許賦值，所以無(wú)法通過。 呵呵，看了這一段冠冕堂皇的話，真讓我笑*了！njboy別怪我揭你短呀：）我對(duì)此的解釋是這樣的：C++標(biāo)準(zhǔn)有一個(gè)規(guī)定，不允許無(wú)序?qū)ο笤陬悆?nèi)部初始化，數(shù)組顯然是一個(gè)無(wú)序的，所以這樣的初始化是錯(cuò)誤的！對(duì)于他，只能在類的外部進(jìn)行初始化，如果想讓它通過，只需要聲明為靜態(tài)的，然后初始化。 這里我們看到，常量與數(shù)組的組合沒有什么特殊！一切都是數(shù)組惹的禍！ （6）this指針是不是const類型的？ this指針是一個(gè)很重要的概念，那該如何理解她呢？也許這個(gè)話題太大了，那我們縮小一些：this指針是個(gè)什么類型的？這要看具體情況：如果在非const成員函數(shù)中，this指針只是一個(gè)類類型的百科;如果在const成員函數(shù)中，this指針是一個(gè)const類類型的;如果在volatile成員函數(shù)中,this指針就是一個(gè)volatile類類型的。

（7）const到底是不是一個(gè)重載的參考對(duì)象？ 先看一下下面的例子： class A { …… void f(int i) {……}//一個(gè)函數(shù) void f(int i) const {……}//上一個(gè)函數(shù)的重載 …… }; 上面是重載是沒有問題的了，那么下面的呢？ class A { …… void f(int i) {……}//一個(gè)函數(shù) void f(const int i) {……}//？？？？？ …… }; 這個(gè)是錯(cuò)誤的，編譯通不過。那么是不是說明內(nèi)部參數(shù)的const不予重載呢？再看下面的例子： class A { …… void f(int& ) {……}//一個(gè)函數(shù) void f(const int& ) {……}//？？？？？ …… }; 這個(gè)程序是正確的，看來上面的結(jié)論是錯(cuò)誤的。為什么會(huì)這樣呢？這要涉及到接口的透明度問題。按值傳遞時(shí)，對(duì)用戶而言，這是透明的，用戶不知道函數(shù)對(duì)形參做了什么手腳，在這種情況下進(jìn)行重載是沒有意義的，所以規(guī)定不能重載！當(dāng)指針或引用被引入時(shí)，用戶就會(huì)對(duì)函數(shù)的操作有了一定的了解，不再是透明的了，這時(shí)重載是有意義的，所以規(guī)定可以重載。

（8）什么情況下為const分配內(nèi)存？ 以下是我想到的可能情況，當(dāng)然，有的編譯器進(jìn)行了優(yōu)化，可能不分配內(nèi)存。 A、作為非靜態(tài)的類成員時(shí); B、用于**時(shí); C、被取地址時(shí); D、在main函數(shù)體內(nèi)部通過函數(shù)來獲得值時(shí); E、const的 class或struct有用戶定義的構(gòu)造函數(shù)、析構(gòu)函數(shù)或基類時(shí);。 F、當(dāng)const的長(zhǎng)度比計(jì)算機(jī)字長(zhǎng)還長(zhǎng)時(shí); G、參數(shù)中的const; H、使用了extern時(shí)。

不知道還有沒有其他情況，歡迎高手指點(diǎn)：） （9）臨時(shí)變量到底是不是常量？ 很多情況下，編譯器必須建立臨時(shí)對(duì)象。像其他任何對(duì)象一樣，它們需要存儲(chǔ)空間而且必須被構(gòu)造和刪除。區(qū)別是我們從來看不到編譯器負(fù)責(zé)決定它們的去留以?。

C語(yǔ)言中const是什么意思。。。

const 推出的初始目的，正是為了取代預(yù)編譯指令，消除它的缺點(diǎn)，同時(shí)繼承它的優(yōu)點(diǎn)。
const關(guān)鍵字使用非常的靈活，這一點(diǎn)和php差別很大，php中const用來在類中定義一個(gè)常量，而在c中，const因位置不同有不同的作用，因情景不同有不同的角色，使用起來也是非常的靈活。

一、const用來修飾普通的變量(指針變量除外)的時(shí)候，const type name 和 type const name 這兩種形式是完全等價(jià)的，都表示其是常量，不能進(jìn)行修改。

二、const用來修飾指針變量的時(shí)候，分為以下四種情況
1、const type *name :這種情況下,const修飾的指針變量name所指向的type類型對(duì)象，也就是說指向的這個(gè)對(duì)象是不能進(jìn)行修改的，因?yàn)槠涫浅Ａ浚羔樧兞看_實(shí)可以進(jìn)行修改的。
2、type const *name :這種情況下,const修飾的指針變量name所指向的type類型對(duì)象，意思完全同上，只是顛倒了以下順序。
3、type * const name :這種情況下,const修飾的指針變量name，也就是說這個(gè)指針變量的值是不能進(jìn)行修改的，但是指針變量所指向的對(duì)象確實(shí)可以修改的。
4、const type * const name :這種情況下,const修飾的指針變量name以及指針變量name所指向的對(duì)象，也就是說這個(gè)指針變量以及這個(gè)指針變量所指向的對(duì)象都是不能進(jìn)行修改的。

擴(kuò)展資料
使用const在一定程度上可以提高程序的安全性和可靠性。另外，在觀看別人代碼的時(shí)候，清晰理解const所起的作用，對(duì)理解對(duì)方的程序也有一定幫助。另外CONST在其它編程語(yǔ)言中也有出現(xiàn)，例如Pascal、C++、PHP5、B#.net、HC08 C、C#等。

在c中，對(duì)于const定義的指針，不賦初值編譯不報(bào)錯(cuò)，int* const px;這種定義是不允許的。（指針常量定義的時(shí)候?qū)ζ溥M(jìn)行初始化）int const *px;這種定義是允許的。（常指針可以再定義的時(shí)候不初始化）
但是，在C++中int* const px;和const int* const px;會(huì)報(bào)錯(cuò)，const int* px;不報(bào)錯(cuò)。

C++在函數(shù)聲明時(shí)，后面跟個(gè)const是什么意思？

const是一個(gè)C語(yǔ)言（ANSI C）的關(guān)鍵字，具有著舉足輕重的地位。它限定一個(gè)變量不允許被改變，產(chǎn)生靜態(tài)作用。

使用const在一定程度上可以提高程序的安全性和可靠性。

另外，在觀看別人代碼的時(shí)候，清晰理解const所起的作用，對(duì)理解對(duì)方的程序也有一定幫助。另外CONST在其它編程語(yǔ)言中也有出現(xiàn)，例如Pascal、C++、PHP5、B#.net、HC08 C、C#等。
const的作用：
1、可以定義const常量，具有不可變性。
例如：const int Max=100; Max++會(huì)產(chǎn)生錯(cuò)誤;
2、便于進(jìn)行類型檢查，使編譯器對(duì)處理內(nèi)容有更多了解，消除了一些隱患。

例如： void f(const int i) { ………} 編譯器就會(huì)知道i是一個(gè)常量，不允許修改;
3、可以避免意義模糊的數(shù)字出現(xiàn)，同樣可以很方便地進(jìn)行參數(shù)的調(diào)整和修改。 同宏定義一樣，可以做到不變則已，一變都變！
如1中，如果想修改Max的內(nèi)容，只需要它修改成：const int Max=you want;即可！
4、可以保護(hù)被修飾的東西，防止意外的修改，增強(qiáng)程序的健壯性。 還是上面的例子，如果在函數(shù)體內(nèi)修改了i，編譯器就會(huì)報(bào)錯(cuò);
例如： void f(const int i) { i=10;//error! }
5、可以節(jié)省空間，避免不必要的內(nèi)存分配。

例如：
#define PI 3.14159 //常量宏
const double?Pi=3.14159; //此時(shí)并未將Pi放入ROM中 ……
6、提高了效率。
編譯器通常不為普通const常量分配存儲(chǔ)空間，而是將它們保存在符號(hào)表中，這使得它成為一個(gè)編譯期間的常量，沒有了存儲(chǔ)與讀內(nèi)存的操作，使得它的效率也很高。

擴(kuò)展資料：
const 的時(shí)候都會(huì)混淆它與 define 的區(qū)別。

從功能上說它們確實(shí)很像，但它們又有明顯的不同：
1、define是預(yù)編譯指令，而const是普通變量的定義。define定義的宏是在預(yù)處理階段展開的，而const定義的只讀變量是在編譯運(yùn)行階段使用的。
2、const定義的是變量，而define定義的是常量。

define定義的宏在編譯后就不存在了，它不占用內(nèi)存，因?yàn)樗皇亲兞?，系統(tǒng)只會(huì)給變量分配內(nèi)存。
但const定義的常變量本質(zhì)上仍然是一個(gè)變量，具有變量的基本屬性，有類型、占用存儲(chǔ)單元?？梢哉f，常變量是有名字的不變量，而常量是沒有名字的。
有名字就便于在程序中被引用，所以從使用的角度看，除了不能作為數(shù)組的長(zhǎng)度，用const定義的常變量具有宏的優(yōu)點(diǎn)，而且使用更方便。

所以編程時(shí)在使用const和define都可以的情況下盡量使用常變量來取代宏。
3、const定義的是變量，而宏定義的是常量，所以const定義的對(duì)象有數(shù)據(jù)類型，而宏定義的對(duì)象沒有數(shù)據(jù)類型。所以編譯器可以對(duì)前者進(jìn)行類型安全檢查，而對(duì)后者只是機(jī)械地進(jìn)行字符替換，沒有類型安全檢查。這樣就很容易出問題，即“邊際問題”或者說是“括號(hào)問題”。