C++11 内存布局术语解读（平凡类型、平凡可复制类型、标准布局类型）

图王大胜

已于 2024-04-23 17:10:23 修改

阅读量1.3k

点赞数 9

分类专栏：计算机学科基础文章标签： c++ 开发语言内存布局术语平凡类型标准布局

于 2024-04-23 11:40:11 首次发布

本文链接：https://blog.csdn.net/vviccc/article/details/138089766

版权

计算机学科基础专栏收录该内容

103 篇文章 78 订阅

订阅专栏

说明：在C++11中，平凡类型（Trivial Type）、平凡可复制类型（TrivialCopyable）、标准布局类型（Standard-layout Type）是描述类在内存中布局特性的术语，它们与类的构造、拷贝、赋值和销毁行为有关，也影响着类的内存布局和对齐方式。下面用通俗的语言解释这些概念：

平凡类型：指那些在内存中的行为非常简单的类。它们的构造函数、析构函数、拷贝构造函数和赋值运算符都没有自定义实现，完全由编译器提供的默认行为即可。这意味着这些类的对象可以像基本数据类型一样被创建和销毁，不需要特殊的资源管理代码。
平凡可复制类型：是平凡类型的一个扩展，它不仅包括所有平凡类型，还包括那些可以安全地被复制和移动的类型，即使这些类型不是平凡类型。例如，一个类可能有一个自定义的构造函数，但如果它保证对象的内容可以通过简单的位拷贝（bitwise copy）来复制，那么它也可以被认为是平凡可复制的。
标准布局类型：指那些在内存布局上满足一定规则的类。这些规则包括所有非静态成员的访问权限必须相同，类不能有虚函数或虚基类，且所有基类也必须是标准布局类型。标准布局类型的一个重要特性是它们的内存布局在不同的编译器和平台上是一致的，这对于跨平台的二进制数据交换非常重要。

接下来用更加通俗和易于理解的方式来说明，解释如下：

平凡类型：就像一个简单的储物箱，没有锁，没有特殊的开启方式，任何人都可以简单地打开和关闭。
平凡可复制类型：类似于平凡类型，但是更加灵活，即使储物箱有锁，只要我们保证复制时锁的状态不变，它也能满足要求。
标准布局类型：就像一个有统一标准的书架，无论在哪个图书馆，书架上书的排列方式都是一致的，方便管理和查找。

这些特性对于编写高效的、跨平台的C++程序非常重要，因为它们允许开发者在保持类型安全的同时，对内存布局有更多的控制。

1 为什么要引入平凡类型、平凡可复制类型、标准布局类型？

引入平凡类型（Trivial Type）、平凡可复制类型（TrivialCopyable）、标准布局类型（Standard-layout Type）的主要原因包括：

内存效率与性能：平凡类型允许简单的位拷贝，提高内存使用效率和程序性能。
跨平台兼容性：标准布局类型确保了不同编译器和硬件平台上的一致性，增强了代码的可移植性。
C语言兼容性：平凡类型与C语言结构体的内存布局兼容，便于C++与C语言代码的互操作。
模板编程：这些概念提供了对模板元编程的支持，允许编写高效且通用的模板代码。
多线程安全：平凡类型的操作线程安全，简化了并发编程中同步和锁的需要。
简化代码与资源管理：减少了复杂资源管理的需求，使得代码更简洁，易于维护。
避免未定义行为：通过明确的类型特性，减少了因对象操作导致的未定义行为，增强了程序的安全性。

总之，主要是为了兼容性。

2 内存布局术语详细解读

2.1 平凡类型详细解读

在C++11中，平凡类型（Trivial Type）是指那些构造、拷贝、移动、赋值和销毁操作都是平凡的（trivial）的类。平凡操作意味着这些操作可以没有特别定义的行为，编译器提供的默认实现就足够了。以下是平凡类型和非平凡类型的示例代码展示，参考代码如下：

#include <iostream>

// 平凡类型：没有任何自定义的构造函数、析构函数、拷贝控制成员
struct TrivialType {
    int a;
    double b;
};

// 非平凡类型：至少有一个自定义的特殊成员函数
struct NonTrivialType {
    int a;
    double b;

    // 自定义构造函数
    NonTrivialType() : a(0), b(0.0) {}

    // 自定义拷贝赋值运算符
    NonTrivialType& operator=(const NonTrivialType& other) {
        a = other.a;
        b = other.b;
        return *this;
    }

    // 自定义析构函数
    ~NonTrivialType() {
        std::cout << "NonTrivialType destroyed\n";
    }
};

int main() {
    TrivialType t1, t2;
    t2 = t1; // 平凡类型的赋值操作是平凡的

    NonTrivialType nt1, nt2;
    nt2 = nt1; // 非平凡类型的赋值操作不是平凡的

    std::cout << "TrivialType is trivially:" 
              << std::is_trivially<TrivialType>::value << std::endl;
    std::cout << "NonTrivialType is trivially:" 
              << std::is_trivially<NonTrivialType>::value << std::endl;
    return 0;
}

在这个示例中：

TrivialType 是一个平凡类型，因为它没有任何自定义的特殊成员函数。它的构造、拷贝、移动、赋值和析构操作都是由编译器提供的默认实现。
NonTrivialType 是一个非平凡类型，因为它至少有一个自定义的特殊成员函数（在这个例子中是构造函数、拷贝赋值运算符和析构函数）。这意味着它至少有一个操作不能由编译器提供的默认实现来完成。

注意事项：

即使类没有显示定义特殊成员函数，如果类中有虚函数或虚基类，它也不是平凡类型。
类中如果有动态内存分配（如指针成员）或需要特殊资源管理的成员，也不是平凡类型。
平凡类型的所有特殊成员函数都是平凡的，这意味着它们可以没有函数体（即使用编译器提供的默认实现）。

平凡类型在C++中很重要，因为它们可以提高效率，允许编译器进行更多的优化。例如，平凡类型的拷贝和赋值可以通过简单的内存复制完成，而不需要调用任何成员函数。

2.2 平凡可复制类型详细解读

在C++11中，平凡可复制类型（TrivialCopyable）是指那些可以被简单地复制和移动的类型，即使它们不是平凡类型（Trivial Type）。一个类型是平凡可复制的，如果它满足以下条件：

类型可以被复制或移动，且不需要特殊的资源管理。
类型的所有特殊成员函数（构造函数、拷贝构造函数、移动构造函数、赋值运算符、移动赋值运算符和析构函数）都是平凡的或者被删除的（deleted）。

以下是一组示例代码，展示了哪些类型是平凡可复制的，哪些不是：

#include <iostream>
#include <utility> // For std::move

// 平凡可复制类型：没有自定义的特殊成员函数，且可以被简单地复制和移动
struct TrivialCopyableType {
    int a;
    double b;
};

// 非平凡可复制类型：有一个自定义的拷贝构造函数
struct NonTrivialCopyableType {
    int a;
    double b;

    NonTrivialCopyableType() : a(0), b(0.0) {}
    NonTrivialCopyableType(const NonTrivialCopyableType& other) : a(other.a), b(other.b) {
        std::cout << "Custom copy constructor called\n";
    }
};

// 非平凡可复制类型：有一个虚函数，因此即使特殊成员函数都是默认的，它也不是平凡可复制的
struct NonTrivialTypeWithVirtualFunction {
    virtual void dummy() {}
};

int main() {
    TrivialCopyableType t1, t2;
    t2 = t1; // 平凡可复制类型的赋值操作是简单的位拷贝

    NonTrivialCopyableType nt1, nt2;
    nt2 = nt1; // 非平凡可复制类型的赋值操作调用了自定义的拷贝构造函数

    NonTrivialTypeWithVirtualFunction v1, v2;
    v2 = v1; // 赋值操作是平凡的，但由于虚函数的存在，类型不是平凡可复制的

    std::cout << "TrivialCopyableType is trivially:" 
              << std::is_trivially_copyable<TrivialCopyableType>::value << std::endl;
    std::cout << "NonTrivialCopyableType is trivially:" 
              << std::is_trivially_copyable<NonTrivialCopyableType>::value << std::endl;
    std::cout << "NonTrivialTypeWithVirtualFunction is trivially:" 
              << std::is_trivially_copyable<NonTrivialTypeWithVirtualFunction>::value << std::endl;

    return 0;
}

在这个示例中：

TrivialCopyableType 是一个平凡可复制类型，因为它没有自定义的特殊成员函数，且可以被简单地复制和移动。
NonTrivialCopyableType 有一个自定义的拷贝构造函数，所以它不是平凡可复制的。尽管它的赋值操作可能是平凡的，但拷贝构造函数的存在使得整个类型不是平凡可复制的。
NonTrivialTypeWithVirtualFunction 有一个虚函数，这使得它即使没有自定义的特殊成员函数，也不是平凡可复制的。虚函数的存在意味着类型需要有虚函数表（vtable），这违反了平凡可复制类型的定义。

平凡可复制类型在C++中很重要，因为它们可以被编译器优化为没有额外开销的位拷贝操作，这对于性能敏感的程序是非常有益的。

2.3 标准布局类型详细解读

在C++11中，标准布局类型（Standard-layout Type）是指那些在内存布局上满足特定规则的类型，这些规则确保了类型在不同的编译器和平台上具有一致的内存布局。一个类型是标准布局的，如果它满足以下条件：

类型的所有非静态数据成员都是公共的（public）。
类型不包含虚函数、虚基类或非标准布局的基类。
类型的所有基类都是标准布局类型。
类型不包含动态内存分配，如没有指向其自身类型的指针成员。
类型的所有数据成员的访问权限（public、protected、private）都是相同的。

以下是一组示例代码，展示了哪些类型是标准布局的，哪些不是：

#include <iostream>
#include <type_traits> // For std::is_standard_layout

// 标准布局类型：没有任何虚函数或虚基类，所有数据成员都是公共的
struct StandardLayoutType {
    int a;
    double b;
};

// 非标准布局类型：包含虚函数
struct NonStandardLayoutTypeWithVirtualFunction {
    virtual void dummy() {}
    int a;
    double b;
};

// 非标准布局类型：包含非标准布局基类
struct NonStandardBase {
    int a;
protected:
    double b; // Data member with non-public access
};

struct NonStandardLayoutTypeWithNonStandardBase : NonStandardBase {
    int c;
};

// 标准布局类型：尽管有继承，但基类是非虚继承且本身也是标准布局
struct StandardLayoutTypeWithInheritance : StandardLayoutType {
    char c;
};

int main() {
    std::cout << std::boolalpha; // Print bool values as true/false

    // 检查是否为标准布局类型
    std::cout << "Is StandardLayoutType standard layout? " << std::is_standard_layout<StandardLayoutType>::value << std::endl;
    std::cout << "Is NonStandardLayoutTypeWithVirtualFunction standard layout? " << std::is_standard_layout<NonStandardLayoutTypeWithVirtualFunction>::value << std::endl;
    std::cout << "Is NonStandardLayoutTypeWithNonStandardBase standard layout? " << std::is_standard_layout<NonStandardLayoutTypeWithNonStandardBase>::value << std::endl;
    std::cout << "Is StandardLayoutTypeWithInheritance standard layout? " << std::is_standard_layout<StandardLayoutTypeWithInheritance>::value << std::endl;

    return 0;
}

在这个示例中：

StandardLayoutType 是一个标准布局类型，因为它没有任何虚函数或虚基类，所有数据成员都是公共的。
NonStandardLayoutTypeWithVirtualFunction 不是标准布局类型，因为它包含一个虚函数。
NonStandardLayoutTypeWithNonStandardBase 不是标准布局类型，因为它有一个基类 NonStandardBase，该基类包含受保护的成员，不符合所有数据成员都是公共的规则。
StandardLayoutTypeWithInheritance 是一个标准布局类型，尽管它继承自 StandardLayoutType，但继承是不带虚函数的，且所有数据成员都是公共的。

使用 std::is_standard_layout 可以检查一个类型是否是标准布局类型。这在跨平台编程中非常重要，因为它保证了类型在不同平台上的ABI（应用二进制接口）兼容性。