cpp-cheat/cpp/constexpr.cpp

/*
# constexpr

    C++11 keyword.

    `const` variables can either be compile time constants or not.

    The compiler is able to decide that at compile time, but it may be hard for human
    readers to predict if a given variable is a constexpr of not.

    Using the constexpr keyword however makes the compiler ensure that the variables are constant expressions,
    so that the compile time constantness is more explicit.

    Two uses:

    -   variables

        Means that the value of an expression is known at compile time.

    -   functions

        The value returned by constexpr functions is known to be a compile time constant.

        The compiler enforces this by inspecting the function.
*/

#include "common.hpp"

#if __cplusplus >= 201103L
int not_constexpr_func() {
    return 1;
}

constexpr int constexpr_func(int i) {
    return i;
}

/*
C++11 specifies that the body of a constexrp function must contain a single return statement.

Otherwise, it would be too much work for the compiler to do.

http://stackoverflow.com/questions/3226211/why-is-it-ill-formed-to-have-multi-line-constexpr-functions

C++ 14 lifts it.

constexpr functions have several restrictions: in broad terms, they cannot have side effects:
https://stackoverflow.com/questions/5112305/why-not-to-declare-a-function-constexpr
which is cool, feels like functional pure functions.
*/
#if __cplusplus >= 201402L
constexpr int constexpr_func_multi_statement(int i) {
    // ERROR: cannot have uninitialized vars.
    //int j;
    // ERROR: cannot call non constexpr functions
    //std::time(NULL);
    return i;
}
#endif

class MyClass {
    public:
        MyClass() : i(1) {}
        constexpr MyClass(int i) : i(i) {}
        // ERROR: Nah, no overload.
        //MyClass(int i) : i(i) {}
        int i;
        static int member;
        constexpr int f(int j) const { return this->i + j; }
        constexpr int noThis(int j) const { return j + 1; }
        int nonConst() const { return std::time(NULL); }
        // ERROR: constexpr data must be static, or this wouldn't make much sense / be useful, right?
        //constexpr int nonStaticConstexpr;
};

constexpr int ConstexprFactorial(int n) {
    return (n == 1) ? 1 : n * ConstexprFactorial(n - 1);
}

/*
ERROR: the compiler ensures that the function return is constexpr,
so this does not compile.
*/
/*
int constexpr constexpr_func_bad(){
    return std::time();
}
*/
#endif

int main() {
#if __cplusplus >= 201103L
    // OK: built-in operators that take constexprs return a constexpr
    {
        constexpr int i = 1 + 1;
    }

    // OK: it is a constexpr
    {
        constexpr int i = 0;
        constexpr int i2 = i;
    }

    // OK: the compiler sees that a const initialized by a constexpr is also a constexpr.
    {
        const int i = 0;
        constexpr int i2 = i;
    }

    // ERROR: for non built-in operators, only constexpr functions can be used.
    {
        //constexpr int i = not_constexpr_func();
    }

    // constexpr functions only work if all their arguments are constexprs.
    {
        { constexpr int i = constexpr_func(1); }
        // ERROR
        //{ constexpr int i = constexpr_func(std::time(NULL)); }
    }

    // constexpr object
    {
        constexpr MyClass myClass(1);
        MyClass myClassNonConst;

        // ERROR: not using constexpr constructor on constexpr object.
        //{ constexpr MyClass myClass; }

        // Fine with non constexpr constructor.

        // Now we can use members further constexpr chains.
        { constexpr int i = myClass.i; }
        // ERROR
        //{ constexpr int i = myClassNonconst.i; }

        // Methods that don't use this don't need the constexpr object.
        { constexpr int i = myClassNonConst.noThis(1); }
        // But if the method uses this, then it needs.
        { constexpr int i = myClass.f(1); }
        // ERROR
        //{ constexpr int i = myClassNonConst.f(1); }

        // Can still call non constexpr methods of the const object.
        { int i = myClass.nonConst(); }
        // ERROR But not initialize constexpre expressions with them.
        //{ constexpr int i = myClass.nonConst(); }
    }

    // Recursive functions can be constexpr, as long as they fit into one line.
    {
        constexpr int i = ConstexprFactorial(3);
        assert(i == 6);
    }

    // ERROR: the compiler sees that this is not a constexpr.
    // Avoid relying on this execept for legacy code: always initialize a constexpr from constexprs!
    {
        const int i = std::time(NULL);
        //constexpr int i2 = i + 1;
    }

    // ERROR: it is not a constexpr
    {
        int i = 0;
        //i = std::time(NULL);
        // We could change i at any time!
        //constexpr int i2 = i + 1;
    }

    // ERROR: constexprs cannot be modified after initialization
    {
        constexpr int i = 0;
        //i = 1;
    }

    // constexpr do have addresses. But likely they will inlined when addresses are never taken.
    {
        constexpr int i = 1;
        constexpr int j = 2;
        const int *ip = &i;
        const int *jp = &j;
        assert(*ip == 1);
        assert(*jp == 2);
        assert(ip != jp);
    }

    // WARN: unitialized constexpr
    {
        //constexpr int i;
    }

    /*
    cannot have constexpr to complex types

    TODO rationale
    */
    {
        //constexpr std::string s = "abc";
    }
#endif
}