C++ 11標準中，const 用于為修飾的變量添加“只讀”屬性而 constexpr關鍵字則用于指明其后是一個常量，編譯器在編譯程序時可以順帶將其結果計算出來，而無需等到程序運行階段,這樣的優(yōu)化極大地提高了程序的執(zhí)行效率，本文重點介紹C++ const與constexpr區(qū)別介紹,一起看看吧。

constexpr：常量表達式

所謂常量表達式,指的就是由多個(≥1)常量組成的表達式。換句話說,如果表達式中的成員都是常量,那么該表達式就是一個常量表達式。這也意味著，常量表達式一旦確定，其值將無法修改。

實際開發(fā)中，我們經常會用到常量表達式。以定義數(shù)組為例，數(shù)組的長度就必須是一個常量表達式：

// 1)
int url[10];//正確
// 2)
int url[6 + 4];//正確
// 3)
int length = 6;
int url[length];//錯誤，length是變量

上述代碼演示了 3 種定義 url 數(shù)組的方式，其中第 1、2 種定義 url 數(shù)組時，長度分別為 10 和 6+4，顯然它們都是常量表達式，可以用于表示數(shù)組的長度；第 3 種 url 數(shù)組的長度為 length，它是變量而非常量，因此不是一個常量表達式，無法用于表示數(shù)組的長度。

常量表達式的應用場景還有很多，比如匿名枚舉、switch-case 結構中的 case 表達式等，感興趣的讀者可自行編碼測試，這里不再過多舉例。

我們知道，C++ 程序的執(zhí)行過程大致要經歷編譯、鏈接、運行這 3 個階段。值得一提的是，常量表達式和非常量表達式的計算時機不同，非常量表達式只能在程序運行階段計算出結果；而常量表達式的計算往往發(fā)生在程序的編譯階段，這可以極大提高程序的執(zhí)行效率，因為表達式只需要在編譯階段計算一次，節(jié)省了每次程序運行時都需要計算一次的時間。

對于用 C++ 編寫的程序，性能往往是永恒的追求。那么在實際開發(fā)中，如何才能判定一個表達式是否為常量表達式，進而獲得在編譯階段即可執(zhí)行的“特權”呢？除了人為判定外，C++11 標準還提供有 constexpr 關鍵字。

constexpr 關鍵字的功能是使指定的常量表達式獲得在程序編譯階段計算出結果的能力，而不必等到程序運行階段。C++ 11 標準中，constexpr 可用于修飾普通變量、函數(shù)（包括模板函數(shù)）以及類的構造函數(shù)。

注意：獲得在編譯階段計算出結果的能力，并不代表 constexpr修飾的表達式一定會在程序編譯階段被執(zhí)行，具體的計算時機還是編譯器說了算。

constexpr修飾普通變量

C++11 標準中，定義變量時可以用constexpr 修飾，從而使該變量獲得在編譯階段即可計算出結果的能力。

注意：使用 constexpr 修改普通變量時，變量必須經過初始化且初始值必須是一個常量表達式。舉個例子：

#include <iostream>
using namespace std;
int main()
{
    constexpr int num = 1 + 2 + 3;
    int url[num] = {1,2,3,4,5,6};
    couts<< url[1] << endl;
    return 0;
}

程序執(zhí)行結果為：2

讀者可嘗試將 constexpr 刪除，此時編譯器會提示“url[num] 定義中 num 不可用作常量”。

可以看到，程序第 6 行使用 constexpr 修飾 num 變量，同時將 “1+2+3” 這個常量表達式賦值給 num。由此，編譯器就可以在編譯時期對 num 這個表達式進行計算，因為 num 可以作為定義數(shù)組時的長度。

有讀者可能發(fā)現(xiàn)，將此示例程序中的 constexpr 用const關鍵字替換也可以正常執(zhí)行，這是因為 num 的定義同時滿足“num 是 const 常量且使用常量表達式為其初始化”這 2 個條件，由此編譯器會認定 num 是一個常量表達式。

另外需要重點提出的是，當常量表達式中包含浮點數(shù)時，考慮到程序編譯和運行所在的系統(tǒng)環(huán)境可能不同，常量表達式在編譯階段和運行階段計算出的結果精度很可能會受到影響，因此 C++11 標準規(guī)定，浮點常量表達式在編譯階段計算的精度要至少等于（或者高于）運行階段計算出的精度。

constexpr修飾函數(shù)

constexpr 還可以用于修飾函數(shù)的返回值，這樣的函數(shù)又稱為“常量表達式函數(shù)”。

注意，constexpr 并非可以修改任意函數(shù)的返回值。換句話說，一個函數(shù)要想成為常量表達式函數(shù)，必須滿足如下 4 個條件：1) 該函數(shù)必須有返回值，即函數(shù)的返回值類型不能是 void。
舉個例子：

constexpr void display() {
    //函數(shù)體
}

像上面這樣定義的返回值類型為 void 的函數(shù)，不屬于常量表達式函數(shù)。原因很簡單，因為通過類似的函數(shù)根本無法獲得一個常量。
2) 整個函數(shù)的函數(shù)體中，除了可以包含 using 指令、typedef 語句以及 static_assert 斷言外，只能包含一條 return 返回語句。
舉個例子：

constexpr int display(int x) {
   int ret = 1 + 2 + x;
   return ret;
}

注意，這個函數(shù)是無法通過編譯的，因為該函數(shù)的返回值用 constexpr 修飾，但函數(shù)內部包含多條語句。如下是正確的定義 display() 常量表達式函數(shù)的寫法：

constexpr int display(int x) {
    //可以添加 using 執(zhí)行、typedef 語句以及 static_assert 斷言
    return 1 + 2 + x;
}

可以看到，display() 函數(shù)的返回值是用 constexpr 修飾的 int 類型值，且該函數(shù)的函數(shù)體中只包含一個return語句。
3)return 返回的表達式必須是常量表達式。
舉個例子：

#include <iostream>
using namespace std;
int num = 3;
constexpr int display(int x){
    return num + x;
}
int main()
{
    //調用常量表達式函數(shù)
    int a[display(3)] = { 1,2,3,4 };
    return 0;
}

該程序無法通過編譯，編譯器報“display(3) 的結果不是常量”的異常。

常量表達式函數(shù)的返回值必須是常量表達式的原因很簡單，如果想在程序編譯階段獲得某個函數(shù)返回的常量，則該函數(shù)的 return 語句中就不能包含程序運行階段才能確定值的變量。

注意，在常量表達式函數(shù)的 return 語句中，不能包含賦值的操作（例如 return x=1 在常量表達式函數(shù)中不允許的）。另外，用 constexpr 修改函數(shù)時，函數(shù)本身也是支持遞歸的，感興趣的讀者可自行嘗試編碼測試。

4) 函數(shù)在使用之前，必須有對應的定義語句。我們知道，函數(shù)的使用分為“聲明”和“定義”兩部分，普通的函數(shù)調用只需要提前寫好該函數(shù)的聲明部分即可（函數(shù)的定義部分可以放在調用位置之后甚至其它文件中），但常量表達式函數(shù)在使用前，必須要有該函數(shù)的定義。舉個例子：

#include <iostream>
using namespace std;
//普通函數(shù)的聲明
int noconst_dis(int x);
//常量表達式函數(shù)的聲明
constexpr int display(int x);
//常量表達式函數(shù)的定義
constexpr int display(int x){
    return 1 + 2 + x;
}
int main()
{
    //調用常量表達式函數(shù)
    int a[display(3)] = { 1,2,3,4 };
    cout << a[2] << endl;
    //調用普通函數(shù)
    cout << noconst_dis(3) << endl;
    return 0;
}
//普通函數(shù)的定義
int noconst_dis(int x) {
    return 1 + 2 + x;
}

程序執(zhí)行結果為：

3
6

讀者可自行將 display() 常量表達式函數(shù)的定義調整到 main() 函數(shù)之后，查看編譯器的報錯信息?？梢钥吹?，普通函數(shù)在調用時，只需要保證調用位置之前有相應的聲明即可；而常量表達式函數(shù)則不同，調用位置之前必須要有該函數(shù)的定義，否則會導致程序編譯失敗。

constexpr修飾類的構造函數(shù)

對于 C++ 內置類型的數(shù)據(jù)，可以直接用 constexpr 修飾，但如果是自定義的數(shù)據(jù)類型（用 struct 或者 class 實現(xiàn)），直接用 constexpr 修飾是不行的。

舉個例子：

#include <iostream>
using namespace std;
//自定義類型的定義
constexpr struct myType {
    const char* name;
    int age;
    //其它結構體成員
};
int main()
{
    constexpr struct myType mt{ "zhangsan", 10 };
    cout << mt.name << " " << mt.age << endl;
    return 0;
}

此程序是無法通過編譯的，編譯器會拋出“constexpr不能修飾自定義類型”的異常。

當我們想自定義一個可產生常量的類型時，正確的做法是在該類型的內部添加一個常量構造函數(shù)。例如，修改上面的錯誤示例如下：

#include <iostream>
using namespace std;
//自定義類型的定義
struct myType {
    constexpr myType(char *name,int age):name(name),age(age){};
    const char* name;
    int age;
    //其它結構體成員
};
int main()
{
    constexpr struct myType mt { "zhangsan", 10 };
    cout << mt.name << " " << mt.age << endl;
    return 0;
}

程序執(zhí)行結果為：

zhangsan 10

可以看到，在 myType 結構體中自定義有一個構造函數(shù)，借助此函數(shù)，用 constexpr 修飾的 myType 類型的mt常量即可通過編譯。

注意，constexpr 修飾類的構造函數(shù)時，要求該構造函數(shù)的函數(shù)體必須為空，且采用初始化列表的方式為各個成員賦值時，必須使用常量表達式。

前面提到，constexpr 可用于修飾函數(shù)，而類中的成員方法完全可以看做是“位于類這個命名空間中的函數(shù)”，所以 constexpr 也可以修飾類中的成員函數(shù)，只不過此函數(shù)必須滿足前面提到的 4 個條件。

舉個例子：

#include <iostream>
using namespace std;
//自定義類型的定義
class myType {
public:
    constexpr myType(const char *name,int age):name(name),age(age){};
    constexpr const char * getname(){
        return name;
    }
    constexpr int getage(){
        return age;
    }
private:
    const char* name;
    int age;
    //其它結構體成員
};
int main()
{
    constexpr struct myType mt { "zhangsan", 10 };
    constexpr const char * name = mt.getname();
    constexpr int age = mt.getage();
    cout << name << " " << age << endl;
    return 0;
}

程序執(zhí)行結果為：

zhangsan 10

注意，C++11 標準中，不支持用 constexpr 修飾帶有 virtual 的成員方法。

constexpr修飾模板函數(shù)

C++11 語法中，constexpr 可以修飾模板函數(shù)，但由于模板中類型的不確定性，因此模板函數(shù)實例化后的函數(shù)是否符合常量表達式函數(shù)的要求也是不確定的。

針對這種情況下，C++11 標準規(guī)定，如果 constexpr 修飾的模板函數(shù)實例化結果不滿足常量表達式函數(shù)的要求，則 constexpr 會被自動忽略，即該函數(shù)就等同于一個普通函數(shù)。

舉個例子：

#include <iostream>
using namespace std;
//自定義類型的定義
struct myType {
    const char* name;
    int age;
    //其它結構體成員
};
//模板函數(shù)
template<typename T>
constexpr T dispaly(T t){
    return t;
}
int main()
{
    struct myType stu{"zhangsan",10};
    //普通函數(shù)
    struct myType ret = dispaly(stu);
    cout << ret.name << " " << ret.age << endl;
    //常量表達式函數(shù)
    constexpr int ret1 = dispaly(10);
    cout << ret1 << endl;
    return 0;
}

程序執(zhí)行結果為：

zhangsan 10
10

可以看到，示例程序中定義了一個模板函數(shù) display()，但由于其返回值類型未定，因此在實例化之前無法判斷其是否符合常量表達式函數(shù)的要求.

const與constexpr區(qū)別：

一些讀者在學習過程中，經常會把 const 和 constexpr 搞混，不知道什么時候用 const，什么時候用 constexpr。本節(jié)就帶領大家對 const 和 constexpr 做系統(tǒng)地區(qū)分。

有關 constexpr 的功能和用法，您可以閱讀《C++11 constexpr》一節(jié)。

我們知道，constexpr 是 C++ 11 標準新添加的關鍵字，在此之前（C++ 98/03標準）只有const關鍵字，其在實際使用中經常會表現(xiàn)出兩種不同的語義。舉個例子：

#include <iostream>
#include <array>
using namespace std;
void dis_1(const int x){
    //錯誤，x是只讀的變量
    array <int,x> myarr{1,2,3,4,5};
    cout << myarr[1] << endl;
}
void dis_2(){
    const int x = 5;
    array <int,x> myarr{1,2,3,4,5};
    cout << myarr[1] << endl;
}
int main()
{
   dis_1(5);
   dis_2();
}

可以看到，dis_1() 和 dis_2() 函數(shù)中都包含一個 const int x，但 dis_1() 函數(shù)中的 x 無法完成初始化 array 容器的任務，而 dis_2() 函數(shù)中的 x 卻可以。

這是因為，dis_1() 函數(shù)中的“const int x”只是想強調 x 是一個只讀的變量，其本質仍為變量，無法用來初始化 array 容器；而 dis_2() 函數(shù)中的“const int x”，表明 x 是一個只讀變量的同時，x 還是一個值為 5 的常量，所以可以用來初始化array容器。

C++ 11標準中，為了解決const關鍵字的雙重語義問題，保留了const表示“只讀”的語義，而將“常量”的語義劃分給了新添加的 constexpr 關鍵字。因此 C++11 標準中，建議將const和 constexpr 的功能區(qū)分開，即凡是表達“只讀”語義的場景都使用 const，表達“常量”語義的場景都使用 constexpr。

在上面的實例程序中，dis_2() 函數(shù)中使用 const int x 是不規(guī)范的，應使用 constexpr 關鍵字。

有讀者可能會問，“只讀”不就意味著其不能被修改嗎？答案是否定的，“只讀”和“不允許被修改”之間并沒有必然的聯(lián)系，舉個例子：

#include <iostream>
using namespace std;
int main()
{
    int a = 10;
    const int & con_b = a;
    cout << con_b << endl;
    a = 20;
    cout << con_b << endl;
}

程序執(zhí)行結果為：

10
20

可以看到，程序中用 const 修飾了 con_b 變量，表示該變量“只讀”，即無法通過變量自身去修改自己的值。但這并不意味著 con_b 的值不能借助其它變量間接改變，通過改變 a 的值就可以使con_b的值發(fā)生變化。
在大部分實際場景中，const 和 constexpr 是可以混用的，例如：

const int a = 5 + 4;
constexpr int a = 5 + 4;

它們是完全等價的，都可以在程序的編譯階段計算出結果。但在某些場景中，必須明確使用 constexpr，例如：

#include <iostream>
#include <array>
using namespace std;
constexpr int sqr1(int arg){
    return arg*arg;
}
const int sqr2(int arg){
    return arg*arg;
}
int main()
{
    array<int,sqr1(10)> mylist1;//可以，因為sqr1時constexpr函數(shù)
    array<int,sqr2(10)> mylist1;//不可以，因為sqr2不是constexpr函數(shù)
    return 0;
}

其中，因為 sqr2() 函數(shù)的返回值僅有const修飾，而沒有用更明確的 constexpr 修飾，導致其無法用于初始化 array 容器（只有常量才能初始化array容器）。

總的來說在 C++ 11 標準中，const 用于為修飾的變量添加“只讀”屬性；而 constexpr 關鍵字則用于指明其后是一個常量（或者常量表達式），編譯器在編譯程序時可以順帶將其結果計算出來，而無需等到程序運行階段，這樣的優(yōu)化極大地提高了程序的執(zhí)行效率。

到此這篇關于C++ const與constexpr區(qū)別小結的文章就介紹到這了,更多相關C++ const constexpr內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論