Fibonacci各种玩法
1-基础入门玩法
auto fib(auto n){ if (n == 0) return 0; if (n == 1) return 1; return fib(n-1) + fib(n-2); }
2-metaprogramming,编译期间展开
template<auto N> struct FibT; template<> struct FibT<0>{ static constexpr int result = 0; }; template<> struct FibT<1>{ static constexpr int result = 1; }; template<auto N> struct FibT{ static constexpr int result = FibT<N-1>::result + FibT<N-2>::result; }; template<auto N> inline constexpr auto fib_v = FibT<N>::result;
std::cout << fib_v<3> << std::endl;
3，metaprogramming，同样编译期间计算展开
template<auto N> struct FibT{ static auto constexpr compute(){ auto result = 0; if constexpr (N==0) result = 0; else if constexpr (N==1) result = 1; else result = FibT<N-1>::compute() + FibT<N-2>::compute(); return result; } }; template<auto N> inline constexpr auto fib_v = FibT<N>::compute();
std::cout << fib_v<3> << std::endl;
4，运行期间展开的有个问题，由于是递归，会再递归的 node上重复计算
比如fib(5)，第一次递归，fib(4)，fib(3)，而计算fib(4)也计算了fib(3)
#include <iostream> #include <vector> static std::vector<int > cache{0,1}; auto fib(auto n){ if(cache.size() > n){ return cache[n]; } else{ auto var = fib(n-1) + fib(n-2); cache.emplace_back(var); return var; } } int main() { std::cout << fib(5) << std::endl; std::cout << fib(4) << std::endl;// cached std::cout << "container:" << std::endl; for(auto &&v : cache){ std::cout << v << " " ; } std::cout << std::endl; return 0; }
输出：
5 3 container: 0 1 1 2 3 5
5，对任意函数的结果cache
template<typename ResultT, typename ... Args> auto make_memoized(ResultT (*func)(Args...)) { using TupleArgsT = std::tuple< Args...>; std::map< TupleArgsT, ResultT> cache;// unordered map can not use in this place return [func, cache](Args... args) mutable -> ResultT { auto args_tuple= std::make_tuple( args...); auto iter = cache.find(args_tuple); if(iter == cache.end()){ auto result = func( args...); cache[args_tuple] = result; return result; } else{ return cache[args_tuple]; } return ResultT(); }; }
调用方法：
auto fib_mem = make_memoized(fib);
fib_mem(fib_n);
fib_mem(fib_n) ;
fib_mem(fib_n) ;
第一次会慢点，但是第二次调用会非常快，但是这个也有缺陷，
--- 函数结果被cache，函数本身的过程没cache
--- 适合调用相同的函数多次
对 N=40 性能的测试：
#include <iostream> #include <unordered_map> #include <tuple> #include <functional> #include <map> #include <chrono> class Timer{ private: std::chrono::steady_clock::time_point last; public: Timer(): last{std::chrono::steady_clock::now()}{ } void reset(){ last = std::chrono::steady_clock::now(); } void printDiff(const std::string &msg = "time diff: "){ auto now{std::chrono::steady_clock::now()}; std::chrono::duration<double, std::milli> diff{now-last}; std::cout << msg << diff.count() << std::endl; last = std::chrono::steady_clock::now(); } }; int fib(int n){ if(n==0 || n==1) return n; else return fib(n-1)+fib(n-2); } template<typename ResultT, typename ... Args> auto make_memoized(ResultT (*func)(Args...)) { using TupleArgsT = std::tuple< Args...>; std::map< TupleArgsT, ResultT> cache;// unordered map can not use in this place return [func, cache](Args... args) mutable -> ResultT { auto args_tuple= std::make_tuple( args...); auto iter = cache.find(args_tuple); if(iter == cache.end()){ auto result = func( args...); cache[args_tuple] = result; return result; } else{ return cache[args_tuple]; } return ResultT(); }; } template<auto N> struct FibT; template<> struct FibT<0>{ static constexpr int result = 0; }; template<> struct FibT<1>{ static constexpr int result = 1; }; template<auto N> struct FibT{ static constexpr int result = FibT<N-1>::result + FibT<N-2>::result; }; template<auto N> inline constexpr auto fib_v = FibT<N>::result; int main() { constexpr auto fib_n = 40; Timer t; fib(fib_n) ; fib(fib_n) ; fib(fib_n) ; t.printDiff("fib() time: "); t.reset(); auto fib_mem = make_memoized(fib); fib_mem(fib_n); fib_mem(fib_n) ; fib_mem(fib_n) ; t.printDiff("fib_mem() time: "); t.reset(); fib_v<fib_n>; fib_v<fib_n>; fib_v<fib_n>; t.printDiff("metaprogramming time: "); t.reset(); return 0; }
上面代码是对每种函数调用3次结果：
fib() time: 3202.85
fib_mem() time: 1066.87
metaprogramming time: 0.000604
如果调用一次：
fib() time: 1056.4
fib_mem() time: 1056.15
metaprogramming time: 0.000681
编译器的递归也有限制，比如将fib_n = 100时候：
Scanning dependencies of target fib_mem [ 50%] Building CXX object CMakeFiles/fib_mem.dir/main.cpp.o /home/father/dev/cpp/fib_mem/main.cpp: In instantiation of ‘constexpr const int FibT<47>::result’: /home/father/dev/cpp/fib_mem/main.cpp:76:46: recursively required from ‘constexpr const int FibT<99>::result’ /home/father/dev/cpp/fib_mem/main.cpp:76:46: required from ‘constexpr const int FibT<100>::result’ /home/father/dev/cpp/fib_mem/main.cpp:79:40: required from ‘constexpr const auto fib_v<100>’ /home/father/dev/cpp/fib_mem/main.cpp:101:5: required from here /home/father/dev/cpp/fib_mem/main.cpp:76:53: warning: integer overflow in expression of type ‘int’ results in ‘-1323752223’ [-Woverflow] 76 | static constexpr int result = FibT<N-1>::result + FibT<N-2>::result; | ~~~~~~~^~~~~~~~~~~~~~~~~~~ /home/father/dev/cpp/fib_mem/main.cpp:76:26: error: overflow in constant expression [-fpermissive] 76 | static constexpr int result = FibT<N-1>::result + FibT<N-2>::result; | ^~~~~~ /home/father/dev/cpp/fib_mem/main.cpp:76:26: error: overflow in constant expression [-fpermissive] make[2]: *** [CMakeFiles/fib_mem.dir/build.make:72: CMakeFiles/fib_mem.dir/main.cpp.o] Error 1 make[1]: *** [CMakeFiles/Makefile2:83: CMakeFiles/fib_mem.dir/all] Error 2 make: *** [Makefile:91: all] Error 2
REF:
Functional Programming In C++ --- Ivan
