小编Bri*_*ian的帖子

我正在查看我的标题(g ++ - 4.5.2)中的一些模板的实现,我发现了以下内容:

/// is_function
template<typename>
  struct is_function
  : public false_type { };
template<typename _Res, typename... _ArgTypes>
  struct is_function<_Res(_ArgTypes...)>
  : public true_type { };
template<typename _Res, typename... _ArgTypes>
  struct is_function<_Res(_ArgTypes......)>
  : public true_type { };

前两个声明似乎是合理的,但我无法弄清楚第三个如何工作.什么是......？我在标准中寻找它,但找不到任何东西.

#if __cplusplus >= 201103L

template <class _Key, class _Tp>
union __value_type
{
    typedef _Key                                     key_type;
    typedef _Tp                                      mapped_type;
    typedef pair<const key_type, mapped_type>        value_type;
    typedef pair<key_type, mapped_type>              __nc_value_type;

    value_type __cc;
    __nc_value_type __nc;

    template <class ..._Args>
    _LIBCPP_INLINE_VISIBILITY
    __value_type(_Args&& ...__args)
        : __cc(std::forward<_Args>(__args)...) {}

    _LIBCPP_INLINE_VISIBILITY
    __value_type(const __value_type& __v)
        : __cc(__v.__cc) {}

    _LIBCPP_INLINE_VISIBILITY
    __value_type(__value_type& __v)
        : __cc(__v.__cc) {}

    _LIBCPP_INLINE_VISIBILITY
    __value_type(__value_type&& __v)
        : __nc(std::move(__v.__nc)) {}

    _LIBCPP_INLINE_VISIBILITY
    __value_type& operator=(const __value_type& __v)
        {__nc = __v.__cc; return *this;}

    _LIBCPP_INLINE_VISIBILITY
    __value_type& operator=(__value_type&& __v)
        {__nc = std::move(__v.__nc); return *this;}

    _LIBCPP_INLINE_VISIBILITY
    ~__value_type() …

我可以确定以下代码可以工作吗？

int sum_array(int *array, size_t size)
{
  int i;
  int sum = 0;
  for (i=0;i<size;i++)
    sum += *(array+i);
  return sum;
}

int main()
{
  int two_d_array[4][3] = {{1,2,3}, {4,5,6}, {7,8,9}, {10,11,12}};
  int sum = sum_array(&two_d_array[0][0], 12);
  printf("%d", sum);
}

虽然将4 x 3数组完全像12个元素的数组那样布置在内存中是合理的，但是可以保证吗？由于我似乎在欺骗类型系统，因此我不确定会出问题（例如，将填充添加到int [3]）。

如果您可以详细说明如果我在数组中使用int以外的东西会发生什么，并提供标准的相关报价，则可以加分。

标准说：

双端队列是支持随机访问迭代器（27.2.7）的序列容器。此外，它支持在开头或结尾的恒定时间插入和擦除操作；在中间插入和擦除需要线性时间。

然而，它也在同一个条款中说：

本条款中的所有复杂性要求仅根据对所包含对象的操作数量进行说明。[ 示例： type 的复制构造函数vector<vector<int>>具有线性复杂性，即使复制每个包含的复杂性vector<int>本身也是线性的。— 结束示例 ]

不这是否意味着在插入的，刚开始说，deque<int>被允许采取线性时间，只要不超过固定数量的执行更多操作上的int那些已经在双端队列和新的Sint对象插入?

例如，假设我们使用“大小为 K 个向量的向量”来实现双端队列。似乎我们在开头每插入 K 次，就必须在开头添加一个新的大小为 K 的向量，因此必须移动所有其他大小为 K 的向量。这意味着开始时插入的时间复杂度分摊为 O(N/K)，其中 N 是元素总数，但 K 是常数，所以这只是 O(N)。但这似乎是标准允许的，因为移动大小为 K 的向量不会移动其任何元素，并且“复杂性要求”“仅根据对所包含int对象的操作数量进行说明” 。

标准真的允许这样做吗？或者我们应该将其解释为具有更严格的要求，即对所包含对象的恒定操作次数加上恒定的额外时间？

对类型对象进行值初始化T意味着：

...

— 如果T是（可能是 cv 限定的）类类型，没有用户提供或删除的默认构造函数，则对象被零初始化并检查默认初始化的语义约束，并且如果T具有非平凡的默认构造函数，对象是默认初始化的；

我理解这里的意图：如果用户没有为 声明默认构造函数T，或者在第一次声明时显式默认了它，那么值初始化的零初始化传递将确保对象的某些直接成员（例如那些基本类型）不会留下不确定的值。

我不明白的是为什么第二遍被指定为“检查默认初始化的语义约束，如果T有一个非平凡的默认构造函数，则对象被默认初始化”。对我来说，这与只是说“对象是默认初始化的”相同（无论默认构造函数是否微不足道）。如果构造函数实际上是微不足道的，那么调用它应该与不调用它相同。标准不需要告诉编译器不要生成调用，因为在 as-if 规则下允许这样的优化，任何好的编译器都会这样做。

我错过了什么吗？在值初始化上下文中，调用一个平凡的默认构造函数与不调用它有什么不同吗？

在下面的代码中

int a = A.load(std::memory_order_acquire);

T b = load_non_atomic(data);

// ---- barrier ----

int c = A.load(std::memory_order_acquire);

即使在弱内存模型架构（例如 ARM）上，load_non_atomic()我应该使用什么样的屏障来避免重新排序？c

直觉上我需要 a来禁止在它之后std::atomic_thread_fence(std::memory_order_release)重新排序读/写操作，但是它是否允许使用释放来加载？