C++中const、volatile、mutable使用方法小結(jié)

更新時間：2020年01月31日 15:22:03 作者：Dawn_sf

這篇文章主要介紹了C++中const、volatile、mutable使用方法小結(jié),需要的朋友可以參考下

相信const大家對他并不陌生，可能大家在日常的編寫代碼當(dāng)中就會時常用到const，但是剩下的兩個關(guān)鍵字不知道我們有

沒有使用過volatile和mutable兩個關(guān)鍵字其實不算特別常用，但是我們一定要知道這個關(guān)鍵字有什么用，應(yīng)該怎么用.首

先const的基本操作我曾經(jīng)寫過一篇博客:const的基本使用

現(xiàn)在我要說一個const操作里面比較騷的一些做法,

舉個例子我們以前寫過的一個類，我們會使用operator[]來返回一個reference的指向,這個一般情況我們都會寫一個const的也會寫一個非const的opeartor[].這是我們最常見的一個代碼：

相信const大家對他并不陌生，可能大家在日常的編寫代碼當(dāng)中就會時常用到const，但是剩下的兩個關(guān)鍵字不知道我們有沒有使用過volatile和mutable兩個關(guān)鍵字其實不算特別常用，但是我們一定要知道這個關(guān)鍵字有什么用，應(yīng)該怎么用.

const的基本使用

const的用法我覺得對于一個以后想著做一個優(yōu)秀的程序員來說，這是必須熟練掌握的技能。因為網(wǎng)上有好多的文章介紹它的寫的非常好，有的我就直接拿過來了~，現(xiàn)在我們來看看他的用法。

const 要求他所修飾的對象為常量，不可被改變，不可被賦值，不可作為左值.

1、函數(shù)體內(nèi)修飾局部變量

例：

void func(){
const int a=0;
}

const作為一個類型限定詞，和int有相同的地位。

const int a; int const a;

是等價的。于是此處我們一定要清晰的明白，const修飾的對象是誰，是a還是int
const要求他所修飾的對象為常量，不可被改變，不可被賦值，不可作為左值（l-value)。所以很明顯它修飾的是a。這是一個很常見的使用方式：

const double pi=3.14;

在程序的后面如果企圖對pi再次賦值或者修改就會出錯。然后看一個稍微復(fù)雜的例子。

const int* p;

因為int* p;和 int *p;是等價的。
所以const int (*p)和int const (*p)是等價的。現(xiàn)在一目了然const 修飾的是誰？是*p.所以p+=1；是合法的

*p+=1;是非法的因為const修飾了你。

int* const p；那這個什么意思？

看const修飾的是什么？它修飾的p。但是p是一個int型的指針，所以這個指針的地址沒有辦法修改。

p+=1； //這就是非法的
*p+=1; //這個是合法的

再看一個更復(fù)雜的例子，它是上面二者的綜合

const int* const p;說明p自己是常量，且p指向的變量也是常量。
于是

p+=1; //非法
*p+=1; //非法

const 還有一個作用就是用于修飾常量靜態(tài)字符串。例如：

const char* name=David;

如果沒有const,我們可能會在后面有意無意的寫name[4]='x'這樣的語句，這樣會導(dǎo)致對只讀內(nèi)存區(qū)域的賦值，然后程序會立刻異常終止。有了 const,這個錯誤就能在程序被編譯的時候就立即檢查出來，這就是const的好處。讓邏輯錯誤在編譯期被發(fā)現(xiàn)。

2、在函數(shù)聲明時修飾參數(shù)
舉個例子void * myMemMove(void *dst,constvoid *src,intcount )這是我寫的memmove函數(shù)的聲明，這個函數(shù)的意思就是（任意類型）把*src的內(nèi)容復(fù)制給*dst，我們現(xiàn)在很明顯的看到*src它只讓你復(fù)制，你不能修改它的值，所以怕你在以后的函數(shù)的定義里出現(xiàn)問題現(xiàn)在在聲明里限制你。

3、全局變量
我們的原則依然是，盡可能少的使用全局變量。我們的第二條規(guī)則則是，盡可能多的使用const。如果一個全局變量只在本文件中使用，那么用法和前面所說的函數(shù)局部變量沒有什么區(qū)別。如果它要在多個文件間共享，那么就牽扯到一個存儲類型的問題。

有兩種方式。

1.使用extern
例如
/* test.h */
extern const double pi;
/* test.c */
const double pi=3.14;

然后其他需要使用pi這個變量的，包含test.h

#include test.h

或者，自己把那句聲明復(fù)制一遍就好。

這樣做的結(jié)果是，整個程序鏈接完后，所有需要使用pi這個變量的共享一個存儲區(qū)域。

2.使用static,靜態(tài)外部存儲類

/* constant.h */
static const pi=3.14;

需要使用這個變量的*.c文件中，必須包含這個頭文件。

前面的static一定不能少。否則鏈接的時候會報告說該變量被多次定義。這樣做的結(jié)果是，每個包含了constant.h的*.c文件，都有一份該變量自己的copy,該變量實際上還是被定義了多次，占用了多個存儲空間，不過在加了static關(guān)鍵字后，解決了文件間重定義的沖突。壞處是浪費了存儲空間，導(dǎo)致鏈接完后的可執(zhí)行文件變大。但是通常，這個，小小幾字節(jié)的變化，不是問題。好處是，你不用關(guān)心這個變量是在哪個文件中被初始化的。
其實const我覺得更多是程序員自己限制自己，自己告訴自己后面哪里不能出現(xiàn)錯誤

舉個例子吧。

#include<stdio.h>
#include<Windows.h>
int main()
{
	int *p;
	const int a = 0;
	p = &a;
	*p = 3;
	printf("a= %d \n", a);
	system("pause");
	return 0;
}

現(xiàn)在看看運行結(jié)果

現(xiàn)在我要說一個const操作里面比較騷的一些做法,

舉個例子我們以前寫過的一個類，我們會使用operator[]來返回一個reference的指向,這個一般情況我們都會寫一個

const的也會寫一個非const的opeartor[].這是我們最常見的一個代碼：

T& operator[](int position) 
{ 
 return xxx[position]; 
} 
const T& operator[](int position) const 
{ 
 return xxx[position]; 
}

這是我們平時寫的初級的代碼，但是現(xiàn)在當(dāng)我們要寫一個TextBlock內(nèi)的opeartor[]不單只返回一個referencr了，也可能執(zhí)行邊界檢查，日志訪問信息，還有什么數(shù)據(jù)完善性檢驗等等一大堆繁瑣的代碼，這個時候當(dāng)你實現(xiàn)operator[] const和operator[]() const,的時候兩份代碼大部分都一樣，這里伴隨的是代碼重復(fù)，編譯時間變長，維護代碼膨脹等等頭疼的問題. 當(dāng)然啦，你可以讓上述那些繁瑣的函數(shù)全部封裝的別的函數(shù)中，然后分別在operator[]()和operator[]()const當(dāng)中調(diào)用但是你還說重復(fù)了一些代碼比如兩次return語句，函數(shù)調(diào)用.真正該做的是實現(xiàn)operator[]的機能一次并使用它兩次。也就是你只需要寫一個函數(shù)，令另外一個調(diào)用這個，這促使我們將常量性轉(zhuǎn)移. 接下來見證奇跡我們來看看下面這個代碼是怎么實現(xiàn)的上述的操作的：

class TextBlock 
{ 
public: 
 ... 
 const char& operator[](std::size_t position) const 
 { 
  ... 
  ... 
  ... 
  return text[position]; 
 } 
 
 char& operator[](std::size_t position) 
 { 
  return const_cast<char&>(static_cast<const TextBlock&>(*this)[position]); 
 } 
};

來仔細看這個操作;return const_cast<char&>(static_cast<const TextBlock&>(*this)[position]);
首先把*this強制轉(zhuǎn)換為const TextBlock，再然后調(diào)用const的operator[]，最后再把const的operator[]的返回值的const常量性取消，然后返回一個非const的值. 這里的調(diào)用實在是太妙了，我們可以思考一下，好好想想這里的深意.
但是會有人說，為什么不用const operator[]調(diào)用operator[]呢，這樣強制兩個都可以行的通啊.這樣想是錯的！

令const版本調(diào)用調(diào)用no-const版本以避免重復(fù)并不是你該做的事情. 記住const所修飾函數(shù)的承諾就是我絕對不會修改你，no-const函數(shù)可沒有這種承諾，所以你讓一個const函數(shù)去調(diào)用一個no-const函數(shù)是不現(xiàn)實的. over其實const有很多可以玩的屬性，只要我們想到就可以去實現(xiàn)，這里就說這么一個就ok. 接下來我們來瞧瞧另外兩個關(guān)鍵字.

C++中的mutable關(guān)鍵字

mutalbe的中文意思是“可變的，易變的”，跟constant（既C++中的const）是反義詞。

在C++中，mutable也是為了突破const的限制而設(shè)置的。被mutable修飾的變量，將永遠處于可變的狀態(tài)，即使在一個const函數(shù)中。

我們知道，被const關(guān)鍵字修飾的函數(shù)的一個重要作用就是為了能夠保護類中的成員變量。即：該函數(shù)可以使用類中的所有成員變量，但是不能修改他們的值。然而，在某些特殊情況下，我們還是需要在const函數(shù)中修改類的某些成員變量，因為要修改的成員變量與類本身并無多少關(guān)系，即使修改了也不會對類造成多少影響。當(dāng)然，你可以說，你可以去掉該函數(shù)的const關(guān)鍵字呀！但問題是，我只想修改某個成員變量，其余成員變量仍然希望被const保護。

經(jīng)典的應(yīng)用場景比如說：我要測試一個方法的被調(diào)用次數(shù)。

class Person {
public:
 Person();
 ~Person();

 int getAge() const; /*調(diào)用方法*/
 int getCallingTimes() const; /*獲取上面的getAge()方法被調(diào)用了多少次*/
private:
 int age;
 char *name;
 float score;
 int m_nums;   /*用于統(tǒng)計次數(shù)*/
};

最普遍的作法就是在getAge()的方法體內(nèi)對m_nums這個變量進行加+1，但是getAge()方法又是const方法，無法修改m_nums這個變量，我又不想去掉const關(guān)鍵字讓別人能夠修改age等成員變量，這個時候mutable關(guān)鍵字就派上用場了：

#include <iostream>

class Person {
public:
 Person();
 ~Person();

 int getAge() const; /*調(diào)用方法*/
 int getCallingTimes() const; /*獲取上面的getAge()方法被調(diào)用了多少次*/
private:
 int age;
 char *name;
 float score;
 mutable int m_nums;   /*用于統(tǒng)計次數(shù)*/
};

Person::Person()
{
 m_nums = 0;
}

Person::~Person(){}

int Person::getAge() const
{
 std::cout << "Calling the method" << std::endl;
 m_nums++;
 // age = 4; 仍然無法修改該成員變量
 return age;
}

int Person::getCallingTimes()const
{
 return m_nums;
}

int main()
{
 Person *person = new Person();
 for (int i = 0; i < 10; i++) {
  person->getAge();
 }
 std::cout << "getAge()方法被調(diào)用了" << person->getCallingTimes() << "次" << std::endl;
 delete person;

 getchar();
 return 0;
}

運行結(jié)果：

Calling the method
Calling the method
Calling the method
Calling the method
Calling the method
Calling the method
Calling the method
Calling the method
Calling the method
Calling the method

getAge()方法被調(diào)用了10次

這樣我們既保護了別的成員變量，又能夠使計數(shù)器的值進行累加。

需要注意的是：mutable不能修飾const 和 static 類型的變量。

接著補充

實際運用起來也非常容易，就是你想改變的元素被const修飾了，你就往它前面加上mutable那么你就無敵了..

我就舉一個最簡單的例子,我定一個AA類，我在AA類中定義一個MT()函數(shù)，該函數(shù)屬性為const屬性，再然后我

想在MT()函數(shù)中添加該函數(shù)執(zhí)行多少次時，程序編不過去了. 因為const修飾的函數(shù)里面的所有值都不能修改.

class AA
{
public:
	void MT() const
	{
		i++;
		cout << "hehe";
		cout << "執(zhí)行了" << i << "次該程序";
	}
 
private:
	int i = 0;
};

但是這樣編不過去啊，因為MT()函數(shù)為const函數(shù),所以不能修改i的值，但是如果我在這里使用mutable關(guān)鍵字的

話，現(xiàn)在我們把i加上mutable關(guān)鍵字，這樣它永遠就是一個可變的了. 來我們加上去試一試,

class AA
{
public:
	void MT() const
	{
		i++;
		cout << "hehe" << " ";
		cout << "執(zhí)行了" << i << "次該程序" << endl;;
	}
 
private:
	mutable int i = 0;
};
 
int main()
{
	AA a;
	a.MT();
	a.MT();
	a.MT();
	a.MT();
	return 0;
}

運行結(jié)果:

這就是mutable的最簡單的一個應(yīng)用，以后可以根據(jù)需求來使用~

volatile

為什么使用volatile ？
C/C++中的 volatile 關(guān)鍵字和const對應(yīng)，用來修飾變量，通常用于建立語言級別的memory barrier。這是BS在“The C++ Programming Language”對volatile修飾詞的解釋：
A volatile specifier is a hint to a compiler that an object may change its value in ways not specified by the language so that aggressive optimizations must be avoided.

volatile 關(guān)鍵字是一種類型修飾符，用它聲明的類型變量表示可以被某些編譯器未知的因素更改，比如：操作系統(tǒng)，硬件或者其他線程等。

遇到這個關(guān)鍵字聲明的變量，編譯器對訪問該變量的代碼就不再進行優(yōu)化，從而可以提供對特殊地址的穩(wěn)定訪問。聲明時語法：int volatile vInt; 當(dāng)要求使用 volatile 聲明的變量的值的時候，系統(tǒng)總是重新從它所在的內(nèi)存讀取數(shù)據(jù)，即使它前面的指令剛剛從該處讀取過數(shù)據(jù)。而且讀取的數(shù)據(jù)立刻被保存。例如：

volatile int i=10; 
int a = i; 
... 
// 其他代碼，并未明確告訴編譯器，對 i 進行過操作 
int b = i; 
volatile int i=10;
int a = i;
...
// 其他代碼，并未明確告訴編譯器，對 i 進行過操作
int b = i;

volatile 指出 i 是隨時可能發(fā)生變化的，每次使用它的時候必須從 i的地址中讀取，因而編譯器生成的匯編代碼會重新從i的地址讀取數(shù)據(jù)放在 b 中。而優(yōu)化做法是，由于編譯器發(fā)現(xiàn)兩次從 i讀數(shù)據(jù)的代碼之間的代碼沒有對 i 進行過操作，它會自動把上次讀的數(shù)據(jù)放在 b 中。而不是重新從 i 里面讀。這樣以來，如果 i是一個寄存器變量或者表示一個端口數(shù)據(jù)就容易出錯，所以說 volatile 可以保證對特殊地址的穩(wěn)定訪問。注意，在 VC 6 中，一般調(diào)試模式?jīng)]有進行代碼優(yōu)化，所以這個關(guān)鍵字的作用看不出來。下面通過插入?yún)R編代碼，測試有無 volatile 關(guān)鍵字，對程序最終代碼的影響：

輸入下面的代碼：

#include <stdio.h> 
  
void main() 
{ 
  int i = 10; 
  int a = i; 
   
  printf("i = %d", a); 
 
  // 下面匯編語句的作用就是改變內(nèi)存中 i 的值 
  // 但是又不讓編譯器知道 
  __asm{ 
    mov dword ptr [ebp-4], 20h 
  } 
    
  int b = i; 
  printf("i = %d", b); 
} 
#include <stdio.h>
 
void main()
{
  int i = 10;
  int a = i;
  
  printf("i = %d", a);
 
  // 下面匯編語句的作用就是改變內(nèi)存中 i 的值
  // 但是又不讓編譯器知道
  __asm{
    mov dword ptr [ebp-4], 20h
  }
   
  int b = i;
  printf("i = %d", b);
}

然后，在 Debug 版本模式運行程序，輸出結(jié)果如下：

i = 10
i = 32
然后，在 Release 版本模式運行程序，輸出結(jié)果如下：

i = 10
i = 10
輸出的結(jié)果明顯表明，Release 模式下，編譯器對代碼進行了優(yōu)化，第二次沒有輸出正確的 i 值。下面，我們把 i 的聲明加上 volatile 關(guān)鍵字，看看有什么變化：

#include <stdio.h> 
 void main() 
{ 
  volatile int i = 10; 
  int a = i; 
  printf("i = %d", a); 
  __asm { 
    mov dword ptr [ebp-4], 20h 
  } 
   
  int b = i; 
  printf("i = %d", b); 
} 
#include <stdio.h>
 
void main()
{
  volatile int i = 10;
  int a = i;
 
  printf("i = %d", a);
  __asm {
    mov dword ptr [ebp-4], 20h
  }
  
  int b = i;
  printf("i = %d", b);
}

分別在 Debug 和 Release 版本運行程序，輸出都是：

i = 10
i = 32

這說明這個 volatile 關(guān)鍵字發(fā)揮了它的作用。其實不只是“內(nèi)嵌匯編操縱棧”這種方式屬于編譯無法識別的變量改變，另外更多的可能是多線程并發(fā)訪問共享變量時，一個線程改變了變量的值，怎樣讓改變后的值對其它線程 visible。一般說來，volatile用在如下的幾個地方：
1) 中斷服務(wù)程序中修改的供其它程序檢測的變量需要加volatile；
2) 多任務(wù)環(huán)境下各任務(wù)間共享的標(biāo)志應(yīng)該加volatile；
3) 存儲器映射的硬件寄存器通常也要加volatile說明，因為每次對它的讀寫都可能由不同意義；

2.volatile 指針

和 const 修飾詞類似，const 有常量指針和指針常量的說法，volatile 也有相應(yīng)的概念：

修飾由指針指向的對象、數(shù)據(jù)是 const 或 volatile 的：

const char* cpch; 
volatile char* vpch; 
const char* cpch;
volatile char* vpch;

注意：對于 VC，這個特性實現(xiàn)在 VC 8 之后才是安全的。指針自身的值——一個代表地址的整數(shù)變量，是 const 或 volatile 的：

char*const pchc; 
char*volatile pchv; 
char*const pchc;
char*volatile pchv;

注意：

(1) 可以把一個非volatile int賦給volatile int，但是不能把非volatile對象賦給一個volatile對象。

(2) 除了基本類型外，對用戶定義類型也可以用volatile類型進行修飾。
(3) C++中一個有volatile標(biāo)識符的類只能訪問它接口的子集，一個由類的實現(xiàn)者控制的子集。用戶只能用const_cast來獲得對類型接口的完全訪問。此外，volatile向const一樣會從類傳遞到它的成員。

3. 多線程下的volatile
有些變量是用volatile關(guān)鍵字聲明的。當(dāng)兩個線程都要用到某一個變量且該變量的值會被改變時，應(yīng)該用volatile聲明，該關(guān)鍵字的作用是防止優(yōu)化編譯器把變量從內(nèi)存裝入CPU寄存器中。如果變量被裝入寄存器，那么兩個線程有可能一個使用內(nèi)存中的變量，一個使用寄存器中的變量，這會造成程序的錯誤執(zhí)行。volatile的意思是讓編譯器每次操作該變量時一定要從內(nèi)存中真正取出，而不是使用已經(jīng)存在寄存器中的值，如下：

volatile BOOL bStop = FALSE; 
// 在一個線程中：  
 while( !bStop ) { ... }  
bStop = FALSE;  
return;   
 
//在另外一個線程中，要終止上面的線程循環(huán)：  
bStop = TRUE;  
while( bStop ); //等待上面的線程終止， 
volatile BOOL bStop = FALSE; 
 
// 在一個線程中： 
 while( !bStop ) { ... } 
bStop = FALSE; 
return;  
 
//在另外一個線程中，要終止上面的線程循環(huán)： 
bStop = TRUE; 
while( bStop ); //等待上面的線程終止，

如果bStop不使用volatile申明，那么這個循環(huán)將是一個死循環(huán)，因為bStop已經(jīng)讀取到了寄存器中，寄存器中bStop的值永遠不會變成FALSE，加上volatile，程序在執(zhí)行時，每次均從內(nèi)存中讀出bStop的值，就不會死循環(huán)了。
這個關(guān)鍵字是用來設(shè)定某個對象的存儲位置在內(nèi)存中，而不是寄存器中。因為一般的對象編譯器可能會將其的拷貝放在寄存器中用以加快指令的執(zhí)行速度，例如下段代碼中：

在此段代碼中，nMyCounter的拷貝可能存放到某個寄存器中（循環(huán)中，對nMyCounter的測試及操作總是對此寄存器中的值進行），但是另外又有段代碼執(zhí)行了這樣的操作：nMyCounter -= 1;這個操作中，對nMyCounter的改變是對內(nèi)存中的nMyCounter進行操作，于是出現(xiàn)了這樣一個現(xiàn)象：nMyCounter的改變不同步。

下面是volatile變量的幾個例子：

1.并行設(shè)備的硬件寄存器（如：狀態(tài)寄存器

2.一個中斷服務(wù)子程序中會訪問到的非自動變量(Non-automatic variables)

3.多線程應(yīng)用中被幾個任務(wù)共享的變量

看下面例題:

int square(volatile int *ptr)
{
  return *ptr * *ptr;
}

這個程序有什么問題嗎? 如果我們不去關(guān)心volatile關(guān)鍵字的話，那么這個程序你怎么看都會覺得沒多大問題.但是這里

面問題大這ne，首先參數(shù)聲明為volatile就是表明*ptr可能會隨時改變.上述代碼運行時，編譯器可能產(chǎn)生這樣的代碼:

int square(volatile int *ptr)
{
  int a,b;
  a = *ptr;
  b = *ptr;
  return a * b;
}

因為你的*ptr是隨時都可以意想不到的變化，所以有可能a*b的時候，a b的值不相同. 這樣你就得到一個錯誤的結(jié)果

改正后的程序:

int square(volatile int *ptr)
{
  int a;
  a = *ptr;
  return a * a;
}

第二個問題，看如下代碼：

#include<iostream> 
#include<Windows.h> 
#include<assert.h> 
 
using namespace std; 
 
int main() 
{ 
  const int a = 2; 
  int *p = const_cast<int*>(&a); 
  *p = 3; 
  cout << a << endl; 
  system("pause"); 
  return 0; 
}

我們有理由的認為在內(nèi)存當(dāng)中a的值被修改為3，但是結(jié)果呢？我們來看一看