0xe3aad

0xe3aad

从模板元编程到constexpr(C++)

模板元编程#

#include <cstdint>

template <uint64_t N> struct Fact {
    enum { Value = N * Fact<N - 1>::Value };
};

template <> struct Fact<1> {
    enum { Value = 1 };
};

template <uint64_t N> struct Fib {
    enum { Value = Fib<N - 1>::Value + Fib<N - 2>::Value };
};

template <> struct Fib<1> {
    enum { Value = 1 };
};

template <> struct Fib<2> {
    enum { Value = 2 };
};

template <uint64_t base, uint64_t exp> struct Pow {
    enum { Value = base * Pow<base, exp - 1>::Value };
};

template <uint64_t base> struct Pow<base, 1> {
    enum { Value = base };
};

int main() {
    auto val1 = Fact<10>::Value;
    auto val2 = Fib<20>::Value;
    auto val3 = Pow<2, 10>::Value;
    return 0;
}

如上代码片段我们是用模板实现了在编译期的计算(C++11起支持)。

constexpr#

C++14开始,支持使用consrexpr来修饰函数,这样如果我们给这个函数传入常量,那么将会在编译器计算;如果传入变量,只能在运行期计算。这一点可以从生成的汇编代码看出。

#include <cstdint>

constexpr auto fact(uint64_t n) {
    if (n == 1) {
        return n;
    }
    return fact(n-1) * n;
}

int main() {
    constexpr auto val = fact(10);
    return 0;
}
fact(int):
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR [rbp-4], edi
        cmp     DWORD PTR [rbp-4], 1
        jne     .L2
        mov     eax, DWORD PTR [rbp-4]
        jmp     .L3
.L2:
        mov     eax, DWORD PTR [rbp-4]
        sub     eax, 1
        mov     edi, eax
        call    fact(int)
        imul    eax, DWORD PTR [rbp-4]
.L3:
        leave
        ret
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     DWORD PTR [rbp-20], edi
        mov     QWORD PTR [rbp-32], rsi
        mov     DWORD PTR [rbp-4], 3628800
        mov     eax, DWORD PTR [rbp-20]
        mov     edi, eax
        call    fact(int)
        mov     DWORD PTR [rbp-8], eax
        mov     eax, 0
        leave
        ret

constexpr 与模板元编程的比较#

#include <cstdint>

constexpr auto fib(uint64_t n) {
    if (n <= 1) {
        return 1;
    }
    return fib(n-1) + fib(n-2);
}

int main(int argc, char *argv[]) {
    constexpr auto val = fib(40);
    return 0;
}

如果我们采用constexpr这种写法的话,编译器会报错,这是因为这个函数重复计算比较多。

而我们使用下面模板元编程这种写法的话就可以,这是因为编译器会对其进行记忆化,省去了重复的计算。

未来编译器可能会支持constexpr函数的记忆化。

template<uint64_t N> struct Fib {
    enum { Value = Fib<N-1>::Value + Fib<N-2>::Value };
};

template<> struct Fib<1> {
    enum { Value = 1 };
};

template<> struct Fib<0> {
    enum { Value = 1};
};

int main(int argc, char *argv[]) {
    auto val = Fib<40>::Value;
    return 0;
}

constexpr if#

C++17开始支持constexpr if,这意味着我们可以简化模板元编程的写法,省去了实例化初始值。这样的话即使比较复杂的计算也能够支持,因为模板元编程有记忆化。

#include <cstdint>

template<uint64_t N> struct Fib {
    static constexpr uint64_t Value = []{
        if constexpr (N <= 1) {
            return 1;
        } else {
            return Fib<N-1>::Value + Fib<N-2>::Value;
        }
    }();
};

int main(int argc, char *argv[]) {
    constexpr auto val = Fib<40>::Value;
    return 0;
}
加载中...
此文章数据所有权由区块链加密技术和智能合约保障仅归创作者所有。