小编MrM*_*ter的帖子

我有一些辅助代码,使用编译时索引执行向量重组.生成的代码尽可能高效至关重要.我依赖带有折叠表达式的参数包,我想知道编写这样的代码的最佳实践是什么.

一个实际的例子:让一个函数insert将容器的元素插入y到位置为编译时常量的位置的容器x中Ii.这个函数的基本签名是这样的:

template<size_t... Ii, size_t Xsize, size_t Size>
constexpr container<Xsize> insert(container<Xsize> x, container<Ysize> y);

它的调用如下:insert<0, 2>(x, y).我看到实现这一点的两个明显可能性.

第一:使用辅助索引变量迭代y:

template<size_t... Ii, size_t Xsize, size_t Size>
constexpr container<Xsize> insert(container<Xsize> x, container<Ysize> y) {
  int i = 0;
  ((x[Ii] = y[i++]), ...);
  return x;
}

我对这个解决方案的问题是变量i:我必须依靠编译器来优化它.

第二个解决方案避免了任何运行时依赖性,但它需要一个辅助功能,使整个实现相当丑陋:

template<size_t... Ii, size_t... Yi, size_t Xsize, size_t Size>
constexpr container<Xsize> insert_(container<Xsize> x, container<Ysize> y, std::index_sequence<Yi...>) {
  ((x[Ii] = y[Yi]), ...);
  return x; …

我很难理解 C 预处理器在以下上下文中如何应用重写规则。我有以下宏：

#define _A(x) "A" _##x\n#define _B(x) "B" _##x\n#define X(x) _##x\n

这个想法是，每个宏都使用串联来创建一个新表达式，它本身可以是一个宏 \xe2\x80\x94 如果它是一个宏，我希望它被扩展：

现在，以下内容正如我所期望的那样展开：

X(x)       expands to _x\nX(A(x))    expands to "A" _x\nX(A(B(x))) expands to "A" "B" _x\n

然而，一旦多次使用同一个宏，扩展就会停止：

X(A(A(x)))       expands to "A" _A(x), expected "A" "A" _x\nX(B(B(x)))       expands to "B" _B(x), expected "B" "B" _x\nX(A(B(A(x))))    expands to "A" "B" _A(x), expected "A" "B" "A" _x \nX(A(B(A(B(x))))) expands to "A" "B" _A(B(x)), expected "A" "B" "A" "B" _x \n

我猜想这里存在某种“只能扩展同名宏一次”规则？我可以做些什么来让宏按照我想要的方式扩展吗？

假设我有一个模板类型，例如

template<typename A, typename B, typename C>
struct mytype { };

如何编写一个概念来检查类型是否是该模板的实例化？

template<typename T>
concept MyType = requires(T x) { ??? }

如果不解决旧式专用探测器类型或标记基类型，我无法找到一种明显的方法。

我很好奇.awaitRust 的实际工作原理。它似乎不是FutureAPI 的一部分，所以我认为它一定是某种编译器魔法。它是如何.await工作的以及它可以应用于什么？

我了解异步构造的工作原理以及如何使用不稳定的生成器编译异步函数；这不是我的问题。我具体询问的是.await魔法会员运营商。也就是说，如果我们有这样的表达式

fut.await

此时会发生什么以及fut该表达式应满足哪些约束才能有效？