第8课 常量表达式(constexpr)

#include <iostream>
#include <array>

using namespace std;

int g_count = 0;

int normalfunc(int x)
{
    return x;
}

//constexpr函数（即可当编译期常量表达式函数，也可以当作普通函数使用）
constexpr int func1(int x)
{
    return x + 2;
}

constexpr void func2(){} //普通函数，constexpr必须有非void的返回值类型
constexpr int func3();   //注意这里只声明，定义在main()函数之后
//constexpr int func4()    //编译失败
//{
//    int x = normalfunc(2); //调用了非constexpr函数！
//    return x;
//}

//幂函数：用于计算base的exp次幂
constexpr int pow(int base, int exp)
{
    //版本1：递归（一条语句）----> C++11要求有且只有一条语句（即return语句)。
    //return (exp == 0) ? 1 : base * pow(base, exp - 1);

    //版本2：非递归（多条语句） --->C++14以上
    auto ret = 1;
    for (int i = 0; i < exp; ++i) {
        ret *= base;
    }

    return ret;
}

int main()
{
    //1.1 修饰变量时
    int x = 0;                 //非constexpr变量
    const int y = 0;
    constexpr int a = 2;       //a为编译期常量
    constexpr int b = a + 4;   //b为编译期常量
    constexpr int c = y + 1;   //c为编译期常量，y直接取自符号表，而不是来自内存值。

    //constexpr auto m = x;    //error，因为x不是常量
    const auto n = x;          //ok, d为x的副本

    constexpr auto N = 10;
    //std::array<int, n> arr1; //error, n不是编译期常量
    std::array<int, N> arr2;   //ok, N为编译期常量
    std::array<int, c> arr3;   //ok, c为编译期常量  

    constexpr auto exp = 5;
    std::array<int, pow(3, exp)> arr4;   //ok! pow是constexpr函数
    //std::array<int, pow(3, x)> arr5;   //error! x为运行期变量，从而导致pow返回值为运行期的值

    //1.2 constexpr修饰指针时，表示指针本身不可修改！！！（constexpr只能放在*的左侧）
    constexpr int* ptr2 = &g_count; //ok，全局变量，编译期地址可确定
    //ptr2 = nullptr;     //注意，与const不同，这里表示ptr2是常量。
    *ptr2 = 100;

    //constexpr int* ptr1 = &x;  //error，因为x在栈上分配，在编译期不能确定其地址。

    //1.3 修饰函数时
    int var1 = func3();               //ok！ func3先声明，使用后定义。
    //constexpr int var2 = func3();   //error，在调用函数前，func3必须定义好了（不能只看到声明）。

    constexpr int c1 = func1(N);      //constexpr语境： 返回值赋值constexpr变量，是constexpr函数（实参也为constexpr）。
    int c2 = func1(x);                //非constexpr语境：func1用于返回值赋值给普通变量时，当作普通函数使用！
    int c3 = func1(N);                //非constexpr语境：func1用于返回值赋值给普通变量时，当作普通函数使用！

    return 0;
}

constexpr int func3() //声明放在main之前，这里是定义！
{
    return 0;
}

#include <iostream>
using namespace std;

//1. constexpr构造函数和成员函数
class Point
{
    double x, y;
public:
    //常量表达式构造函数
    constexpr Point(double x=0, double y=0) noexcept : x(x),y(y){}

    //成员函数（注意：constexpr不允许用于修饰virtual函数）
    constexpr double getX() const noexcept { return x;} //constexpr函数，在C++11中默认为const函数。但C++14中取消了，这里加const
    constexpr double getY() const noexcept { return y;}

    //以下两个函数在C++11中无法声明为constexpr（C++14可以！），原因如下：
    //1.C++11中被声明为constexpr成员函数会自动设为const函数，而这两个函数需要更改成员变量的值，这与const成员函数
    //却不允许需改成员的值，会产生编译错误。C++14中constexpr函数不再默认为const函数，因此可以修改成员变量。
    //2. C++11中constexpr函数不能返回void型，但C++14中不再限制。
    constexpr void setX(double newX) noexcept { x = newX; } //C++11中须去掉constexpr;
    constexpr void setY(double newY) noexcept { y = newY; }
};

//计算中点坐标
constexpr Point midpoint(const Point& p1, const Point& p2) noexcept
{
    //p1和p2均为const对象，会调用const版本的getX()和getY()
    return { (p1.getX() + p2.getX()) / 2, (p1.getY() + p2.getY()) / 2 };
}

//返回p相对于原点的中心对称点（C++14）
constexpr Point reflection(const Point& p) noexcept
{
    Point ret;
    ret.setX(-p.getX());
    ret.setY(-p.getY());
    return ret;
}

//2. 函数模板：（constexpr元编程）
//函数是否为constexpr函数，编译期未知。取决于传入的实参t是否为constexpr变量/对象
template<typename T>
constexpr T func(T t) 
{
    return t;
}

struct NotLiteral  
{
    int i;
    NotLiteral():i(5){} //注意：构造函数不是constexpr类型！
};

//3.constexpr类型的递归函数
//3.1 求斐波那契数
constexpr int Fib(int n)
{
    return (n == 1) ? 1 : ((n == 2) ? 1 : Fib(n-1) + Fib(n -2));
}

//3.2 模板递归（模板元编程）
template<long N>
struct Fibonacci
{
    static const long val = Fibonacci<N - 1>::val + Fibonacci<N - 2>::val;
};

//特化
template<> struct Fibonacci<2> { static const long val = 1; };
template<> struct Fibonacci<1> { static const long val = 1; };
template<> struct Fibonacci<0> { static const long val = 0; };

void printArray(int a[], int len)
{
    cout << "Fibonacci： ";
    for (int i=0; i<len; ++i)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main()
{
    //1. 用constexpr定义自定义类的对象（要求该类具有constexpr构造函数）
    constexpr Point p1(9.4, 27.7);    //ok, p1为编译期常量
    constexpr Point p2{ 28.8, 5.3 };  //ok，同上
    //1.1求中点
    constexpr auto mid = midpoint(p1, p2);  //mid为编译期常量，mid.getX()也是编译期常量！！！
    //1.2求关于原点的对称点
    constexpr auto reflectedMid = reflection(mid);

    //2. constexpr型的函数模板
    NotLiteral n1;             //非constexpr对象
    NotLiteral n2 = func(n1);  //传入实参为非constexpr对象，func成为普通函数！
    //constexpr NotLiteral n3 = func(n1); //error，由于NotLiteral的构造函数不是constexpr类型，
                                          //不能用constexpr定义该类型的constexpr的对象！！！
    constexpr int a = func(1); //ok，1为constexpr对象

    //3. constexpr类型递归函数
    int fib1[]{ Fib(11), Fib(12), Fib(13), Fib(14) };
    printArray(fib1, 4);

    int fib2[] = { Fibonacci<11>::val, Fibonacci<12>::val, Fibonacci<13>::val, Fibonacci<14>::val };
    printArray(fib1, 4);

    return 0;
}
/*输出结果
Fibonacci： 89 144 233 377
Fibonacci： 89 144 233 377
*/