1.inline const rational operator*(const rational& lhs,const rational& rhs){return rational(lhs.n * rhs.n, lhs.d * rhs.d);}這是一個實現有理數乘積的函數，問“inline const”中的const有什么用？為什么這里要用const呢？2.int comptot()const{return (bsal+yourbonus+allbonus);} 這個const是放在()之后的，這和上面1的放在()之前的有區(qū)別么？3.virtual void logTransaction() const=0;這個記得是定義純虛函數的，不過不理解const=0是什么意思？這個是不是表示函數的返回值是0??？如果是的話，純虛函數不是什么都不做的，返回值是0也沒意義啊。4.virtual void logTransaction() const;這個const在這里有什么用呢？能去掉么？一樓提供的資料很有用，不過好像找不到對問題1、3解答，希望能完善，如果有高手能針對性的回答一下就最好，視答案還可以加分先肯定一樓回答的價值，不過還未能完全說服我，謝謝！
2 回答
絕地無雙
TA貢獻1946條經驗 獲得超4個贊
(1)const用于定義常量。
例如：const int N = 100;const int M = 200;
這樣程序中只要用到 N、M 就分別代表為整型100、200，N、M 為一常量，在程序中不可改變。
但有人說他編程時從來不用const定義常量。我相信。但他是不懂得真正的編程藝術，用const定義常量不僅能方便我們編程而且能提高程序的清晰性。你是愿意看到程序中100、200 滿天飛，還是愿意只看到簡單清晰的N、M。相信有沒有好處你慢慢體會。
還有人說他不用const定義常量，他用#define宏定義常量?？梢浴５恢滥阌袥]有發(fā)現有時#define宏并沒有如你所愿在定義常量。下面我們比較比較const和#define。
1。const定義常量是有數據類型的，而#define宏定義常量卻沒有。
這樣const定義的常量編譯器可以對其進行數據靜態(tài)類型安全檢查，而#define宏定義的常量卻只是進行簡單的字符替換，沒有類型安全檢查，且有時還會產生邊際效應(不如你愿處)。所謂邊際效應舉例如下：
#define N 100
#define M 200 + N
當程序中使用 M*N 時，原本想要 100 * （200+ N ）的卻變成了 100 * 200 + N。
2。有些調試程序可對const進行調試，但不對#define進行調試。
3。當定義局部變量時，const作用域僅限于定義局部變量的函數體內。但用#define時其作用域不僅限于定義局部變量的函數體內，而是從定義點到整個程序的結束點。但也可以用#undef取消其定義從而限定其作用域范圍。
光用const定義常量，并不能起到其強大的作用。const還可修飾函數形式參數、返回值和類的成員函數等。從而提高函數的健壯性。因為const修飾的東西能受到c/c++的靜態(tài)類型安全檢查機制的強制保護，防止意外的修改。
(2)const修飾函數形式參數
形式參數有輸入形式參數和輸出形式參數。參數用于輸出時不能加const修飾，那樣會使函數失去輸出功能。因為const修飾的東西是不能改變的。
const只能用于修飾輸入參數。
談const只能用于修飾輸入參數之前先談談C++函數的三種傳遞方式。
C++函數的三種傳遞方式為：值傳遞、指針傳遞和引用傳遞。簡單舉例說明之，詳細說明請參考別的資料。
值傳遞：
void fun(int x){
x += 5; //修改的只是y在棧中copy x
}
void main(void){
int y = 0;
fun(y);
cout<<"y = "< }
指針傳遞：
void fun(int *x){
*x += 5;//修改的是指針x指向的內存單元值
}
void main(void){
int y = 0;
fun(&y);
cout<<<<"y = "<}
引用傳遞：
void fun(int &x){
x += 5;//修改的是x引用的對象值 &x = y;
}
void main(void){
int y = 0;
fun(y);
cout<<<<"y = "<}
看了傳遞方式后我們繼續(xù)來談"const只能用于修飾輸入參數"的情況。
當輸入參數用"值傳遞"方式時，我們不需要加const修飾，因為用值傳遞時，函數將自動用實際參數的拷貝初始化形式參數，當在函數體內改變形式參數時，改變的也只是棧上的拷貝而不是實際參數。
但要注意的是，當輸入參數為ADT/UDT（用戶自定義類型和抽象數據類型）時，應該將"值傳遞"改為"const &傳遞"，目的可以提高效率。
例如：
void fun(A a);//效率底。函數體內產生A類型的臨時對象用于復制參數 a，但是臨時對象的
//構造、復制、析構過程都將消耗時間。
void fun(A const &a);//提高效率。用"引用傳遞"不需要產生臨時對象，省了臨時對象的
//構造、復制、析構過程消耗的時間。但光用引用有可能改變a,所以加const
當輸入參數用"指針傳遞"方式時，加const修飾可防止意外修改指針指向的內存單元，起到保護作用。
例如：
void funstrcopy(char *strdest,const char *strsrc)//任何改變strsrc指向的內存單元，
//編譯器都將報錯
些時保護了指針的內存單元，也可以保護指針本身，防止其地址改變。
例如：
void funstrcopy(char *strdest,const char *const strsrc)
(3)const修飾函數的返回值
如給"指針傳遞"的函數返回值加const，則返回值不能被直接修改，且該返回值只能被賦值給加const修飾的同類型指針。
例如：
const char *GetChar(void){};
賦值 char *ch = GetChar();//錯誤const char *ch = GetChar();//正確
(4)const修飾類的成員函數(函數定義體)
任何不會修改數據成員的函數都應用const修飾，這樣當不小心修改了數據成員或調用了非const成員函數時，編譯器都會報錯。
const修飾類的成員函數形式為：int GetCount(void)const;
問題1 屬于 const修飾函數的返回值
2 屬于 const修飾類的成員函數(函數定義體)
3.4 純虛函數和虛函數就是這樣定義
翻閱古今
TA貢獻1780條經驗 獲得超5個贊
這是針對性地回答：
1.inline const rational operator*(const
inline const不是一個關鍵字。
應該是這樣的：
inline是內聯函數的關鍵字。就是說這個函數可以在調用時像宏一樣擴展代碼，節(jié)省調用時間。
const rational是一起的，表示返回值類型是rational型的const常量。
我不建議這里是const，返回常量會造成后序操作的很多麻煩。
2.int comptot()const
const放在函數聲明或者定義的（）后是定義常量函數，表明這個函數不改變實參或者調用對象的值。
3.virtual void logTransaction() const=0;
是定義純虛函數的，不過又是個斷句錯誤。
virtual void logTransaction() const是一起的，const作用和2一樣，表明函數是個常量函數。
=0表示純虛函數，是針對整個函數聲明的，而不是const。
4.virtual void logTransaction() const;
這個const和2一樣，就是為了聲明常量函數。
常類型是指使用類型修飾符const說明的類型，常類型的變量或對象的值是不能被更新的。因此，定義或說明常類型時必須進行初始化。
一般常量和對象常量
1. 一般常量
一般常量是指簡單類型的常量。這種常量在定義時，修飾符const可以用在類型說明符前，也可以用在類型說明符后。如：
int const x=2;
或
const int x=2;
定義或說明一個常數組可采用如下格式：
<類型說明符> const <數組名>[<大小>]…
或者
const <類型說明符> <數組名>[<大小>]…
例如：
int const a[5]={1, 2, 3, 4, 5};
2. 常對象
常對象是指對象常量，定義格式如下：
<類名> const <對象名>
或者
const <類名> <對象名>
定義常對象時，同樣要進行初始化，并且該對象不能再被更新，修飾符const可以放在類名后面，也可以放在類名前面。
常指針和常引用
1. 常指針
使用const修飾指針時，由于const的位置不同，而含意不同。下面舉兩個例子，說明它們的區(qū)別。
下面定義的一個指向字符串的常量指針：
char * const prt1 = stringprt1;
其中，ptr1是一個常量指針。因此，下面賦值是非法的。
ptr1 = stringprt2;
而下面的賦值是合法的：
*ptr1 = "m";
因為指針ptr1所指向的變量是可以更新的，不可更新的是常量指針ptr1所指的方向(別的字符串)。
下面定義了一個指向字符串常量的指針：
const * ptr2 = stringprt1;
其中，ptr2是一個指向字符串常量的指針。ptr2所指向的字符串不能更新的，而ptr2是可以更新的。因此，
*ptr2 = "x";
是非法的，而：
ptr2 = stringptr2;
是合法的。
所以，在使用const修飾指針時，應該注意const的位置。定義一個指向字符串的指針常量和定義一個指向字符串常量的指針時，const修飾符的位置不同，前者const放在*和指針名之間，后者const放在類型說明符前。
2. 常引用
使用const修飾符也可以說明引用，被說明的引用為常引用，該引用所引用的對象不能被更新。其定義格式如下：
const <類型說明符> & <引用名>
例如：
const double & v;
在實際應用中，常指針和常引用往往用來作函數的形參，這樣的參數稱為常參數。
在C++面向對象的程序設計中，指針和引用使用得較多，其中使用const修飾的常指針和常引用用得更多。使用常參數則表明該函數不會更新某個參數所指向或所引用的對象，這樣，在參數傳遞過程中就不需要執(zhí)行拷貝初始化構造函數，這將會改善程序的運行效率。
下面舉一例子說明常指針作函數參數的作法。
#include
const int N = 6;
void print(const int *p, int n);
void main()
{
int array[N];
for (int i=0; i cin>>array[i];
print(array, N);
}
void print(const int *p, int n)
{
cout<<"{"<<*p;
for (int i=1; i cout<<","<<*(p+i);
cout<<"}"< }
常成員函數
使用const關鍵字進行說明的成員函數，稱為常成員函數。只有常成員函數才有資格操作常量或常對象，沒有使用const關鍵字說明的成員函數不能用來操作常對象。常成員函數說明格式如下：
<類型說明符> <函數名> (<參數表>) const；
其中，const是加在函數說明后面的類型修飾符，它是函數類型的一個組成部分，因此，在函數實現部分也要帶const關鍵字。下面舉一例子說明常成員函數的特征。
#include
class R
{
public:
R(int r1, int r2) { R1=r1; R2=r2; }
void print();
void print() const;
private:
int R1, R2;
};
void R::print()
{
cout< }
void R::print() const
{
cout< }
void main()
{
R a(5, 4);
a.print();
const R b(20, 52);
b.print();
}
該例子的輸出結果為：
5,4
20;52
該程序的類聲明了兩個成員函數，其類型是不同的(其實就是重載成員函數)。有帶const修飾符的成員函數處理const常量，這也體現出函數重載的特點。
常數據成員
類型修飾符const不僅可以說明成員函數，也可以說明數據成員。
由于const類型對象必須被初始化，并且不能更新，因此，在類中說明了const數據成員時，只能通過成員初始化列表的方式來生成構造函數對數據成員初始化。
下面通過一個例子講述使用成員初始化列表來生成構造函數。
#include
class A
{
public:
A(int i);
void print();
const int &r;
private:
const int a;
static const int b;
};
const int A::b=10;
A::A(int i):a(i), r(a)
{
}
void A::print()
{
cout< }
void main()
{
A a1(100), a2(0);
a1.print();
a2.print();
}
該程序的運行結果為：
100:10:100
0:10:0
在該程序中，說明了如下三個常類型數據成員：
const int & r;
const int a;
static const int b;
其中，r是常int型引用，a是常int型變量，b是靜態(tài)常int型變量。
程序中對靜態(tài)數據成員b進行初始化。
值得注意的是構造函數的格式如下所示：
A(int i):a(i),r(a)
{
}
其中，冒號后邊是一個數據成員初始化列表，它包含兩個初始化項，用逗號進行了分隔，因為數據成員a和r都是常類型的，需要采用初始化格式。
添加回答
舉報
0/150
提交
取消