啪啪拉拉噼里啪啦

問(wèn)題：const變量 & 常量

　　為什么我象下面的例子一樣用一個(gè)const變量來(lái)初始化數(shù)組，ANSI C的編譯器會(huì)報(bào)告一個(gè)錯(cuò)誤呢？

　　const int n = 5;

　　int a[n];

　　答案與分析:

　　1)、這個(gè)問(wèn)題討論的是“常量”與“只讀變量”的區(qū)別。常量肯定是只讀的，例如5， “abc”，等，肯定是只讀的，因?yàn)槌绦蛑懈緵](méi)有地方存放它的值，當(dāng)然也就不能夠去修改它。而“只讀變量”則是在內(nèi)存中開(kāi)辟一個(gè)地方來(lái)存放它的值，只不過(guò)這個(gè)值由編譯器限定不允許被修改。C語(yǔ)言關(guān)鍵字const就是用來(lái)限定一個(gè)變量不允許被改變的修飾符(Qualifier)。上述代碼中變量n被修飾為只讀變量，可惜再怎么修飾也不是常量。而ANSI C規(guī)定數(shù)組定義時(shí)維度必須是“常量”，“只讀變量”也是不可以的。

　　2)、注意：在ANSI C中，這種寫(xiě)法是錯(cuò)誤的，因?yàn)閿?shù)組的大小應(yīng)該是個(gè)常量，而const int n,n只是一個(gè)變量(常量 != 不可變的變量，但在標(biāo)準(zhǔn)C++中，這樣定義的是一個(gè)常量，這種寫(xiě)法是對(duì)的)，實(shí)際上，根據(jù)編譯過(guò)程及內(nèi)存分配來(lái)看，這種用法本來(lái)就應(yīng)該是合理的，只是ANSI C對(duì)數(shù)組的規(guī)定限制了它。

　　3)、那么，在ANSI C 語(yǔ)言中用什么來(lái)定義常量呢？答案是enum類型和#define宏，這兩個(gè)都可以用來(lái)定義常量。

　　問(wèn)題：const變量 & const 限定的內(nèi)容

　　下面的代碼編譯器會(huì)報(bào)一個(gè)錯(cuò)誤，請(qǐng)問(wèn)，哪一個(gè)語(yǔ)句是錯(cuò)誤的呢？

　　typedef char * pStr;

　　char string[4] = "abc";

　　const char *p1 = string;

　　const pStr p2 = string;

　　p1++;

　　p2++;

　　答案與分析：

　　問(wèn)題出在p2++上。

　　1)、const使用的基本形式： const char m;

　　限定m不可變。

　　2)、替換1式中的m, const char *pm;

　　限定*pm不可變，當(dāng)然pm是可變的，因此問(wèn)題中p1++是對(duì)的。

　　3)、替換1式char, const newType m;

　　限定m不可變，問(wèn)題中的charptr就是一種新類型，因此問(wèn)題中p2不可變，p2++是錯(cuò)誤的。

　　問(wèn)題：const變量 & 字符串常量

　　請(qǐng)問(wèn)下面的代碼有什么問(wèn)題？

　　char *p = "i'm hungry!";

　　p[0]= 'I';

　　答案與分析：

　　上面的代碼可能會(huì)造成內(nèi)存的非法寫(xiě)操作。分析如下， “i'm hungry”實(shí)質(zhì)上是字符串常量，而常量往往被編譯器放在只讀的內(nèi)存區(qū)，不可寫(xiě)。p初始指向這個(gè)只讀的內(nèi)存區(qū)，而p[0] = 'I'則企圖去寫(xiě)這個(gè)地方，編譯器當(dāng)然不會(huì)答應(yīng)。

　　問(wèn)題：const變量 & 字符串常量2

　　請(qǐng)問(wèn)char a[3] = "abc" 合法嗎？使用它有什么隱患？

　　答案與分析：

　　在標(biāo)準(zhǔn)C中這是合法的，但是它的生存環(huán)境非常狹小；它定義一個(gè)大小為3的數(shù)組，初始化為“abc”，，注意，它沒(méi)有通常的字符串終止符'\0'，因此這個(gè)數(shù)組只是看起來(lái)像C語(yǔ)言中的字符串，實(shí)質(zhì)上卻不是，因此所有對(duì)字符串進(jìn)行處理的函數(shù)，比如strcpy、printf等，都不能夠被使用在這個(gè)假字符串上。

　　問(wèn)題：const & 指針

　　類型聲明中const用來(lái)修飾一個(gè)常量，有如下兩種寫(xiě)法，那么，請(qǐng)問(wèn)，下面分別用const限定不可變的內(nèi)容是什么?

　　1)、const在前面

　　const int nValue； //nValue是const

　　const char *pContent; //*pContent是const, pContent可變

　　const (char *) pContent;//pContent是const,*pContent可變

　　char* const pContent; //pContent是const,*pContent可變

　　const char* const pContent; //pContent和*pContent都是const

　　2)、const在后面，與上面的聲明對(duì)等

　　int const nValue； // nValue是const

　　char const * pContent;// *pContent是const, pContent可變

　　(char *) const pContent;//pContent是const,*pContent可變

　　char* const pContent;// pContent是const,*pContent可變

　　char const* const pContent;// pContent和*pContent都是const

　　答案與分析：

　　const和指針一起使用是C語(yǔ)言中一個(gè)很常見(jiàn)的困惑之處，在實(shí)際開(kāi)發(fā)中，特別是在看別人代碼的時(shí)候，常常會(huì)因?yàn)檫@樣而不好判斷作者的意圖，下面講一下我的判斷原則：

　　沿著*號(hào)劃一條線，const和誰(shuí)在一邊，那么誰(shuí)就是const，即const限定的元素就是它。你可以根據(jù)這個(gè)規(guī)則來(lái)看上面聲明的實(shí)際意義，相信定會(huì)一目了然。

　　另外，需要注意：對(duì)于const (char *) ; 因?yàn)閏har *是一個(gè)整體，相當(dāng)于一個(gè)類型(如 char)，因此，這是限定指針是const。

  回復(fù)  更多評(píng)論
  

一、typedef的用法

____在C/C++語(yǔ)言中，typedef常用來(lái)定義一個(gè)標(biāo)識(shí)符及關(guān)鍵字的別名，它是語(yǔ)言編譯過(guò)程的一部分，但它并不實(shí)際分配內(nèi)存空間，實(shí)例像：

typedef int INT;
typedef int ARRAY[10];
typedef (int*) pINT;

____typedef可以增強(qiáng)程序的可讀性，以及標(biāo)識(shí)符的靈活性，但它也有“非直觀性”等缺點(diǎn)。

二、#define的用法

____#define為一宏定義語(yǔ)句，通常用它來(lái)定義常量(包括無(wú)參量與帶參量)，以及用來(lái)實(shí)現(xiàn)那些“表面似和善、背后一長(zhǎng)串”的宏，它本身并不在編譯過(guò)程中進(jìn)行，而是在這之前(預(yù)處理過(guò)程)就已經(jīng)完成了，但也因此難以發(fā)現(xiàn)潛在的錯(cuò)誤及其它代碼維護(hù)問(wèn)題，它的實(shí)例像：

#define INT int
#define TRUE 1
#define Add(a,b) ((a)+(b));
#define Loop_10 for (int i=0; i<10; i++)

____在Scott Meyer的Effective C++一書(shū)的條款1中有關(guān)于#define語(yǔ)句弊端的分析，以及好的替代方法，大家可參看。

三、typedef與#define的區(qū)別

____從以上的概念便也能基本清楚，typedef只是為了增加可讀性而為標(biāo)識(shí)符另起的新名稱(僅僅只是個(gè)別名)，而#define原本在C中是為了定義常量，到了C++，const、enum、inline的出現(xiàn)使它也漸漸成為了起別名的工具。有時(shí)很容易搞不清楚與typedef兩者到底該用哪個(gè)好，如#define INT int這樣的語(yǔ)句，用typedef一樣可以完成，用哪個(gè)好呢？我主張用typedef，因?yàn)樵谠缙诘脑S多C編譯器中這條語(yǔ)句是非法的，只是現(xiàn)今的編譯器又做了擴(kuò)充。為了盡可能地兼容，一般都遵循#define定義“可讀”的常量以及一些宏語(yǔ)句的任務(wù)，而typedef則常用來(lái)定義關(guān)鍵字、冗長(zhǎng)的類型的別名。

____宏定義只是簡(jiǎn)單的字符串代換(原地?cái)U(kuò)展)，而typedef則不是原地?cái)U(kuò)展，它的新名字具有一定的封裝性，以致于新命名的標(biāo)識(shí)符具有更易定義變量的功能。請(qǐng)看上面第一大點(diǎn)代碼的第三行：

typedef (int*) pINT;
以及下面這行:
#define pINT2 int*

____效果相同？實(shí)則不同！實(shí)踐中見(jiàn)差別：pINT a,b;的效果同int *a; int *b;表示定義了兩個(gè)整型指針變量。而pINT2 a,b;的效果同int *a, b;表示定義了一個(gè)整型指針變量a和整型變量b。

____注意：兩者還有一個(gè)行尾;號(hào)的區(qū)別哦！
  回復(fù)  更多評(píng)論
  

常量
常量是一種標(biāo)識(shí)符，它的值在運(yùn)行期間恒定不變。C語(yǔ)言用 #define來(lái)定義常量（稱為宏常量）。C++ 語(yǔ)言除了 #define外還可以用const來(lái)定義常量（稱為const常量）。
為什么需要常量
如果不使用常量，直接在程序中填寫(xiě)數(shù)字或字符串，將會(huì)有什么麻煩？
（1） 程序的可讀性（可理解性）變差。程序員自己會(huì)忘記那些數(shù)字或字符串是什么意思，用戶則更加不知它們從何處來(lái)、表示什么。
（2） 在程序的很多地方輸入同樣的數(shù)字或字符串，難保不發(fā)生書(shū)寫(xiě)錯(cuò)誤。
（3） 如果要修改數(shù)字或字符串，則會(huì)在很多地方改動(dòng)，既麻煩又容易出錯(cuò)。

【規(guī)則5-1-1】 盡量使用含義直觀的常量來(lái)表示那些將在程序中多次出現(xiàn)的數(shù)字或字符串。
例如：
#define MAX 100 /* C語(yǔ)言的宏常量 */
const int MAX = 100; // C++ 語(yǔ)言的const常量
const float PI = 3.14159; // C++ 語(yǔ)言的const常量
const 與 #define的比較
C++ 語(yǔ)言可以用const來(lái)定義常量，也可以用 #define來(lái)定義常量。但是前者比后者有更多的優(yōu)點(diǎn)：
（1） const常量有數(shù)據(jù)類型，而宏常量沒(méi)有數(shù)據(jù)類型。編譯器可以對(duì)前者進(jìn)行類型安全檢查。而對(duì)后者只進(jìn)行字符替換，沒(méi)有類型安全檢查，并且在字符替換可能會(huì)產(chǎn)生意料不到的錯(cuò)誤（邊際效應(yīng)）。
（2） 有些集成化的調(diào)試工具可以對(duì)const常量進(jìn)行調(diào)試，但是不能對(duì)宏常量進(jìn)行調(diào)試。

【規(guī)則5-2-1】在C++ 程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。



  回復(fù)  更多評(píng)論
  

常量定義規(guī)則
【規(guī)則5-3-1】需要對(duì)外公開(kāi)的常量放在頭文件中，不需要對(duì)外公開(kāi)的常量放在定義文件的頭部。為便于管理，可以把不同模塊的常量集中存放在一個(gè)公共的頭文件中。
【規(guī)則5-3-2】如果某一常量與其它常量密切相關(guān)，應(yīng)在定義中包含這種關(guān)系，而不應(yīng)給出一些孤立的值。
例如：
const float RADIUS = 100;
const float DIAMETER = RADIUS * 2;
類中的常量
有時(shí)我們希望某些常量只在類中有效。由于#define定義的宏常量是全局的，不能達(dá)到目的，于是想當(dāng)然地覺(jué)得應(yīng)該用const修飾數(shù)據(jù)成員來(lái)實(shí)現(xiàn)。const數(shù)據(jù)成員的確是存在的，但其含義卻不是我們所期望的。const數(shù)據(jù)成員只在某個(gè)對(duì)象生存期內(nèi)是常量，而對(duì)于整個(gè)類而言卻是可變的，因?yàn)轭惪梢詣?chuàng)建多個(gè)對(duì)象，不同的對(duì)象其const數(shù)據(jù)成員的值可以不同。
不能在類聲明中初始化const數(shù)據(jù)成員。以下用法是錯(cuò)誤的，因?yàn)轭惖膶?duì)象未被創(chuàng)建時(shí)，編譯器不知道SIZE的值是什么。
class A
{…
const int SIZE = 100; // 錯(cuò)誤，企圖在類聲明中初始化const數(shù)據(jù)成員
int array[SIZE]; // 錯(cuò)誤，未知的SIZE
};

const數(shù)據(jù)成員的初始化只能在類構(gòu)造函數(shù)的初始化表中進(jìn)行，例如
class A
{…
A(int size); // 構(gòu)造函數(shù)
const int SIZE ;
};
A::A(int size) : SIZE(size) // 構(gòu)造函數(shù)的初始化表
{
…
}
A a(100); // 對(duì)象 a 的SIZE值為100
A b(200); // 對(duì)象 b 的SIZE值為200

怎樣才能建立在整個(gè)類中都恒定的常量呢？別指望const數(shù)據(jù)成員了，應(yīng)該用類中的枚舉常量來(lái)實(shí)現(xiàn)。例如
class A
{…
enum { SIZE1 = 100, SIZE2 = 200}; // 枚舉常量
int array1[SIZE1];
int array2[SIZE2];
};
枚舉常量不會(huì)占用對(duì)象的存儲(chǔ)空間，它們?cè)诰幾g時(shí)被全部求值。枚舉常量的缺點(diǎn)是：它的隱含數(shù)據(jù)類型是整數(shù)，其最大值有限，且不能表示浮點(diǎn)數(shù)（如PI=3.14159）。

  回復(fù)  更多評(píng)論
  

const主要是為了程序的健壯型,減少程序出錯(cuò).
最基本的用法:
const int a=100; b的內(nèi)容不變,b只能是100也就是聲明一個(gè)int類型的常量(#define b =100)
int const b=100; //和上面作用一樣

const指針和引用一般用在函數(shù)的參數(shù)中
int* m = &a; //出錯(cuò),常量只能用常指針
int c= 1;const int*pc = &c;//常指針可指向常量

const int* pa = &a; //指針指向的內(nèi)容為常量(就是b的值不變)
int const *a = &b; //指針指向的內(nèi)容為常量(就是b的值不變)*p=3//error
int* const a = &b; //指針為常量,不能更改指針了如 a++但可以改值*p=3;

從這可以看出const放在*左側(cè)修飾的是指針的內(nèi)容,const放在*右側(cè)修飾的是指針
本身.

const引用的用法和指針一樣
int const & a=b; 和指針一樣
const int& a=b; 和指針一樣
但沒(méi)有 int& const a=b 的用法因?yàn)橐貌荒茏鲆莆贿\(yùn)算，但只是出個(gè)warning

const int* const a = &b; //綜合應(yīng)用,一般用來(lái)傳遞多維的數(shù)組
類如：char* init[] = {"Paris","in the","Spring"};
void fun(const int* const a){}
fun(init)//保護(hù)參數(shù)不被修改

int A(int)const; //是常函數(shù)，只能用在類中，調(diào)用它的對(duì)象不能改改變成員值
const int A(); //返回的是常量,所以必須這么調(diào)用 cosnt int a=A();
int A(const int); //參數(shù)不能改值,可用在任意函數(shù)
int A(const int*);
....
int height() const;//常函數(shù)只能由常函數(shù)調(diào)用
int max(int,int) const;
int Max = max(height(),height());

const int* pHeap = new int;
delete pHeap;
p = NULL;//出錯(cuò)
我的解決辦法是強(qiáng)制類型轉(zhuǎn)換
const int* pHeap = new int(1);
delete (int*)pHeap;
pHeap = NULL;

一、const 和引用聯(lián)合使用的時(shí)候要注意

const int a = 1;
const int& ref1 = a;
const int& ref2 = 1;

ref1 和 ref2 都是正確的，但是他們引用的內(nèi)容和一般的引用不同
對(duì) const int& ref1 = a; 而言，其實(shí)這個(gè) ref1 已經(jīng)和 a 沒(méi)有任何關(guān)系了
ref1 實(shí)際上是對(duì)一個(gè)臨時(shí)量的引用。同理 const int& ref2 = 1; 也是對(duì)
一個(gè)臨時(shí)量做的引用。當(dāng)引用臨時(shí)量是 C++ 的隱式類型轉(zhuǎn)換可以起作用。
臨時(shí)量的生存期和引用量的生存期相同。

二、強(qiáng)傳const對(duì)象可能導(dǎo)致無(wú)定義行為

對(duì)于優(yōu)化做的比較好的編譯器，代碼 const int i = 1;
當(dāng)后面用到變量 i 的時(shí)候，編譯器會(huì)優(yōu)化掉對(duì) i 的存取，而直接使用立即數(shù) 1

const int i = 1;

*(const_cast<int*>(&i)) = 2;
cout << *(int*)&i << endl;
cout << i << endl;

所以，對(duì) const 對(duì)象做 const_cast 可能導(dǎo)致無(wú)定義行為
目前我就遇到這些問(wèn)題，那位還有補(bǔ)充的嗎





能不能把自己的經(jīng)驗(yàn)也談?wù)劇４蠹医涣鹘涣?
這個(gè)就是我在調(diào)錯(cuò)時(shí)發(fā)現(xiàn)的
int height() const;//常函數(shù)只能由常函數(shù)調(diào)用
int max(int,int) const;
int Max = max(height(),height());





Thinking again in C++（一）常量性原理 cphj（原作）
有些地方很受啟發(fā)


1.不能將const修飾的任何對(duì)象、引用和指針作為賦值表達(dá)式的左值。
const int cx=100;
const int & rcx=cx;
const int * pcx=&cx;
cx=200; //error
rcx=200; //error
*pcx=200; //error

2.const類型的對(duì)象不能直接被non-const類型的別名所引用。
(1)不能將const類型的對(duì)象傳遞給non-const類型的引用。
const int cx=100;
int & rx=cx; //error
(2)不能將const類型的實(shí)參傳遞給形參為non-const類型引用的函數(shù)。
void f(int a)
{
}
void g(int & ra)
{
}
const int cx=100;
f(cx); //ok
g(cx); //error
(3)不能將const類型的對(duì)象作為non-const類型引用的函數(shù)返回值。
int & f(const int & rca)
{
return rca; //error
}
int x=100;
f(x);

3.可以使用const類型別名引用non-const對(duì)象。此時(shí)通過(guò)const引用不能修改對(duì)象，但對(duì)象可以通過(guò)non-const引用被修改。
int x=100;
int & rx=x;
const int & rcx=x; //ok
x=200;
rx=200;
rcx=200; //error

4.指針的屬性有兩個(gè)：指針的類型和指針本身的常量性。其中，指向const對(duì)象與指向non-const對(duì)象，是不同的指針類型。
int x=100;
const int * pcx=&x; //[1]
int * px=&x; //[2]
int y=100;
int * const cpy=&y; //[3]
int * py=&y; //[4]
[1][2]兩個(gè)指針的類型不同；[3][4]兩個(gè)指針的常量性不同。
對(duì)象與指向?qū)ο蟮闹羔樀囊?guī)則類似于對(duì)象與引用。即，const類型的對(duì)象不能直接被non-const類型的指針?biāo)甘荆ㄍ?）；可以使用const類型的指針指向non-const對(duì)象（同3）。

5.可以將相同類型（包括常量性）的const指針值賦給non-const指針。
int x=100;
int * px;
const int * pcx=&x;
px=pcx; //error
int * const cpx=&x;
px=cpx; //ok

6.若函數(shù)的返回值為內(nèi)建類型或是指針，則該返回值自動(dòng)成為const性質(zhì)。但自定義類型則為non-const性質(zhì)。
int f() //相當(dāng)于返回const int
{
return 100;
}
int * g(int & ra) //相當(dāng)于返回int * const
{
return &ra;
}
class CTest
{
int n;
public:
CTest(int n){this->n=n;}
};
CTest h() //返回的就是CTest
{
return CTest(200);
}

f()=200; //error

int x=100;
int y=200;
int * px=&x;
g(y)=px; //error
*g(y)=x; //ok，從這點(diǎn)可以看出g()返回的不是const int *

CTest t(100);
h()=t; //ok，但卻是完全錯(cuò)誤的、危險(xiǎn)的做法
//所以h()的正確寫(xiě)法是返回const CTest





const int b=100; b的內(nèi)容不變,b只能是100
int const b=100; b必須為int型,不能為其他類型?
這2句話的意思應(yīng)該是一樣的吧 ， THINKING IN C++是這樣說(shuō)的





const int a=100; a的內(nèi)容不變,a只能是100（同樣不能類型轉(zhuǎn)換）。
int const b=100; b必須為int型,不能為其他類型?（同樣在使用中不能修改）。
所以a和b是一樣的，稱為整型常數(shù)，在使用中不能被修改，當(dāng)然都不能轉(zhuǎn)為其他類型了。
#include <iostream>

using namespace std;

int main()
{
　　const int a = 100;
　　int const b = 100;

　 a = 100; //這四條語(yǔ)句編譯時(shí)都會(huì)出現(xiàn)“Cannot modify a const object
b = 100; //in function main()”的錯(cuò)誤提示，也就是說(shuō)，任何企圖修改　　 a = 100.0;　//a和b（其實(shí)是一樣的）的行為都會(huì)出現(xiàn)“災(zāi)難”，在語(yǔ)法上講就　　b = 100.0; //是a和b都不能出現(xiàn)在賦值語(yǔ)句的左邊！

　　cout<<'\n'<<a<<'\n'<<b<<endl;

　　return 0;
}





常函數(shù)的調(diào)用是這樣的：常量對(duì)象只能調(diào)用常成員函數(shù)，非常量對(duì)象即可以調(diào)常成員函數(shù)，也可以調(diào)一般成員函數(shù)，但當(dāng)某個(gè)函數(shù)有const和非const兩個(gè)版本時(shí)，const對(duì)象調(diào)const版本，非const對(duì)象調(diào)非const版本
例：
class A
{
public:
int & GetData(){return data;}
const int & GetData()const {return data;}
private:
int data;
}
A a;
a.GetData();//調(diào)用int & GetData(){return data;}
//但如果沒(méi)有這個(gè)函數(shù)，也可以調(diào)用const int & GetData()const
const A const_a;
const_a.GetData();//調(diào)用const int & GetData()const {return data;}
常函數(shù)只能調(diào)常函數(shù)，也是由于這個(gè)原因





算你狠！加兩點(diǎn)

一、const 和引用聯(lián)合使用的時(shí)候要注意

const int a = 1;
const int& ref1 = a;
const int& ref2 = 1;

ref1 和 ref2 都是正確的，但是他們引用的內(nèi)容和一般的引用不同
對(duì) const int& ref1 = a; 而言，其實(shí)這個(gè) ref1 已經(jīng)和 a 沒(méi)有任何關(guān)系了
ref1 實(shí)際上是對(duì)一個(gè)臨時(shí)量的引用。同理 const int& ref2 = 1; 也是對(duì)
一個(gè)臨時(shí)量做的引用。當(dāng)引用臨時(shí)量是 C++ 的隱式類型轉(zhuǎn)換可以起作用。
臨時(shí)量的生存期和引用量的生存期相同。

二、強(qiáng)傳const對(duì)象可能導(dǎo)致無(wú)定義行為

對(duì)于優(yōu)化做的比較好的編譯器，代碼 const int i = 1;
當(dāng)后面用到變量 i 的時(shí)候，編譯器會(huì)優(yōu)化掉對(duì) i 的存取，而直接使用立即數(shù) 1

const int i = 1;

*(const_cast<int*>(&i)) = 2;
cout << *(int*)&i << endl;
cout << i << endl;

所以，對(duì) const 對(duì)象做 const_cast 可能導(dǎo)致無(wú)定義行為





#include <iostream.h>
void fun(char b){cout <<"void"<<endl;}
int fun(int const b){cout <<"int"<<endl;}
int main()
{
fun(1.0);//詳細(xì)看看重載函數(shù)吧
fun(4); //想一想調(diào)用哪一個(gè)

return 0;
}
我試了一下，會(huì)出錯(cuò)? vc說(shuō)：'fun':ambiguous call to overloaded function





補(bǔ)充的好啊，這個(gè)一般不會(huì)注意的
const int i = 1;
*(const_cast<int*>(&i)) = 2;
cout << *(int*)&i << endl;
cout << i << endl;
這個(gè)可真有意思，調(diào)試時(shí)兩個(gè)都是2，可編譯就是2，1了
const的永遠(yuǎn)都是const,這樣能更改就不錯(cuò)了，不然就自相矛盾了
奇怪的是 pi 和 &i地址一樣啊，就像樓上說(shuō)的這是編譯時(shí)的優(yōu)化
處理
const int i = 1;
int* pi=const_cast<int*>(&i);
*pi=2;
cout << *pi << endl;
cout << i << endl;





那個(gè)主要是隱式轉(zhuǎn)換
你可依次把兩個(gè)函數(shù)注掉看看調(diào)用
#include <iostream.h>
//void fun(char b){cout <<"void"<<endl;}
void fun(int b){cout <<"int"<<endl;}
int main()
{
fun('a');
fun(4);
return 0;
}


  回復(fù)  更多評(píng)論