13 | 编译期能做些什么？一个完整的计算世界

精选留言(11)

• 
  三味

  2019-12-30

  这个课后思考题真不是盖得。。。还看到了5分钟编译期堆排序的段子。。。看得我心惊胆战。。。
  不过还是一堆百度写出了一个，针对int型，写出从[0, N)的编译期生成数组的例子。。。兼容其他类型还要再额外写好多代码。。偷懒直接写了int型。。。
  我在msvc下测试了，应该没问题。。。用到了模板不定参数，其他不知道什么技巧的方法。。。
  想要让int N转换成从0，1，2，3，4，5 。。。卡在了如何把这堆参数展开。。写得可能复杂一些。。不知道怎么更简单。。 下面代码吧：
  
  template<int... values>
  struct IntegerSequence {};
  
  template<typename T, T v, typename INTEGER_SEQUENCE>
  struct PushBack;
  
  template<int v, int... values>
  struct PushBack<int, v, IntegerSequence<values...>> {
      using type = IntegerSequence<values..., v>;
  };
  
  template<int N>
  struct IntegerRange {
      using type = typename PushBack<int, N-1, typename IntegerRange<N-1>::type>::type;
  };
  
  template<>
  struct IntegerRange<1> {
      using type = IntegerSequence<0>;
  };
  
  template<int N, typename INTEGER_SEQUENCE>
  struct RangeArray;
  
  template<int N, int... values>
  struct RangeArray<N, IntegerSequence<values...>> {
      static constexpr std::array<int, N> value = {values...};
  };
  
  template<int N> using Range = RangeArray<N, typename IntegerRange<N>::type>;
  
  测试：
  auto A = Range<5>::value;
  不出意外，会生成std::array<int, 5>{0,1,2,3,4};

  展开

  

  
• 
  总统老唐

  2019-12-27

  吴老师，关于最后这个例子，有两个小问题：
  1，我们平时定义一个 vector 的时候，一般并不会写成 vector<int, allocator<int>> vec 这种形式，为什么模板函数里面定义返回值 result 时，需要多一个 allocator？
  2，fmap函数的入参和for循环，全都用的右值引用，有什么特殊考量么？

  展开

  作者回复: 1. 因为模板的定义就是这个样子，虽然我们平时第二个参数用的都是默认模板参数。
  
  2. 不是右值引用，是转发引用。复习一下第 3 讲结尾部分吧。

  

  
• 
  总统老唐

  2019-12-27

  吴老师，看了你的While模板，试着想把这个计算累加的功能扩展一下，输入任意两个数，可以求他们之间的数的累加和，代码如下：
  template <int from, int to, int sum>
  struct SumAnyTwo_A
  {
      static const bool cond_value = from != to;
      static const int res_value = sum;
      typedef integral_constant<int, res_value> res_type;
      typedef SumAnyTwo_A<from + 1, to, sum + from> next_type;
  };
  
  template <int from, int to, int sum>
  struct SumAnyTwo_B
  {
      static const bool cond_value = from != to;
      static const int res_value = sum;
      typedef integral_constant<int, res_value> res_type;
      typedef SumAnyTwo_B<from - 1, to, sum + from> next_type;
  };
  
  template <bool valueCompare, int from, int to>
  struct SumAnyTwo;
  
  template <int from, int to>
  struct SumAnyTwo<true, from, to>
  {
      typedef SumAnyTwo_A<from, to, 0> addType;
  };
  
  template <int from, int to>
  struct SumAnyTwo<false, from, to>
  {
      typedef SumAnyTwo_B<from, to, 0> addType;
  };
  
  template <int from, int to>
  struct SumTwo
  {
      typedef SumAnyTwo<(from > to), from, to> type;
  };
  
  遇到了两个问题：
  1，这段代码看起来不够优雅，在C++ 98 的范畴内，有更好的模板元编程实现方式么？
  2，当我试图调用这个While模板时，出现如下状况，不明白为什么第一个会报错
          While<SumTwo<8, 3>::type::addType>::type::value // 报错，template instantiation depth exceeds maximum of 900
          While<SumAnyTwo_B<8, 3, 0>>::type::value // OK
         While<SumAnyTwo<(8 - 3 < 0), 8, 3>::addType>::type::value //OK
  
  

  展开

  作者回复: 我真是自作自受，得看这样的代码。😜
  
  1. 我给的这些模板只是说明能力的，肯定不是让你真的这么写代码的。比如你这种累加，可以考虑这样写（只考虑了正向）：
  
  template <int from, int to, int sum, bool ending>
  struct sum_two_op;
  
  template <int from, int to, int sum>
  struct sum_two_op<from, to, sum, false> {
      static const int value = sum;
  };
  
  template <int from, int to, int sum>
  struct sum_two_op<from, to, sum, true> {
      static const int value =
          sum_two_op<from + 1, to, sum + from, (from < to)>::value;
  };
  
  template <int from, int to>
  struct sum_two {
      static const int value = sum_two_op<from, to, 0, (from <= to)>::value;
  };
  
  2. 你已经很靠近了，只犯了一个小错误，SumTwo 里的方向。应该是：
  
  template <int from, int to>
  struct SumTwo {
      typedef SumAnyTwo<(from < to), from, to> type;
  };
  
  另外，你目前的处理对于 from==to 的情况有点问题。可参考我上面的写法，那是可以正确处理的。

   3

  
• zhang

  2019-12-26

  您好，我想问一个mutex相关的问题，虽然这部分内容以后会讲，但我现在工作中有一个疑问，麻烦您看一下，谢谢。
  代码简写如下：
  class Mutex {
  public:
      pthread_mutex_t mutex;
      Mutex():mutex(PTHREAD_MUTEX_INITIALIZER) {}
      void lock() {
          pthread_mutex_lock(&mutex);
      }
      void unlock() {
          pthread_mutex_unlock(&mutex);
      }
  };
  class Cond {
  public:
      pthread_cond_t cond;
      Cond():cond(PTHREAD_COND_INITIALIZER) {}
      void signal() {
          pthread_cond_signal(&cond);
      }
      void broadcast() {
          pthread_cond_broadcast(&cond);
      }
      void wait(Mutex &mutex) {
          pthread_cond_wait(&cond, &mutex.mutex);
      }
  };
  class ScopeLock {
      Mutex &mutex;
  public:
      ScopeLock(CanMutex &_mutex):mutex(_mutex) {
          mutex.lock();
      };
      ~ScopeLock() {
          mutex.unlock();
      };
  };
  
  class Client
  {
  public:
      Mutex inter_mutex;
      Mutex mutex;
      Cond cond;
      bool pending;
      Client():pending(false){}
      ~Client(){}
      void Lock() {
          mutex.lock();
      }
      void Unlock() {
          mutex.unlock();
      }
      void sendData() {
          const ScopeLock inter_protect(inter_mutex);
          const ScopeLock protect(mutex);
  
          //send_to_server();
  
          while (!pending) {
              cond.wait(mutex);
          }
          pending = false;
      }
      void recvData() {
          const ScopeLock protect(mutex);
          pending = true;
          cond.signal();
      }
  };
  我有几个线程会执行同一个Client对象的sendData函数，有一个线程执行Client对象的recvData函数。我主要想问我几个sendData线程需要同步执行，执行完一个sendData发送后，再执行另一个sendData。那么我在sendData函数最开始加整个函数范围的锁const ScopeLock inter_protect(inter_mutex);，是否可以这样做？谢谢！

  展开

  作者回复: 对你的业务场景不熟悉，随便评论几句。
  
  ・C++11 里有现成的 mutex、condition_variable 和 unique_lock。
  ・Client::Lock 和 Client::Unlock 似乎没有用处。
  ・变量 pending 的命名让人困惑：收到数据了，“挂起”标志被设为真，然后发送数据就能继续往下执行了？连续两次 sendData 中间必须有一次 recvData 才行，而且 sendData 里的等待是在发送之后？这块感觉有问题。
  ・inter_mutex 和 inter_protect 本身目前没有看出问题。

   2

  
• 
  安静的雨

  2019-12-25

  模版编程很有趣，期待老师的更新。

  展开

  作者回复: 觉得有趣就好，这个我们要讲上好几讲的。

  

  
• 
  总统老唐

  2019-12-25

  记得吴老师之前预告过，这一节可能会比较难，确实被难住了。在第一个 If 模板这里就被卡住了，老师能给个简单的例子来说明这个 If 模板该如何使用么？

  展开

  作者回复: 下面的函数和模板是基本等价的：
  
  int foo(int n)
  {
    if (n == 2 || n == 3 || n == 5) {
      return 1;
    } else {
      return 2;
    }
  }
  
  template <int n>
  struct Foo {
    typedef typename If<
      (n == 2 || n == 3 || n == 5),
      integral_constant<int, 1>,
      integral_constant<int, 2>>::type
      type;
  };
  
  你可以输出 foo(3)，也可以输出 Foo<3>::type::value。

  

  
• 
  禾桃

  2019-12-25

  脑壳儿疼的兄弟姐妹们，我这有个小偏方， 哈哈
  
  While< Sum<2>::type >::type::value 实例化(instantiation)过程
  --> While< SumLoop<0, 2> >::type::value
  --> WhileLoop<SumLoop<0, 2>::cond_value, SumLoop<0, 2>>::type::value
  --> WhileLoop<true, SumLoop<0, 2>>::type::value
  
  --> WhileLoop<SumLoop<0, 2>::cond_value, SumLoop<0, 2>::next_type>::type::value
  --> WhileLoop<true, SumLoop<2, 1>>::type::value
  
  --> WhileLoop<SumLoop<2, 1>::cond_value, SumLoop<2, 1>::next_type>::type::value
  --> WhileLoop<true, SumLoop<3, 0>>::type::value
  
  --> WhileLoop<SumLoop<3, 0>::cond_value, SumLoop<3, 0>::next_type>::type::value
  --> WhileLoop<false, SumLoop<3, -1>>::type::value
  
  --> SumLoop<3, -1>::res_type::value
  
  -->integral_constant<int, 3>::value
  -->3

  展开

  作者回复: 对，对于模板，就是要在脑子里或纸上、电脑上把它展开……☺️

  

  
• 小一日一

  2019-12-25

  #include <iostream>
  #include <vector>
  #include <type_traits>
  
  using namespace std;
  
  template< class T >
  using decay_t = typename decay<T>::type;
  
  template < template <typename, typename> class OutContainer = vector,
             typename F, class R>
  auto fmap(F&& f, R&& inputs)
  {
      typedef decay_t<decltype( f(*inputs.begin()))> result_type;
      OutContainer< result_type, allocator<result_type>> result;
      for (auto&& item : inputs) {
          result.push_back(f(item));
      }
      return result;
  }
  
  int add_1(int x)
  {
      return x + 1;
  }
  
  int main()
  {
      vector<int> v{1, 2, 3, 4, 5};
  
      auto result = fmap(add_1, v);
  
      for (auto &&v : result) {
          cout << v << endl;
      }
  }
  
  用g++ 4.8.5 带std=c++11参数编译能通过并正确运行，但是有warning:
  13_5.cc:12:28: warning: ‘fmap’ function uses ‘auto’ type specifier without trailing return type [enabled by default] auto fmap(F&& f, R&& inputs)
  
  请问老师如何加尾置返回类型消除warning?

  展开

  作者回复: 试试 c++1y、c++14 等标准选项了。这个 GCC 太老了……我要求 C++17、GCC 7 的。

   2

  
• 
  李义盛

  2019-12-25

  一到模板就处于看不懂状态了。

  展开

  作者回复: 拿纸笔来展开试试？实际上就是一种展开而已。

  

  
• 
  禾桃

  2019-12-25

  “常用的一个技巧就是用 is_trivially_destructible 模板来判断类是否是可平凡析构的——也就是说，不调用析构函数，不会造成任何资源泄漏问题。”
  
  麻烦解释一下，
  #1 这个类模版是如何识别“，不调用析构函数，不会造成任何资源泄漏问题”？ 这的资源包括new的堆内存吗？
  #2 trivially这个词总是觉得很难理解，C++里，使用这个词的目的，到底是什么？

  展开

  作者回复: 1 是有点编译器魔法的。如果你有析构函数，或者你没有析构函数但有个非 POD 数据成员，is_trivially_destructible 就不成立了。
  
  2 trivial 是很常见的数学术语，没什么特别的。见：
  
  https://baike.baidu.com/item/%E5%B9%B3%E5%87%A1/16739977
  https://zh.wikipedia.org/wiki/%E5%B9%B3%E5%87%A1_(%E6%95%B8%E5%AD%B8)
  https://en.wikipedia.org/wiki/Triviality_(mathematics)

  

  
• 
  hello world

  2019-12-25

  一直对模板元编程感兴趣，但总是搞不明白，今天学习很有收获，特别是最后的fmap，感谢老师，记得模板编程还有policy之类的东西，老师之后在编译期这方面还会更详细讲解吗

  作者回复: 编译期要连续讲到第 18 讲，甚至之后还会有提到的机会。你喜欢那是最好了。我是怕很多人会被编译期编程吓退呢。😅
  
  policy 这个概念不单独讲，但我觉得在讨论了使用常数来对模板进行特化之后，这个概念应该没有特别之处。我们的例子倒是会有标准库提供的 policy。😁

  

  