歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux編程 >> Linux編程

C/C++語言中關於const用法的總結

一. const的基本功能與用法

1.將限定符聲明為只讀

使用方法如下,在類型前/後加上關鍵字const,該變量必須被初始化,否則編譯錯誤;該變量不能被重新賦值,否則也編譯錯誤。
舉例:

const int i = 50;  // 編譯正確
const int j;        // 編譯錯誤
int k = 0;
i = k;              // 編譯錯誤
k = i;              // 編譯正確1
2.用於修飾函數形參,保護參數使其不被修改

用法1:若形參為const A* a,則不能改變函數所傳遞的指針內容,這樣對指針所指向的內容起到保護作用,這裡需要注意的是,該修飾不能改變指針所指向地址所存儲的內容,但是指針a所指向的地址可以被改變,具體例子如下:

void Test(const int *a)
{
    *a = 1;          //錯誤,*a不能被賦值
    a = new int(10086);  //正確,為指針a開辟新的空間,並令*a=2
}

int main()
{
    int *a = new int(10000);
    Test(a);
    return 0;
}1
用法2:若形參為const A& a,則不能改變函數傳遞進來的引用對象,從而保護了原對象的屬性。

對於自定義的數據類型,用引用傳遞速度較快,如果不想改變原值,就可以用const來保護參數,如以下例子:

void Test(const int &a) //保護L7中的a不會被改變
{
    a = 2;//錯誤,a不能給常量賦值
}

int main()
{
    int a = 3;
    Test(a);
    return 0;
}事實上對於內置型數據類型(如以上例子中的int類型),用引用傳遞不會使速度更快。如果是用引用傳參,一般是為了改變參數值;如果不想改變參數的值,直接值傳遞即可,不必使用const修飾。而對於自定義數據類型的輸入參數,為了提高速度和效率,應使用“const + 引用傳遞”代替值傳遞。例如:

將函數 void Test(A a) 改為-> void Test(const A &a)

3.用於修飾函數返回值

用法1:用const修飾返回值為對象本身(非引用和指針)的情況多用於二目操作符重載函數並產生新對象的時候
舉例:

const Rational operator*(const Rational& lhs, const Rational& rhs)
{
    return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
Rational a,b;
Radional c;
(a*b) = c;//錯誤1
用法2:不建議用const修飾函數的返回值類型為某個對象或對某個對象引用的情況。原因如下:如果返回值為某個對象為const(const A test = A 實例)或某個對象的引用為const(const A& test = A實例) ,則返回值具有const屬性,則返回實例只能訪問類A中的公有(保護)數據成員和const成員函數,並且不允許對其進行賦值操作,這在一般情況下很少用到,具體例子如下:

class A
{
public:
    int y;
    A(int y):x(x),y(y){};
    void Sety(int y){this->y = y;}
};

const A Test1(A a)
{
    return a;
}

const A& Test2(A &a)
{
    return a;
}

int main()
{
    A a(2);
    Test1(a).Sety(3);//錯誤,因為Test1(a)的返回值是個const,不能被Sety(3)修改
    Test2(a).Sety(3);//錯誤,因為Test1(a)的返回值是個const,不能被Sety(3)修改
    return 0;
}用法3:如果給采用“指針傳遞”方式的函數返回值加const修飾,那麼函數返回值(即指針)的內容不能被修改,該返回值只能被賦給加const 修飾的同類型指針。例子如下:

const char * GetString(void){}
int main()
{
    char *str1=GetString();//錯誤
    const char *str2=GetString();//正確
    return 0;
}用法4:函數返回值采用“引用傳遞”的場合不多,這種方式一般只出現在類的賦值函數中,目的是為了實現鏈式表達。例子如下:

class A
{
    // 以下賦值函數的返回值加const修飾,該返回值的內容不允許修改
    A &operate = (const A &other);
}
A a, b, c;  // a,b,c為A的對象
a = b = c;      // 正確
(a = b) = c;    // 錯誤,a = b的返回值不允許被再賦值1
4.在類成員函數的函數體後加關鍵字const

在類成員函數的函數體後加關鍵字const,形如:void fun() const; 在函數過程中不會修改數據成員。如果在編寫const成員函數時,不慎修改了數據成員,或者調用了其他非const成員函數,編譯器將報錯,這大大提高了程序的健壯性。

如果不是在類的成員函數,沒有任何效果,void fun() const;和void func();是一樣的。

5.在另一連接文件文件中引用常量

方法:在類型前添加關鍵字extern const,表示引用的是常量,因此該常量不允許被再次賦值,舉例如下:

extern const int i;      // 正確
extern const int j = 10;  // 錯誤,常量不可以被再次賦值二.const常量與#define的區別

1.const常量有數據類型,而宏常量沒有數據類型

宏常量只進行簡單的字符替換,沒有類型安全檢查,並且在字符替換時可能會產生意料不到的錯誤,如:

#define I = 10
const long &i = 10;
// 由於編譯器的優化,使得在const long i=10時i不被分配內存
// 而是已10直接代入以後的引用中,以致在以後的代碼中沒有錯誤
//一旦你關閉所有優化措施,即使const long i = 10也會引起後面的編譯錯誤。
char h = I; // 正確
char h = i; // 編譯警告,可能由於數的截短帶來錯誤賦值2.使用const可以避免不必要的內存分配

從匯編的角度來看,const定義常量只是給出了對應的內存地址, 而不是象#define一樣給出的是立即數,所以,const定義的常量在程序運行過程中只有一份拷貝,而#define定義的常量在內存中有若干個拷貝。例子如下:

#define k "Hello world!"
const char pk[]="Hello world!";
printf(k);      // 為k分配了第一次內存
printf(pk);    // 為pk一次分配了內存,以後不再分配
printf(k);      // 為k分配了第二次內存
printf(pk);三. 使用const的一些注意事項

1.修改const 所修飾的常量值

以下例子中,i為const修飾的變量,可以通過對i進行類型強制轉換,將地址賦給一個新的變量,對該新的變量再作修改即可以改變原來const 修飾的常值。

const int i=0;
int *p=(int*)&i;
p=100;2.構造函數不能被聲明為const

3.const數據成員的初始化只能在類的構造函數的初始化表中進行

class A
{
public:
    const int a;
    A(int x):a(x)//正確
    {
        a = x;//錯誤
    }
};1
4.在參數中使用const應該使用引用或指針,而不是一般的對象實例

合理利用const在成員函數中的三種用法(參數、返回值、函數),一般來說,不要輕易的將函數的返回值類型定為const;另外,除了重載操作符外一般不要將返回值類型定為對某個對象的const引用。

5.對於使用const修飾來指針的情況

對於以下情況,const放在變量聲明符的前後位置效果是一樣的,這種情況下不允許對指針a 的內容進行更改操作:

int i;
const int *a = &i;
int const*a = &i;1
但是,如果const位於星號的左側,則const就是用來修飾指針所指向的變量,即該指針指向一個地址,該地址的內容不可變;如果const位於星號的右側,const就是修飾指針本身,即指針本身是常量:

int i;
// 以下一行表示a是一個指針,可以任意指向int常量或者int變量
// 它總是把它所指向的目標當作一個int常量
// 也可以寫成int const* a
const int *a = &i;
// 以下一行表示a是一個指針常量,
// 初始化的時候必須固定指向一個int變量
// 之後就不能再指向別的地方了
// 但是指針指向的內容可以改變
int *const a = &i;6.指針本身是常量,而指針所指向的內容不是常量,這種情況下不能對指針本身進行更改操作,如以下例子中a++是錯誤的:

int *const a = &i;
a++;  // 錯誤,a指針本身是常量,不能再指向別的地方7.當指針本身和指針所指向的內容均為常量時

這種情況下可寫為:

const int * const a = &i;8.const成員函數返回的引用,也是const

#include<iostream>
using namespace std;
class A
{
public:
    int x;
    void set(int x){this->x = x;}
    // const成員函數返回的引用也是const,a
    // 如果把A&前面的const去掉會出錯
    // 因為返回的是一個const的對象,返回類型卻不是const
    // 返回的內容和返回的類型不符
    const A& Test1()const
    {
    // 錯誤。這是const成員函數的特點
    x = 2;
    // 不限於*this。不管返回的是什麼,哪怕是一個定義為非const的對象,結果也是一樣的
    return *this;
    }
};

int main()
{
    A a, b;
    // 正確,雖然返回的是一個const,卻用另一個非const來接收
    b = a.Test1();
    // 錯誤,既然是別名,那麼別名的類型要與原來的類型相同
    A &c = a.Test1();
    // 正確雖然在a.Test1()中a不能改變,但是這裡已經出了這個成員函數的作用域
    a.set(2);
    // 正確,b接收了a.Test1()返回的數據的內容,但是它不是const
    b.set(2);
    // 錯誤。a.Test1()是一個對象,這個對象是它的返回值
    // 雖然沒有名字,但是它就是a.Test1()的返回值
    // 值是a.Test1()返回的值,類型是a.Test1()返回的類型
    a.Test1().set(2);
    return 0;
}9.mutable將數據聲明為可變數據成員

在C++語言中,mutable是使用較少的關鍵字,它的作用是:如果一個函數被const 修飾,那麼它將無法修改其成員變量的,但是如果一個成員變量是被mutable修飾的話,則可以修改。

mutable 可以用來指出,即��成員函數或者類變量為const,其某個成員也可以被修改。反過來說,可變數據成員永遠不能成為const,即使它是const對象的成員。

class A
{
public:
    int x;
    mutable int y;
    A(int a, int b):x(a),y(b){}
};

int main()
{
    const A a(0, 0); // const對象必須初始化
    a.x = 1;        // 錯誤
    a.y = 2;        // 正確,mutable修飾使得成員可被修改,即使對象a為const
    return 0

Copyright © Linux教程網 All Rights Reserved