const

c語言中const修飾的量為常變數，可以通過一定的方法修改其值，如下程式碼：

# include<stdio.h>

int main()
{
	const int i = 20;
	int *p = &i;
	*p = 30;
	printf("%d\n", i);

	return 0;
}

c++中const修飾的量為常量，值不允許改變（改變不了）。在編譯期的時候將使用該常量值的地方替換成該常量的值。如下程式碼

# include<iostream>
using namespace std;

int main()
{
	const int i = 10;
	int *p = (int *)&i;
	*p = 20;

	cout << *p << "   " << i << endl;//在編譯時將此處i替換成10
	//輸出為20  10
	return 0;
}
 

• c++中常量必須初始化
• const修飾的資料產生的符號時local型別的符號，因為其產生一個global型別的符號也沒用，常量是在編譯期的時候進行值的替換，編譯是單檔案的，所以其產生一個global型別的符號，別的檔案中也沒法引用它進行替換。

c++常量可以退化成常變數（編譯期無法確定其值的時候會退化），如下操作

int c = 20;
const int s = c;
此時s就退化成一個常變數，因為在編譯的時候常量進行替換，此時無法得知該用什麼值進行替換s，在編譯期間不
進行取值的過程。

void fun(const int a)
{
    int *p = (int *)&a;
    *p = 30;

    cout << *p <<"  " <<a;//此時常量啊，也退化成了一個常變數因為在編譯時無法確認其值
}

int main()
{
    const int d = 10;
    int *p = (int *)&d;

    fun(10);
}
 

• const修飾的型別是離它最近的完整型別
• const修飾的內容是它修飾型別的內容
• const修飾的內容不允許被改變
• 不允許洩漏常量的地址給非常量的指標

int b = 10;

int *p1 = &b;//正確
const int *p2 = &b;//正確
int *const p3 = &b;//正確

int *q1 = *b;
const int *q2 = &b;
int *const q3 = &b;

q1 = p1; //int *p1 ---> int *q1 正確
q1 = p2; //const int *p2 ---> int *q1  錯誤，(*p2)為常量，q1為非常量的指標
q1 = p3; //int *const p3 ---> int *q1  正確，常量為p3，沒有洩漏p3的地址

q2 = p1; //int *p1 ---> const int *q2  正確，沒有常量洩漏地址
q2 = p2; //const int *p2 ---> const int *q2 正確，p2 q2均為常量的指標
q2 = p3; //int *const p3 ---> const int *p2 常量為p3，沒有洩漏p3的地址
 

引用(c++特有)

引用是變數的一個別名，引用底層是一個指標，在使用的時候替換成了指標的解引用

• 引用必須初始化
• 不允許洩漏常量的引用給一個非常量的引用
• 引用一個臨時量，如下：

int fun()
{
    return 1;
}
int main()

{
    const int &p = fun();//引用一個不可定址的常量，產生一個臨時量(常量)供引用
    return 0;
}



const int &p = 10;//也是產生一個臨時量(常量)供引用

注意：

1. 標準型別產生的臨時量是常量
2. 自定義型別產生的臨時量是非常量

• 引用單獨使用不參與型別
• const單獨使用不參與型別
• const和引用結合使用參與型別
• const修飾指標，如果修飾的內容裡沒有*，則const不參與型別

c語言程式碼如c++程式碼如何互相呼叫

c++呼叫c語言程式碼：

extern "C"  //用c語言的規則編譯
{
    呼叫的程式碼
}

c語言呼叫c++程式碼：

在cpp檔案中將c語言要呼叫的程式碼，用c語言的規則編譯即可