如何优雅地利用c++编程从1乘到20？

叼辣条闯世界

昨天在知乎，看到了一个问题：

这就是一个求阶乘的问题，大家刚刚开始学编程的时候应该都写过这样的程序。

一个求阶乘的问题，还能玩出什么样的花儿来？

我在回答区看到了一个非常有趣的回答，给我笑的差点喷饭，一定得分享给大家。

下面是回答正文，答主：小白白。

数学家版本：
（简单利索，深藏功与名）

1. #include <iostream>
   
2. #include <cmath>
   
3. int main()
   
4. {
   
5.     std::cout << std::tgamma(20 + 1) << std::endl;
   
6. }

复制代码

语言学家版本：
（语言学家，你懂得，恨不得把所有语法特性都派上用场）

1. #include <iostream>
   
2. #include <utility>
   
3. 
   
4. template<std::size_t...I> constexpr auto foo(std::index_sequence<I...>) { return ((I+1) * ...); }
   
5. 
   
6. int main()
   
7. {
   
8.     std::cout << foo(std::make_index_sequence<20>()) << std::endl;
   
9. }

复制代码

历史学家版本：
（void main() 有没有嗅到浓厚的历史气息？）

1. #include <stdio.h>
   
2. void main(void) {
   
3.     int i;
   
4.     long long j;
   
5.     for(i = 1, j = 1;i <= 20; j *= i++);
   
6.         printf("%lld", j);
   
7. }

复制代码

敏捷开发上线1.0版本：
（可以说是非常敏捷了）

1. #include <stdio.h>
   
2. int main() {
   
3.     //printf("%d", 1*2*3*4*5*6*7*8*9*10);
   
4.     printf("%lld", (long long)1*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18*19*20);
   
5. }

复制代码

面向对象专家版本：
（好家伙，一个简单的问题，愣是祭出了接口、继承、虚函数、虚继承、智能指针等一大堆东西出来，这很面向对象）

1. #include <iostream>
   
2. #include <string>
   
3. #include <memory>
   
4. 
   
5. struct IBaseInterface {
   
6.     virtual ~IBaseInterface() = 0;
   
7. };
   
8. inline IBaseInterface::~IBaseInterface() = default;
   
9. 
   
10. struct IDataProvider : virtual public IBaseInterface {
    
11.     virtual int first() = 0;
    
12.     virtual int last() = 0;
    
13.     virtual int next(int v) = 0;
    
14. };
    
15. 
    
16. struct ICalculator : virtual public IBaseInterface {
    
17.     virtual long long calc(IDataProvider *) = 0;
    
18. };
    
19. 
    
20. struct IPrinter : virtual public IBaseInterface {
    
21.     virtual void print(const std::string &) = 0;
    
22. };
    
23. 
    
24. struct ISerializer : virtual public IBaseInterface {
    
25.     virtual std::string serialize(long long value) = 0;
    
26. };
    
27. 
    
28. struct IRunnable : virtual public IBaseInterface {
    
29.     virtual void run() = 0;
    
30. };
    
31. 
    
32. class Foo : virtual public IRunnable {
    
33.     std::shared_ptr<IDataProvider> m_dp;
    
34.     std::shared_ptr<ICalculator> m_c;
    
35.     std::shared_ptr<ISerializer> m_s;
    
36.     std::shared_ptr<IPrinter> m_p;
    
37. public:
    
38.     Foo(std::shared_ptr<IDataProvider> dp, std::shared_ptr<ICalculator> c, std::shared_ptr<ISerializer> s, std::shared_ptr<IPrinter> p) : m_dp(std::move(dp)), m_c(std::move(c)), m_s(std::move(s)),m_p(std::move(p)) {}
    
39.     void run() override { return  m_p->print(m_s->serialize(m_c->calc(m_dp.get()))); }
    
40. };
    
41. 
    
42. class DefaultSerializer : virtual public ISerializer {
    
43. public:
    
44.     std::string serialize(long long value) override { return std::to_string(value); }
    
45. };
    
46. 
    
47. class StreamPrinter : virtual public IPrinter {
    
48.     std::ostream &m_os;
    
49. public:
    
50.     explicit StreamPrinter (std::ostream &os) : m_os(os) {}
    
51.     void print(const std::string &s)  override { m_os << s << std::endl; }
    
52. };
    
53. 
    
54. class MultiplyAccumulateCalculator : virtual public ICalculator {
    
55. public:
    
56.     long long calc(IDataProvider *dp) override {
    
57.         int i = dp->first();
    
58.         long long j = i;
    
59.         do
    
60.             j *= (i = dp->next(i));
    
61.         while(i != dp->last());
    
62.         return j;
    
63.     }
    
64. };
    
65. 
    
66. int main() {
    
67.     struct MyDataProvider : virtual public IDataProvider {
    
68.         int first() override { return 1; }
    
69.         int last() override { return 20; }
    
70.         int next(int v) override { return v+1; }
    
71.     };
    
72.     Foo foo(std::make_shared<MyDataProvider>(), std::make_shared<MultiplyAccumulateCalculator>(), std::make_shared<DefaultSerializer>(), std::make_shared<StreamPrinter>(std::cout));
    
73.     foo.run();
    
74. }

复制代码

提前优化的并行版本：
（一看就是精通底层技术的大佬，把CPU拿捏得死死的）

1. #include <iostream>
   
2. #include <xmmintrin.h>
   
3. 
   
4. double foo(int x) {
   
5.     __m128 a = {1.0f, 2.0f, 3.0f, 4.0f};
   
6.     __m128 b = {4.0f, 4.0f, 4.0f, 4.0f};
   
7.     __m128 c = {1.0f, 1.0f, 1.0f, 1.0f};
   
8.     for(int i = 0; i < x / 4; ++i, a = _mm_add_ps(a, b))
   
9.         c = _mm_mul_ps(c, a);
   
10.     for(int i = x % 4; i < 4; ++i)
    
11.         a<i> = 1.0f;
    
12.     c = _mm_mul_ps(c, a);
    
13.     return (double)c[0] * (double)c[1] * (double)c[2] * (double)c[3];
    
14. }
    
15. 
    
16. int main() {
    
17.     std::cout << foo(20) << std::endl;
    
18. }</i>

复制代码

黑魔法版本：
（能看懂这段代码的，都不是普通人！）

1. #include <iostream>
   
2. #include <numeric>
   
3. #include <vector>
   
4. #include <functional>
   
5. int main() {
   
6. std::vector<int> v(std::atoi(std::end(__DATE__) - (__LINE__) / 2) - 1); // 2021年，第六行
   
7. std::iota(v.begin(), v.end(), 1);
   
8. std::cout << std::accumulate(v.begin(), v.end(), 1ull, std::multiplies<>()) << std::endl;
   
9. }

复制代码

“宏孩儿”元编程版：
（当年看各种C++框架中，排山倒海一样的宏定义，简直令人发指）

1. #include <boost/preprocessor.hpp>
   
2. 
   
3. // 由于boost.preprocessor仅提供255以下的整数运算
   
4. // 所以使用sequence来 (十位个位)(千位百位)(十万位万位) 的方式来表示大整数。
   
5. 
   
6. // 不进位加法：(77)(66)(55) + (44)(33)(22) = (121)(99)(77)
   
7. #define PP_ADD_N_N_CARRY_OP(R, DATA, I, ELEM) (BOOST_PP_ADD(BOOST_PP_SEQ_ELEM(I, DATA), ELEM))
   
8. #define PP_ADD_N_N_CARRY(SEQ_A, SEQ_B) BOOST_PP_SEQ_FOR_EACH_I(PP_ADD_N_N_CARRY_OP, SEQ_A, SEQ_B)
   
9. 
   
10. // 进位加法：(121)(99)(77) = （21)(0)(78)
    
11. // 注意SEQ_A的长度要比SEQ_B长
    
12. #define PP_ADD_N_N_OP(S, STATE, ELEM_CARRY) \
    
13.     BOOST_PP_SEQ_PUSH_FRONT( \
    
14.             BOOST_PP_SEQ_REPLACE(STATE, 0, BOOST_PP_MOD(BOOST_PP_ADD(BOOST_PP_SEQ_HEAD(STATE), ELEM_CARRY), 100)), \
    
15.             BOOST_PP_DIV(BOOST_PP_ADD(BOOST_PP_SEQ_HEAD(STATE), ELEM_CARRY), 100) \
    
16.             )
    
17. #define PP_ADD_N_N(SEQ_A, SEQ_B) BOOST_PP_SEQ_REVERSE(BOOST_PP_SEQ_FOLD_LEFT(PP_ADD_N_N_OP, BOOST_PP_SEQ_NIL(0), PP_ADD_N_N_CARRY(SEQ_A, SEQ_B)))
    
18. 
    
19. // 没什么好说的，X*N = X+X+X+X+X+...+X
    
20. #define PP_MUL_N_1_EXP_OP(Z, I, DATA) (DATA)
    
21. #define PP_MUL_N_1_EXP(SEQ_N, N) BOOST_PP_REPEAT(N, PP_MUL_N_1_EXP_OP, SEQ_N)
    
22. #define PP_MUL_N_1_MYOP(S, STATE, ITEM) PP_ADD_N_N(STATE, ITEM)
    
23. #define PP_MUL_N_1_FWD(EXP) BOOST_PP_SEQ_FOLD_LEFT(PP_MUL_N_1_MYOP, BOOST_PP_SEQ_HEAD(EXP), BOOST_PP_SEQ_TAIL(EXP))
    
24. #define PP_MUL_N_1(SEQ_N, N) PP_MUL_N_1_FWD(PP_MUL_N_1_EXP(SEQ_N, N))
    
25. 
    
26. #define FACT5 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1((1), 2), 3), 4), 5)
    
27. #define FACT10 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(FACT5, 6), 7), 8), 9), 10)
    
28. #define FACT15 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(FACT10, 11), 12), 13), 14), 15)
    
29. #define FACT20 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(FACT15, 16), 17), 18), 19), 20)
    
30. #define FACT25 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(FACT20, 21), 22), 23), 24), 25)
    
31. 
    
32. static_assert(false, BOOST_PP_STRINGIZE(FACT10));
    
33. 真·模板元编程版本
    
34. （泛型编程，码不惊人死不休）
    
35. 
    
36. #include <iostream>
    
37. #include <iomanip>
    
38. #include <type_traits>
    
39. 
    
40. using BaseType_t = long long;
    
41. constexpr BaseType_t lgBase = 9; // 注意10000*10000刚刚好小于int的取值范围
    
42. constexpr BaseType_t Base = 1000000000; // 注意10000*10000刚刚好小于int的取值范围
    
43. 
    
44. // 大整数的表示
    
45. template<BaseType_t...I> struct BigInteger {
    
46.     using type = BigInteger;
    
47. };
    
48. 
    
49. // 连接
    
50. template<class T1, class T2> struct BI_Cat;
    
51. template<BaseType_t...I1, BaseType_t...I2> struct BI_Cat <BigInteger<I1...>, BigInteger<I2...>> : BigInteger<I1..., I2...> {};
    
52. 
    
53. // 左移一个单元（即*Base）
    
54. template<class T> struct BI_SHL;
    
55. template<BaseType_t...I> struct BI_SHL<BigInteger<I...>> : BigInteger<I..., 0> {};
    
56. 
    
57. // 去除开头的0
    
58. template<class T> struct BI_Remove_Zeros : T {};
    
59. template<BaseType_t...I> struct BI_Remove_Zeros<BigInteger<0, I...>> : BI_Remove_Zeros<BigInteger<I...>> {};
    
60. 
    
61. // 填充0到N个单元
    
62. template<int X, class IS> struct BI_Fill_Impl;
    
63. template<int X, class T, T...I> struct BI_Fill_Impl<X, std::integer_sequence<T, I...>> : BigInteger<(I, X)...> {};
    
64. template<int Size> struct BI_Fill_Zeros : BI_Fill_Impl<0, std::make_index_sequence<Size>> {};
    
65. 
    
66. template<class T, int N> struct BI_Resize;
    
67. template<BaseType_t...I, int N> struct BI_Resize<BigInteger<I...>, N> : BI_Cat<typename BI_Fill_Zeros<N - sizeof...(I)>::type, BigInteger<I...>> {};
    
68. 
    
69. // 返回较大的数值
    
70. template<int A, int B> struct int_min : std::integral_constant<int, (A<B?B:A)> {};
    
71. 
    
72. // 非进位加法：先把两个数的位数改成一样的然后依次相加
    
73. template<class A, class B, class ShouldResize> struct BI_AddNotCarry_Impl;
    
74. template<BaseType_t...I1, BaseType_t...I2> struct BI_AddNotCarry_Impl <BigInteger<I1...>, BigInteger<I2...>, std::true_type> : BigInteger<(I1 + I2)...> {};
    
75. 
    
76. template<BaseType_t...I1, BaseType_t...I2> struct BI_AddNotCarry_Impl <BigInteger<I1...>, BigInteger<I2...>, std::false_type>
    
77.      : BI_AddNotCarry_Impl<
    
78.          typename BI_Resize<BigInteger<I1...>, int_min<sizeof...(I1), sizeof...(I2)>::value>::type,
    
79.          typename BI_Resize<BigInteger<I2...>, int_min<sizeof...(I1), sizeof...(I2)>::value>::type,
    
80.          std::true_type
    
81.      >{};
    
82. 
    
83. template<class A, class B> struct BI_AddNotCarry;
    
84. template<BaseType_t...I1, BaseType_t...I2> struct BI_AddNotCarry <BigInteger<I1...>, BigInteger<I2...>>
    
85.     : BI_AddNotCarry_Impl<BigInteger<I1...>, BigInteger<I2...>, std::bool_constant<sizeof...(I1) == sizeof...(I2)>> {};
    
86. 
    
87. // 判断是否为0
    
88. template<class Y> struct BI_IsZero;
    
89. template<BaseType_t...I> struct BI_IsZero<BigInteger<I...>> : std::bool_constant<((I == 0) && ...)> {};
    
90. 
    
91. // 自动进位
    
92. template<class A> struct BI_Carry;
    
93. template<class A, class B> struct BI_Add : BI_Carry<typename BI_AddNotCarry<A, B>::type> {};
    
94. 
    
95. template<class Mod, class Div, class ShouldCalc = typename BI_IsZero<Div>::type> struct BI_Carry_Impl;
    
96. template<class Mod, class Div> struct BI_Carry_Impl<Mod, Div, std::true_type> : Mod {};
    
97. template<class Mod, class Div> struct BI_Carry_Impl<Mod, Div, std::false_type>
    
98.         : BI_Add<Mod, typename BI_SHL<Div>::type > {};
    
99. template<BaseType_t...I> struct BI_Carry<BigInteger<I...>>
    
100.         : BI_Remove_Zeros<typename BI_Carry_Impl<BigInteger<(I % Base)...>, BigInteger<(I / Base)...>>::type> {};
     
101. 
     
102. // 乘以X并自动进位
     
103. template<class A, int X> struct BI_MulX;
     
104. template<BaseType_t...I1, int X> struct BI_MulX <BigInteger<I1...>, X>
     
105.         : BI_Carry<BigInteger<(I1 * X)...>> {};
     
106. 
     
107. // 计算阶乘
     
108. template<int X> struct BI_Fact : BI_MulX<typename BI_Fact<X-1>::type, X> {};
     
109. template<> struct BI_Fact<0> : BigInteger<1> {};
     
110. 
     
111. template<BaseType_t...I>
     
112. std::ostream &operator<<(std::ostream &out, BigInteger<I...>) {
     
113.     return ((out << std::setfill('0') << I << std::setw(lgBase)), ...);
     
114. }
     
115. 
     
116. int main()
     
117. {
     
118.     std::cout << typename BI_Fact<20>::type() << std::endl;
     
119. }

复制代码

原回答：https://www.zhihu.com/question/365763395/answer/971009059

不得不服，知乎真是人才多啊！各位大佬，你们在第几个版本倒下了？

我反正看到面向对象专家版本就已经忍不住了···

原文:https://mp.weixin.qq.com/s/9H0YOCrvmXj1IMB0N1OXEQ

柿子饼同学

啥都看不懂啊

2454696816

菜鸟啥也看不懂

Lexroll

啥都看不懂啊

1molHF

不明觉厉！

ohhohh

tomok

来学习了

知识改变眼界

学习

hornwong

oyddchris

厉害

tianlai7266

hornwong

hornwong

qwb1997

Passepartout

Thanks&#9834;(&#65381;ω&#65381;)&#65417;

zhsguitar

ckg16

xdl

我叫武炜昊

看不懂

myqf123

新年快乐

江湖散人

厉害