一.const 使用

const 是 constant 的縮寫，“恒定不變”的意思。被 const 修飾的東西都受到強(qiáng)制保護(hù)，可以預(yù)防意外的變動，能提高程序的健壯性。所以很多 C++ 程序設(shè)計書籍建議：“Use const whenever you need”。

1.const 修飾變量

/******************************************************************************************/
//@Author:猿說編程
//@Blog(個人博客地址): www.codersrc.com
//@File:C語言 const 和 define 區(qū)別
//@Time:2021/07/04 08:00
//@Motto:不積跬步無以至千里，不積小流無以成江海，程序人生的精彩需要堅持不懈地積累！
/******************************************************************************************/

#include <stdio.h>

int main() {
    const int a = 20 ;
    printf("a = %d\n",a);
    a = 200 ;
    printf("a = %d\n",a);
    return 0;
}

/*
 輸出：

 Compilation Failed
 error: assignment of read-only variable 'a'
     6 |     a = 200 ;
       |     ~~^~~~~
 */

用 const 定義的變量的值是不允許改變的，即不允許給它重新賦值，即使是賦相同的值也不可以。并且 const 修飾的變量在定義的時候就給它賦初值，否則報錯：

error: uninitialized 'const ' [-fpermissive]

詳細(xì)解釋可以直接跳轉(zhuǎn)：const 修飾變量；

2.const 修飾指針

//以下兩者等價，表示 *p 不可變。*p 表示的是指針變量 p 所指向的內(nèi)存單元里面的內(nèi)容，此時這個內(nèi)容不可變；
const int *p
int const *p


//此時 const 修飾的是 p，所以 p 中存放的內(nèi)存單元的地址不可變，而內(nèi)存單元中的內(nèi)容可變。即 p 的指向不可變，p 所指向的內(nèi)存單元的內(nèi)容可變；
int * const p


//*p 和 p 都被修飾了，那么 p 中存放的內(nèi)存單元的地址和內(nèi)存單元中的內(nèi)容都不可變；
const int * const p

3.const 修飾在函數(shù)名前面當(dāng)

const 在函數(shù)名前面的時候修飾的是函數(shù)返回值；在函數(shù)名后面表示是 C++ 常成員函數(shù)，該函數(shù)不能修改對象內(nèi)的任何成員，只能發(fā)生讀操作，不能發(fā)生寫操作。

const char * GetString(void);
const int    GetInt(void);
const float  GetFloat(void);
const double GetDdouble(void);

如果給以“指針傳遞”方式的函數(shù)返回值加 const 修飾，那么函數(shù)返回值（即指針）的內(nèi)容不能被修改，該返回值只能被賦給加 const 修飾的同類型指針；

const char * GetString(void);

//如下語句將出現(xiàn)編譯錯誤：
//char *str = GetString();

//正確的用法是
const char  *str = GetString();

如果函數(shù)返回值采用“值傳遞方式”，由于函數(shù)會把返回值復(fù)制到外部臨時的存儲單元中，加 const 修飾沒有任何價值。

int GetInt(void);

const int GetInt(void);

以上兩個函數(shù)都是都是獨立存在的，并非同一個函數(shù)；

4.const 修飾在函數(shù)名后面

當(dāng) const 在函數(shù)名前面的時候修飾的是函數(shù)返回值；在函數(shù)名后面表示是 C++ 常成員函數(shù)，該函數(shù)不能修改對象內(nèi)的任何成員，只能發(fā)生讀操作，不能發(fā)生寫操作。

/******************************************************************************************/
//@Author:猿說編程
//@Blog(個人博客地址): www.codersrc.com
//@File:C語言 const 和 define 區(qū)別
//@Time:2021/07/04 08:00
//@Motto:不積跬步無以至千里，不積小流無以成江海，程序人生的精彩需要堅持不懈地積累！
/******************************************************************************************/


class People
{
 public:
    int talk(void);
    int eat(void) const; // const 成員函數(shù)
 private:
    int m_age;

};
int People::eat(void) const
{
    ++m_age; // 編譯錯誤，企圖修改數(shù)據(jù)成員m_num
    talk();  // 編譯錯誤，企圖調(diào)用非const函數(shù)
    return    m_age;
}

• const 對象只能訪問 const 成員函數(shù),而非 const 對象可以訪問任意的成員函數(shù),包括 const 成員函數(shù)；
• const 對象的成員是不可修改的,然而 const 對象通過指針維護(hù)的對象卻是可以修改的；
• const 成員函數(shù)不可以修改對象的數(shù)據(jù),不管對象是否具有 const 性質(zhì).它在編譯時,以是否修改成員數(shù)據(jù)為依據(jù),進(jìn)行檢查；
• 然而加上 mutable 修飾符的數(shù)據(jù)成員,對于任何情況下通過任何手段都可修改,自然此時的 const 成員函數(shù)是可以修改它的；
  

5.const 修飾函數(shù)參數(shù)

如果函數(shù)參數(shù)采用“指針傳遞”，那么加 const 修飾可以防止意外地改動該指針，起到保護(hù)作用。

void StringCopy (char*strDestination, const char *strSource);

其中 strSource 是輸入?yún)?shù)，strDestination 是輸出參數(shù)。給 strSource 加上 const 修飾后，如果函數(shù)體內(nèi)的語句試圖改動 strSource 的內(nèi)容，編譯器將指出錯誤。

如果輸入?yún)?shù)采用“值傳遞”，由于函數(shù)將自動產(chǎn)生臨時變量用于復(fù)制該參數(shù)，該輸入?yún)?shù)本來就無需保護(hù)，所以不要加 const 修飾。

例如不要將函數(shù) void Func1(int x) 寫成 void Func1(const int x)。

如果參數(shù)作為輸出參數(shù)，不論它是什么數(shù)據(jù)類型，也不論它采用“指針傳遞”還是“引用傳遞”，都不能加 const 修飾，否則該參數(shù)將失去輸出功能（因為有 const 修飾之后，不能改變他的值）。

如果參數(shù)作為輸入?yún)?shù)，可以防止數(shù)據(jù)被改變，起到保護(hù)作用，增加程序的健壯性；

二.define 使用

1.define 定義常量

C 語言中，可以用 #define 定義一個標(biāo)識符來表示一個常量，用 #define 定義標(biāo)識符的一般形式為：

#define  標(biāo)識符  常量   //注意define最后沒有分號
//例如：
#define MAX_VALUE 100       //定義整型變量MAX_VALUE值為100
#define USER_NAME "huge"    //定義字符串變量USER_NAME值為"huge"
#define PI 3.1415926        //定義浮點數(shù)變量PI值為3.1415926

凡是以 # 開頭的均為預(yù)處理指令，預(yù)處理又叫預(yù)編譯。預(yù)編譯不是編譯，而是編譯前的處理。這個操作是在正式編譯之前由系統(tǒng)自動完成的。

2.define 定義函數(shù)

//定義常量
#define MAX_VALUE 100       //定義整型變量MAX_VALUE值為100
#define USER_NAME "huge"    //定義字符串變量USER_NAME值為"huge"
#define PI 3.1415926        //定義浮點數(shù)變量PI值為3.1415926

//定義函數(shù)
#define MAX(a,b) (a>b)?a:b  //取兩個數(shù)最大值
#define MIN(a,b) (a<b)?a:b  //取兩個數(shù)最小值

3.define 定義多行函數(shù)

//定義常量
#define MAX_VALUE 100       //定義整型變量MAX_VALUE值為100
#define USER_NAME "huge"    //定義字符串變量USER_NAME值為"huge"
#define PI 3.1415926        //定義浮點數(shù)變量PI值為3.1415926

//定義簡單函數(shù)
#define MAX(a,b) (a>b)?a:b  //取兩個數(shù)最大值
#define MIN(a,b) (a<b)?a:b  //取兩個數(shù)最小值

//定義復(fù)雜多行的函數(shù)
#define   MACRO(arg1,   arg2)   do   {   \
   \
stmt1;   \
stmt2;   \
   \
}   while(0)

//關(guān)鍵是要在每一個換行的時候加上一個 "\ "

使用define定義一個多行的復(fù)雜函數(shù),關(guān)鍵是要在每一個換行的時候加上一個 \；

4.define 防止頭文件重復(fù)包含

通過 #ifndef / #define 解決頭文件重復(fù)包含

#ifndef __XXX_H__
#define __XXX_H__

int a=1;

#endif

上面的偽代碼如下：

如果(沒有定義宏__XXX_H__)
{
    那么直接定義宏__XXX_H__
    定義變量a 并且賦值為 1
}
結(jié)束程序

• 假如第一次包含時，由于沒有定義宏 __XXX_H，所以做了兩件事，定義宏 __XXX_H，然后定義 int a = 1;
• 假如第二次包含時，由于已經(jīng)定義宏 __XXX_H__，所以啥都不做；
• 假如第 N 次包含時，由于已經(jīng)定義宏 __XXX_H__，所以啥都不做；
• 整個過程，無論頭文件被包含多少次，變量 a 只被定義一次，不會有重復(fù)包含重復(fù)定義的問題存在！
  

三.const 和 define 區(qū)別

1.就起作用的階段而言
define 是在編譯的預(yù)處理階段起作用，而 const 是在 編譯、運行的時候起作用。
2.就起作用的方式而言
define 只是簡單的字符串替換，沒有類型檢查。而 const 有對應(yīng)的數(shù)據(jù)類型，是要進(jìn)行判斷的，可以避免一些低級的錯誤。
3.就存儲方式而言
define 只是進(jìn)行展開，有多少地方使用，就替換多少次，它定義的宏常量在內(nèi)存中有若干個備份； const 定義的只讀變量在程序運行過程中只有一份備份。
4.從代碼調(diào)試的方便程度而言
const 常量可以進(jìn)行調(diào)試的，define 是不能進(jìn)行調(diào)試的，因為在預(yù)編譯階段就已經(jīng)替換掉了。

5.從效率程度而言

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

四.const 優(yōu)點

• 1.const 常量有數(shù)據(jù)類型，而宏常量沒有數(shù)據(jù)類型。編譯器可以對前者進(jìn)行類型安全檢查。而對后者只進(jìn)行字符替換，沒有類型安全檢查，并且在字符替換可能會產(chǎn)生意料不到的錯誤。
• 2.有些集成化的調(diào)試工具可以對 const 常量進(jìn)行調(diào)試，但是不能對宏常量進(jìn)行調(diào)試。
• 3.const 可節(jié)省空間，避免不必要的內(nèi)存分配，提高效率

到此這篇關(guān)于關(guān)于C語言 const 和 define 區(qū)別的文章就介紹到這了,更多相關(guān)C語言 const 和 define 區(qū)別 內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論