大家好晚上好，今天給大家分享的是，c++中的const的使用，在我們以前學習c語言的時候，我們已經接觸了const的用法，那么在c++中，const的使用，又會有什么樣的不同呢？接下來就開始我們的分享吧！每天進步一點點，日積月累你也是專家！

一、c語言中const的用法：

1、const修飾的變量是只讀的，本質還是變量。

2、const修飾的局部變量在棧分配空間，這里舉一個例子：

#include <stdio.h>

int main()
{
    const int c =0;
	int *p (int *)&c;

	printf("start\n");

	*p=6;

	printf=("c=%d\n",c);

	return 0;
}

最終演示結果可以看到，c的值發生了改變：

root@txp-virtual-machine:/home/txp/c++# ./a.out
start
c=6


3、const修飾的全局變量在只讀存儲區分配空間

4、const只在編譯期有用，在運行期無用。

另外關于c語言里面常用的const幾種用法，可以我之前寫的文章（小聲說提示一下，當時第一次寫文章，排版排的差勁，還請理解！）超實用的const用法

二、c++中的const用法：

既然今天主題是C++中的const用法，想都不用想，c++中的const的用法和c語言里面的const用法肯定有不一樣的地方，下面我們來看具體的用法：

1、當碰見const聲明時在符號表中放入常量。

2、編譯過程中若發現使用常量則直接以符號表中的值替換。

3、編譯過程中若發現下面情況則給對應的常量分配存儲空間
    ——對const常量使用了extern
    ——對const常量使用&操作符
    
  注意：c++編譯器雖然可能為const常量分配空間
  ，但不會使用其存儲空間中的值。

這里的話，還是以上面的那個例子來舉例，我們現在在c++環境下來編譯試試，最終結果會是什么情況：

root@txp-virtual-machine:/home/txp/c++# g++ test.cpp
root@txp-virtual-machine:/home/txp/c++# ./a.out
start
c=0

這時候突然發現，c的值居然還是零，有點難以置信；其實不然，這就是我們上面說的，在c++中，在上面的編譯過程中會產生一個符號表的概念（符號表是編譯器在編譯過程中所產生的一張表，這張表是編譯器內部的數據結構），我們還是拿剛才的那個示例來分析：

 

我們來分析一下，在c語言里面指針p初始化的時候，指向了c,然后在對指針p取值操作，也就是說，改變了這時候所p指向的那個地址（&c）處的內存里面的內容，原來是0，現在被改成了6；然而在我們的c++編譯環境中，就不是按照這樣來想的了，如上面的示意圖，可以看到，在c++編譯過程中會有一個符號表生成，那么當操作指針p的時候，由于c的值暫時被放到了符號表中了，所以的話，這個時候*p只是屬于自己在那塊內存中賦值操作而已，影響不到c的值了，下面我添加打印一下(*p)的值來說明：

#include <stdio.h>

int main()
{
    const int c =0;
  int *p =(int *)&c;
  
  printf("start\n");
  
  *p=6;
  
  printf("c=%d\n",c);
  printf("*p=%d\n",*p);
  return 0;
}

演示結果：

root@txp-virtual-machine:/home/txp/c++# ./a.out
start
c=0
*p=6

三、c++中的const與宏的區別：

1，const 常量由編譯器處理；

2，編譯器對 const 常量進行類型檢查和作用域檢查；

3，宏定義由預處理器處理，單純的文本替換，無類型和作用域檢查；

為了大家方便理解，下面我們來舉個例子來說明情況，不過為了說明c++里面const修飾的變量，本質還是變量，并且只有驗證一下c語言里面的const只用在編譯過程中有用，在運行期沒有用，這里我們先舉例一個c環境的代碼，然后再到c++環境中編譯，做一個簡單的對比，方便大家理解：

 #include <stdio.h>
  void f()
  {
      #define a 3
      const int b = 4;
  }
  
  void g()
  {
     printf("a = %d\n", a);
     //printf("b = %d\n", b);
  }
 
 int main()
 {
     const int A = 1;
     const int B = 2;
     int array[A + B] = {0};
     int i = 0;
     for(i=0; i<(A + B); i++)
     {
         printf("array[%d] = %d\n", i, array[i]);
     }
     
     f();
     g();
     
     return 0;
}

演示結果，這個是在c環境下編譯的現象：

root@txp-virtual-machine:/home/txp/c++# gcc test.c
test.c: In function ‘main’:
test.c:18:6: error: variable-sized object may not be initialized
      int array[A + B] = {0};
      ^
test.c:18:6: warning: excess elements in array initializer [enabled by default]
test.c:18:6: warning: (near initialization for ‘array’) [enabled by default]

什么居然編譯通過不了，不要吃驚，在剛才也說了結論。我們現在具體來看一下它的說了啥， “variable-sized object may not be initialized”意思是：可變大小的對象可能無法初始化，也就是說明在c語言中使用const修飾的變量A和B,本質上還是變量。這里另外再啰嗦一下，面試的時候，千萬不要說const修飾的就是常量，在c語言里面真正比較好的常量例子，通過 enum（枚舉）定義的標識符才是真正意義上的常量。

接下來我們在c++環境中編譯看看：

root@txp-virtual-machine:/home/txp/c++# g++ test.cpp
root@txp-virtual-machine:/home/txp/c++# ./a.out
array[0] = 0
array[1] = 0
array[2] = 0
a = 3

哈哈通過了，這也說明了，在c++中一般定義的變量類型，在其前面加了const修飾，它就真的變成了常量了；同時細心的你可能發現，怎么在哪個函數里面有一個宏定義啊；平時大家可能見的比較多的是，宏定義都是寫在最前面，這里不要奇怪，因為編譯在編譯到這里的時候，只是把宏定義換成了"a=3",而且還要注意上面const和宏定義的區別：編譯器對 const 常量進行類型檢查和作用域檢查。于是乎我把上面的那個g()函數里面的注釋拿掉，再進行編譯：

 #include <stdio.h>
  void f()
  {
      #define a 3
      const int b = 4;
  }
  
  void g()
  {
     printf("a = %d\n", a);
     printf("b = %d\n", b);
  }
 
 int main()
 {
     const int A = 1;
     const int B = 2;
     int array[A + B] = {0};
     int i = 0;
     for(i=0; i<(A + B); i++)
     {
         printf("array[%d] = %d\n", i, array[i]);
     }
     
     f();
     g();
     
     return 0;
}

編譯結果：

root@txp-virtual-machine:/home/txp/c++# g++ test.cpp
test.cpp: In function ‘void g()’:
test.cpp:11:25: error: ‘b’ was not declared in this scope
      printf("b = %d\n", b);

在g()函數里面找不到變量b，沒有定義，這證明了上面所說的觀點。

四、總結：

1，與 C 語言不通，C++ 中的 const 不是只讀變量；

2，C++ 中的 const 是一個真正意義上的常量；

3，C++ 編譯器可能會為 const 常量非配空間；

4，C++ 完全兼容 C 語言中 const 常量的語法特性；