这是gcc的一个遗漏的优化。
基本上，问题是：当vector必须重新分配时，如何将元素从旧存储转移到新存储？gcc的实现目前正在尝试这样做（为了简洁起见，我删除了一些不相关的代码块）：

// This class may be specialized for specific types.
  // Also known as is_trivially_relocatable.
  template<typename _Tp, typename = void>
    struct __is_bitwise_relocatable
    : is_trivial<_Tp> { };

  template <typename _InputIterator, typename _ForwardIterator,
        typename _Allocator>
    _GLIBCXX20_CONSTEXPR
    inline _ForwardIterator
    __relocate_a_1(_InputIterator __first, _InputIterator __last,
           _ForwardIterator __result, _Allocator& __alloc)
    noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
                           std::addressof(*__first),
                           __alloc)))
    {
      _ForwardIterator __cur = __result;
      for (; __first != __last; ++__first, (void)++__cur)
    std::__relocate_object_a(std::__addressof(*__cur),
                 std::__addressof(*__first), __alloc);
      return __cur;
    }

  template <typename _Tp, typename _Up>
    _GLIBCXX20_CONSTEXPR
    inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
    __relocate_a_1(_Tp* __first, _Tp* __last,
           _Tp* __result,
           [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept
    {
      ptrdiff_t __count = __last - __first;
      if (__count > 0)
    {
      __builtin_memmove(__result, __first, __count * sizeof(_Tp));
    }
      return __result + __count;
    }

这里的第一个重载执行成员方式的复制，第二个重载执行单个memmove-但仅当类型满足__is_bitwise_relocatable<_Tp>时，如您所见，默认值为std::is_trivial。但这就是导致代码路径进行缓慢的元素复制而不是单个memmove的原因。
您可以通过专门化__is_bitwise_relocatable<Foo>并查看性能now lines up来验证这一点。

我理解Foo和Baz为什么不满足标准定义的条件，但我不明白的是，为什么这意味着某些算法可以优化Bar上的操作，而在Foo或Baz上却不能。
这不是真实的的实现，而只是一个概念上的暗示：

Bar* default_alloc_x_Bars(int x)
{
    return (Bar*)(char*)malloc(sizeof(Bar)*x); //returns nullptr if allocation unsuccesful
}

Baz* default_alloc_x_Bazs(int x)
{
    char* buffer = (char*)malloc(sizeof(Baz)*x);

    if(buffer)
        memset((void*)buffer,0,sizeof(Baz)*x);

    return (Baz*)buffer; //returns nullptr if allocation unsuccesful
}

在_i未初始化的情况下，不可能创建法律的的Baz或Foo，因此您不能简单地获取一块内存并声明它是Baz/Foo。
Bar不会初始化_i，因此任何给定的大小和对齐方式正确的内存块在功能上都是Bar。
（这是一个复杂的问题，你不能像我们写普通C一样简单地转换内存，但是作为一个概念模型，为什么琐碎的构造很重要，这几乎是事情的全部）