C++11-20 常量表达式的使用
C++98时代
C++98编译器对int常量情有独钟，因为这是少数它能直接识别的东西。因为这个有限的能力，编译器就能够预先判定数组的大小了：
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);
}
我们不必纠结于这里的a到底是10还是100，这完全取决于编译器的实现。而实际工作中谁要写出这样的代码，直接拖出去打死了事。
C++11时代
constexpr值
C++98编译器对常量的那点有限智商实在是令人着急。C++11干脆就引入了一个新的关键字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没啥区别嘛？但实际上，你可以把constexpr理解为真正的编译期常量，而const实际上是运行期常量，以前之所以能在编译期起作用完全是不得已的救场客串行为。
constexpr函数
当然，如果constexpr仅仅有这点作用，那是绝对不会被作为新的关键字引入的。更为重要的是，既然编译期已经知道constexpr就代表编译期可以运行的东西，那么它为什么不可以修饰函数？让只能在运行期调用的函数可以在编译期起作用：
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函数限制很多：
- 函数必须返回一个值，不能是void
- 函数体只能有一条语句return
- 函数调用前必须被定义
- 函数必须用constexpr声明
浮点型常量
尽管有些限制，但是毕竟也是个函数，所以要实现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++的一大特点就是面向对象的，既然constexpr可以修饰函数了，那为什么不能修饰成员函数呢？
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函数限制实在是太多了。于是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));
}
基本上，这基本上就是真正的函数了，不再限制为只能一行代码了：
- 可以使用分支控制语句了
- 可以使用循环控制语句了
- 可以修改生命周期和常量表达式相同的变量了，所以连++n之类的表达式也可以支持了
甚至连函数必须返回一个值，不能是void的限制也被取消了，所以可以写setN之类的函数了，不过这个不太常用。
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));
}
为了让一个函数可以适应更多的情况，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));
}
以前，类似的代码需要一个模板函数加上一个特化函数，现在一个函数就搞定了，真好。
C++20时代
不出意料，C++20继续把黑手伸向更多的地方
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和虚函数
这个有点过分，不知道有多少实际用处，略。
立即函数
用consteval修饰的函数，表示在编译期可以立即执行，如果执行不了就报错。
static consteval int sqr(int n)
{
return n * n;
}
TEST_METHOD(TestConstEval)
{
int a[sqr(3)] = { 0 };
Assert::AreEqual(size_t(9), _countof(a));
}
感知常量环境
这个有点意思，如果可以感知是否是常量环境，就可以让一个函数分别给出编译期的实现和运行期的实现，其方法是使用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);
}
参考资料
《现代C++语言核心特性解析》
到此这篇关于C++11-20 常量表达式的使用的文章就介绍到这了,更多相关C++ 常量表达式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
这篇文章主要给大家介绍了关于如何为Qt视图中的文字实现彩虹渐变效果的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者使用Qt具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧2019-03-03
这篇文章主要介绍了C语言数据结构之图的遍历实例详解的相关资料,需要的朋友可以参考下2017-07-07
工厂方法模式是一个创建型设计模式,通过定义一个创建对象的接口，让其子类决定实例化哪一个工厂类,这篇文章主要给大家介绍了关于C++设计模式之工厂方法模式的实现及优缺点,需要的朋友可以参考下2021-06-06
下面小编就为大家带来一篇浅谈使用Rapidxml 库遇到的问题和分析过程(分享)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧2017-05-05
这篇文章主要介绍了C++编程中类模板的三种特化,需要的朋友可以参考下2016-01-01
这篇文章主要为大家详细介绍了如何利用C++语言实现日期类(Date)，可以实现确定某年某月有多少天、打印日期等功能，感兴趣的可以了解一下2022-07-07
这篇文章主要为大家详细介绍了如何利用C++实现中缀转后缀的问题，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2022-09-09
这篇文章主要介绍了C++ Boost Graph算法，我门尝试使用Boost.Graph库来运行Goldberg的最大流算法。 Boost.Graph将其称为push_relabel_max_flow2022-10-10
在现代社会中,计算器已经进入了每一个家庭,人们在生活和学习中经常需要使用到计算器,下面这篇文章主要给大家介绍了关于基于C++实现日期计算器的相关资料,需要的朋友可以参考下2022-06-06
这篇文章主要介绍了C++二分查找(折半查找)算法,结合实例形式详细分析了二分查找算法的原理、思想、实现方法与相关操作技巧,需要的朋友可以参考下2017-05-05
最新评论