C++11-20 常量表達式的使用

更新時間：2021年10月29日 16:05:28 作者：oowgsoo

本文主要介紹了C++11-20常量表達式，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下

C++98時代

C++98編譯器對int常量情有獨鐘，因為這是少數(shù)它能直接識別的東西。因為這個有限的能力，編譯器就能夠預先判定數(shù)組的大小了：

  TEST_METHOD(TestConstVar)
  {
   //int n = 3;
   const int n = 3;
   int a[n] = { 0 };
   Assert::AreEqual(size_t(3), _countof(a));
 
   const int m = n * 3;
   int b[m] = { 0 };
   Assert::AreEqual(size_t(9), _countof(b));
  }

并由此還引入了一個“常量折疊”的概念，即編譯器會自動將所有const int變量的引用全部替換為常量：

  TEST_METHOD(TestConstVarFold)
  {
   const int a = 10;
   int b = 2 * a;
   int* p = (int*)&a;
   *p = 100;
 
   // 沒有常量折疊？
   Assert::AreEqual(100, a);
   Assert::AreEqual(20, b);
   Assert::AreEqual(100, *p);
  }

我們不必糾結(jié)于這里的a到底是10還是100，這完全取決于編譯器的實現(xiàn)。而實際工作中誰要寫出這樣的代碼，直接拖出去打死了事。

C++11時代

constexpr值

C++98編譯器對常量的那點有限智商實在是令人著急。C++11干脆就引入了一個新的關(guān)鍵字constexpr，以便讓編譯器可以做更多的事情。

  TEST_METHOD(TestConstExprVar)
  {
   constexpr int n = 3;
   int a[n] = { 0 };
   Assert::AreEqual(size_t(3), _countof(a));
 
   constexpr int m = n * 3;
   int b[m] = { 0 };
   Assert::AreEqual(size_t(9), _countof(b));
  }

constexpr看起來和const沒啥區(qū)別嘛？但實際上，你可以把constexpr理解為真正的編譯期常量，而const實際上是運行期常量，以前之所以能在編譯期起作用完全是不得已的救場客串行為。

constexpr函數(shù)

當然，如果constexpr僅僅有這點作用，那是絕對不會被作為新的關(guān)鍵字引入的。更為重要的是，既然編譯期已經(jīng)知道constexpr就代表編譯期可以運行的東西，那么它為什么不可以修飾函數(shù)？讓只能在運行期調(diào)用的函數(shù)可以在編譯期起作用：

  static constexpr int size()
  {
   return 3;
  }
 
  static constexpr int sqrt(int n)
  {
   return n * n;
  }
 
  static constexpr int sum(int n)
  {
   return n > 0 ? n + sum(n - 1) : 0;
  }
  TEST_METHOD(TestConstExprFunc)
  {
   int a[size()] = { 0 };
   Assert::AreEqual(size_t(3), _countof(a));
 
   int b[sqrt(3)] = { 0 };
   Assert::AreEqual(size_t(9), _countof(b));
 
   int c[sum(3)] = { 0 };
   Assert::AreEqual(size_t(6), _countof(c));
  }

當然，在C++11階段，這種constexpr函數(shù)限制很多：

函數(shù)必須返回一個值，不能是void
函數(shù)體只能有一條語句return
函數(shù)調(diào)用前必須被定義
函數(shù)必須用constexpr聲明

浮點型常量

盡管有些限制，但是畢竟也是個函數(shù)，所以要實現(xiàn)C++98編譯期頭疼的浮點型常量也變得很簡單了：

  static constexpr double pi()
  {
   return 3.1415926535897;
  }
 
  TEST_METHOD(TestConstExprDouble)
  {
   int a[(int)pi()] = { 0 };
   Assert::AreEqual(size_t(3), _countof(a));
  }

constexpr類

C++的一大特點就是面向?qū)ο蟮模热籧onstexpr可以修飾函數(shù)了，那為什么不能修飾成員函數(shù)呢？

  class N
  {
  private:
   int m_n;
 
  public:
   constexpr N(int n = 0)
    :m_n(n)
   {
   }
 
   constexpr int getN() const
   {
    return m_n;
   }
  };
 
  TEST_METHOD(TestConstExprConstruct)
  {
   constexpr N n(3);
   int a[n.getN()] = { 0 };
   Assert::AreEqual(size_t(3), _countof(a));
  }

C++14時代

C++11的constexpr很好，很強大。但是最為令人詬病的就是constexpr函數(shù)限制實在是太多了。于是C++14開始為其松綁：

 static constexpr int abs(int n)
  {
   if (n > 0)
   {
    return n;
   }
   else
   {
    return -n;
   }
  }
 
  static constexpr int sumFor(int n)
  {
   int s = 0;
   for (int i = 1; i <= n; i++)
   {
    s += i;
   }
 
   return s;
  }
 
  static constexpr int next(int n)
  {
   return ++n;
  }
 
  TEST_METHOD(TestConstExprFunc14)
  {
   int a[abs(-3)] = { 0 };
   Assert::AreEqual(size_t(3), _countof(a));
 
   int b[sumFor(3)] = { 0 };
   Assert::AreEqual(size_t(6), _countof(b));
 
   int c[next(3)] = { 0 };
   Assert::AreEqual(size_t(4), _countof(c));
  }

基本上，這基本上就是真正的函數(shù)了，不再限制為只能一行代碼了：

可以使用分支控制語句了
可以使用循環(huán)控制語句了
可以修改生命周期和常量表達式相同的變量了，所以連++n之類的表達式也可以支持了

甚至連函數(shù)必須返回一個值，不能是void的限制也被取消了，所以可以寫setN之類的函數(shù)了，不過這個不太常用。

C++17時代

C++17進一步把constexpr的范圍擴展到了lambda表達式：

  static constexpr int lambda(int n)
  {
   return [](int n) { return ++n; }(n);
  }
 
  TEST_METHOD(TestConstExprLambda)
  {
   int a[lambda(3)] = { 0 };
   Assert::AreEqual(size_t(4), _countof(a));
  }

為了讓一個函數(shù)可以適應更多的情況，C++17還把黑手伸向了if語句，引入了所謂的“if constexpr”：

  template<typename T>
  static bool is_same_value(T a, T b)
  {
   if constexpr (std::is_same<T, double>::value)
   {
    if (std::abs(a - b) < 0.0001)
    {
     return true;
    }
    else
    {
     return false;
    }
   }
   else
   {
    return a == b;
   }
  }
  
  TEST_METHOD(TestConstExprIf)
  {
   Assert::AreEqual(false, is_same_value(5.6, 5.11));
   Assert::AreEqual(true, is_same_value(5.6, 5.60000001));
   Assert::AreEqual(true, is_same_value(5, 5));
  }

以前，類似的代碼需要一個模板函數(shù)加上一個特化函數(shù)，現(xiàn)在一個函數(shù)就搞定了，真好。

C++20時代

不出意料，C++20繼續(xù)把黑手伸向更多的地方

constexpr和異常：

  static constexpr int funcTry(int n)
  {
   try
   {
    if (n % 2 == 0)
    {
     return n / 2;
    }
    else
    {
     return n;
    }
   }
   catch (...)
   {
    return 3;
   }
  }
 
  TEST_METHOD(TestConstExprTry)
  {
   int a[funcTry(6)] = { 0 };
   Assert::AreEqual(size_t(3), _countof(a));
 
   int b[funcTry(3)] = { 0 };
   Assert::AreEqual(size_t(3), _countof(b));
  }

constexpr和union：

  union F
  {
   int i;
   double f;
  };
 
  static constexpr int funcUnion(int n)
  {
   F f;
   f.i = 3;
   f.f = 3.14;
 
   return n;
  }
 
  TEST_METHOD(TestConstExprUnion)
  {
   int a[funcUnion(3)] = { 0 };
   Assert::AreEqual(size_t(3), _countof(a));
  }

constexpr和虛函數(shù)

這個有點過分，不知道有多少實際用處，略。

立即函數(shù)

用consteval修飾的函數(shù)，表示在編譯期可以立即執(zhí)行，如果執(zhí)行不了就報錯。

  static consteval int sqr(int n)
  {
   return n * n;
  }
 
  TEST_METHOD(TestConstEval)
  {
   int a[sqr(3)] = { 0 };
   Assert::AreEqual(size_t(9), _countof(a));
  }

感知常量環(huán)境

這個有點意思，如果可以感知是否是常量環(huán)境，就可以讓一個函數(shù)分別給出編譯期的實現(xiàn)和運行期的實現(xiàn)，其方法是使用std::is_constant_evaluated()：

  static constexpr double power(double b, int n)
  {
   if (std::is_constant_evaluated() && n >= 0)
   {
    double r = 1.0, p = b;
    unsigned u = unsigned(n);
    while (u != 0)
    {
     if (u & 1) r *= p;
     u /= 2;
     p *= p;
    }
 
    return r;
   }
   else
   {
    return std::pow(b, double(n));
   }
  }
 
  TEST_METHOD(TestConstEvaluated)
  {
   constexpr double p = power(3, 2);
   Assert::AreEqual(9.0, p, 0.001);
   int m = 2;
   Assert::AreEqual(9.0, power(3, m), 0.001);
  }