在x86-64 GCC 13.1和Clang 16.0.0中，copy<PrivateBase>函数使用按成员复制，而copy<PublicBase>函数使用按位复制。您可以参考compiler explorer上的详细源代码和汇编代码，或者查看下面提供的代码片段：

class PublicBase {
public:
    int num;
    char c1;
};

class PrivateBase {
private:
    int num;
    char c1;
};

template<typename T>
__attribute_noinline__ void copy(T *dst, T *src) {
    *dst = *src;
}

template void copy(PublicBase *dst, PublicBase *src);
template void copy(PrivateBase *dst, PrivateBase *src);

void copy<PublicBase>(PublicBase*, PublicBase*):
        mov     rax, QWORD PTR [rsi]
        mov     QWORD PTR [rdi], rax
        ret
void copy<PrivateBase>(PrivateBase*, PrivateBase*):
        mov     eax, DWORD PTR [rsi]
        mov     DWORD PTR [rdi], eax
        movzx   eax, BYTE PTR [rsi+4]
        mov     BYTE PTR [rdi+4], al
        ret

问题是，C++11的默认复制赋值操作符何时使用按位复制而不是按成员复制？似乎is_trivially_copyable和is_pod都没有提供答案。

is_trivially_copyable

根据cppreference-is_trivially_copyable：
不可能重叠的子对象的平凡可复制类型的对象是唯一可以用std：：memcpy安全复制的C++对象。
PublicBase和PrivateBase都是可复制的，而不是子对象，但PrivateBase是按成员而不是按位复制的。

is_pod

如果存在PublicBase或PrivateBase的派生类，则PrivateBase的派生类将重用基类的填充，而PublicBase的派生类则不会。
因此，PrivateBase以成员方式复制是合理的。否则，基类的填充可能会在调用copy<PrivateBase>(derived, base)时覆盖PrivateDerived::c2。

class PublicDerived : public PublicBase {
public:
    char c2;
};

class PrivateDerived : public PrivateBase {
private:
    char c2;
};

int main() {
    std::cout << "sizeof(PublicBase)=" << sizeof(PublicBase) << std::endl;
    std::cout << "sizeof(PublicDerived)=" << sizeof(PublicDerived) << std::endl;
    std::cout << "sizeof(PrivateBase)=" << sizeof(PrivateBase) << std::endl;
    std::cout << "sizeof(PrivateDerived)=" << sizeof(PrivateDerived) << std::endl;

    return 0;
}
// Output:
// sizeof(PublicBase)=8
// sizeof(PublicDerived)=12
// sizeof(PrivateBase)=8
// sizeof(PrivateDerived)=8

我对编译器如何决定是否重用基类的填充感到困惑。根据related question，POD类型不重用基类的填充。
根据cppreference-POD_class：
POD类是一个

• 直到C++11：
• 是一个聚合（没有私有或受保护的非静态数据成员），
• 没有用户声明的复制赋值运算符，
• 没有用户声明的析构函数，并且
• 没有非POD类（或此类类型的数组）或引用类型的非静态数据成员。
• 自C++11
• 是一个平凡的类
• 是一个标准布局类（对所有非静态数据成员具有相同的访问控制），并且
• 没有非POD类类型的非静态数据成员（或此类类型的数组）。

在C11之前，PrivateBase不是POD类型（因为它有私有数据成员），但从C11开始，它变成了POD类型（因为它对所有非静态数据成员都有相同的访问控制）。

int main() {
    std::cout << "PublicBase: is_standard_layout=" << is_standard_layout<PublicBase>::value
              << ", is_trivial=" << is_trivial<PublicBase>::value
              << ", is_pod=" << is_pod<PublicBase>::value << std::endl;

    std::cout << "PrivateBase: is_standard_layout=" << is_standard_layout<PrivateBase>::value
              << ", is_trivial=" << is_trivial<PrivateBase>::value
              << ", is_pod=" << is_pod<PrivateBase>::value << std::endl;
}
// Output:
// PublicBase: is_standard_layout=1, is_trivial=1, is_pod=1
// PrivateBase: is_standard_layout=1, is_trivial=1, is_pod=1