C++之std::is_trivially_copyable(平凡可复制类型检测)

2024-05-26 21:12
文章标签 c++ 类型 检测 std 复制 平凡 trivially copyable

本文主要是介绍C++之std::is_trivially_copyable(平凡可复制类型检测)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

1.C++基础回顾

1.1.平凡类型 

1.2.平凡可复制类型

1.3.标准布局类型

2.std::is_trivially_copyable

2.1.定义

2.2.使用

2.3.总结

1.C++基础回顾

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

1.1.平凡类型 

        指那些在内存中的行为非常简单的类。它们的构造函数、析构函数、拷贝构造函数和赋值运算符都没有自定义实现，完全由编译器提供的默认行为即可，而且也不能包含虚函数以及是虚基类的父类, 这意味着这些类的对象可以像基本数据类型一样被创建和销毁，不需要特殊的资源管理代码。

        以下是平凡类型和非平凡类型的示例代码展示，参考代码如下：

#include <iostream>// 平凡类型：没有任何自定义的构造函数、析构函数、拷贝控制成员
struct TrivialType {int a;double b;
};// 非平凡类型：至少有一个自定义的特殊成员函数
struct NonTrivialType1 {int a;double b;// 自定义构造函数NonTrivialType1() : a(0), b(0.0) {}// 自定义拷贝赋值运算符NonTrivialType1& operator=(const NonTrivialType1& other) {a = other.a;b = other.b;return *this;}// 自定义析构函数~NonTrivialType1() {std::cout << "NonTrivialType1 destroyed\n";}
};//使用=default关键字可以显式地声明默认的构造函数，从而使得类型恢复 “平凡化”。
struct TrivialType2 {int a;double b;// 自定义构造函数TrivialType2() : a(0), b(0.0) {}TrivialType2() = default;
};int main() {TrivialType t1, t2;t2 = t1; // 平凡类型的赋值操作是平凡的NonTrivialType nt1, nt2;nt2 = nt1; // 非平凡类型的赋值操作不是平凡的std::cout << "TrivialType is trivially:" << std::is_trivially<TrivialType>::value << std::endl; //输出：truestd::cout << "NonTrivialType1 is trivially:" << std::is_trivially<NonTrivialType1>::value << std::endl; //输出：falsestd::cout << "TrivialType2is trivially:" << std::is_trivially<TrivialType2>::value << std::endl; //输出: falsereturn 0;
}

        在这个示例中：

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

        TrivialType2虽然重新定义了构造函数，但是使用=default，使用=default关键字可以显式地声明默认的构造函数，从而使得类型恢复 “平凡化”。

注意事项：

即使类没有显示定义特殊成员函数，如果类中有虚函数或虚基类，它也不是平凡类型。
类中如果有动态内存分配（如指针成员）或需要特殊资源管理的成员，也不是平凡类型。
平凡类型的所有特殊成员函数都是平凡的，这意味着它们可以没有函数体（即使用编译器提供的默认实现）。
        平凡类型在C++中很重要，因为它们可以提高效率，允许编译器进行更多的优化。例如，平凡类型的拷贝和赋值可以通过简单的内存复制完成，而不需要调用任何成员函数。

1.2.平凡可复制类型

        是平凡类型的一个扩展，它不仅包括所有平凡类型，还包括那些可以安全地被复制和移动的类型，即使这些类型不是平凡类型。例如，一个类可能有一个自定义的构造函数，但如果它保证对象的内容可以通过简单的位拷贝（bitwise copy）来复制，那么它也可以被认为是平凡可复制的。它必须满足两个条件：

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

下列类型统称为可平凡复制类型：

  • 标量类型
  • 可平凡复制类类型
  • 上述类型的数组
  • 这些类型的有 cv 限定版本

说明：        

        一般来说，对于任何可平凡复制类型 T 及 T 对象 obj1，能复制 obj1 的底层字节到 char 或 unsigned char 或 std::byte (C++17 起) 的数组中，或到 T 的另一不同对象 obj2 中。obj1 与 obj2 均不可为潜在重叠的子对象。

        如果复制 obj1 的底层字节到这种数组中，然后复制结果内容回 obj1 中，那么 obj1 将保有其原值。如果复制 obj1 的底层字节到 obj2 中，那么 obj2 将保有 obj1 的值。

底层字节能由 std::memcpy 或 std::memmove 复制，只要不访问存活的 volatile 对象即可。

        具体示例我们将在后面给出。

1.3.标准布局类型

        指那些在内存布局上满足一定规则的类。这些规则包括所有非静态成员的访问权限必须相同，类不能有虚函数或虚基类，且所有基类也必须是标准布局类型。标准布局类型的一个重要特性是它们的内存布局在不同的编译器和平台上是一致的，这对于跨平台的二进制数据交换非常重要，它必须满足以下条件：

        1）类型的所有非静态数据成员都是公共的（public）。
        2）类型不包含虚函数、虚基类或非标准布局的基类。
        3）类型的所有基类都是标准布局类型。
        4）类型不包含动态内存分配，如没有指向其自身类型的指针成员。
        5）类型的所有数据成员的访问权限（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;
}

在这个示例中：

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

2.std::is_trivially_copyable

2.1.定义

它是在标头 <type_traits> 定义

template< class T >
struct is_trivially_copyable;

主要用来判断T是否平凡可复制类型。

并非非潜在重叠子对象的可平凡复制类型的对象，是仅有的能以 std::memcpy 安全复制或以 std::ofstream::write() / std::ifstream::read() 序列化自/到二进制文件的 C++ 对象。

2.2.使用

示例1：

#include <type_traits>struct A { int m; };
static_assert(std::is_trivially_copyable_v<A> == true);struct B { B(B const&) {} };
static_assert(std::is_trivially_copyable_v<B> == false);struct C { virtual void foo(); };
static_assert(std::is_trivially_copyable_v<C> == false);struct D
{int m;D(D const&) = default; // -> 可平凡复制D(int x) : m(x + 1) {}
};
static_assert(std::is_trivially_copyable_v<D> == true);int main() {}

在这个示例中：

        1) A是一个平凡可复制类型，因为它没有自定义的特殊成员函数，且可以被简单地复制和移动。
        2) B有一个自定义的拷贝构造函数，所以它不是平凡可复制的。尽管它的赋值操作可能是平凡的，但拷贝构造函数的存在使得整个类型不是平凡可复制的。
        3) C有一个虚函数，这使得它即使没有自定义的特殊成员函数，也不是平凡可复制的。虚函数的存在意味着类型需要有虚函数表（vtable），这违反了平凡可复制类型的定义。
        4) D虽然有一个自定义的拷贝构造函数，但是有一个使用=default的构造函数，所以它也是平凡可复制的。
        平凡可复制类型在C++中很重要，因为它们可以被编译器优化为没有额外开销的位拷贝操作，这对于性能敏感的程序是非常有益的。

示例2：

#include <iostream>
using namespace std;// trivially copyable
class A
{~A() = default;                    // trivially copyableA() {}                             // trivially copyableA(const A &) = default;            // trivially copyableA(A &&) = default;                 // trivially copyableA &operator=(const A &) = default; // trivially copyableA &operator=(A &&) = default;      // trivially copyable
};class B
{// 只要有任意自定义的下列行为即会变成 not trivially copyablevirtual void foo() = 0; // not trivially copyable// ~B() = delete;             // not trivially copyable// ~B() {}                    // not trivially copyable// B(const B &) {}            // not trivially copyable// B(B &&) {}                 // not trivially copyable// B &operator=(const B &) {} // not trivially copyable// B &operator=(B &&) {}      // not trivially copyable
};// not trivially copyable
class C : public B
{
};// trivially copyable
class D
{
public:explicit D(int val) : d(val) {}int d;
};void TriviallyCopyableTest()
{cout << std::is_trivially_copyable<bool>::value << endl;           // trivially copyablecout << std::is_trivially_copyable<char>::value << endl;           // trivially copyablecout << std::is_trivially_copyable<int>::value << endl;            // trivially copyablecout << std::is_trivially_copyable<float>::value << endl;          // trivially copyablecout << std::is_trivially_copyable<double>::value << endl;         // trivially copyablecout << std::is_trivially_copyable<std::nullptr_t>::value << endl; // trivially copyablecout << std::is_trivially_copyable<int *>::value << endl;          // trivially copyablecout << std::is_trivially_copyable<A>::value << endl;              // trivially copyablecout << std::is_trivially_copyable<A *>::value << endl;            // trivially copyablecout << std::is_trivially_copyable<B>::value << endl;              // not trivially copyablecout << std::is_trivially_copyable<B *>::value << endl;            // trivially copyablecout << std::is_trivially_copyable<C>::value << endl;              // not trivially copyablecout << std::is_trivially_copyable<string>::value << endl;         // not trivially copyable
}

分析方法同上，我们在这里就不赘述了。

2.3.总结

        在 C++11 及其之后的版本中，如果一个类型是可平凡复制的，那么你可以安全地通过 memcpy 或 memmove 等函数进行复制，而不需要担心可能的副作用（如析构函数的调用或虚函数的重新定向等）。然而，你应该注意，即使一个类型是可平凡复制的，也并不意味着你应该总是使用 memcpy 来进行复制；在许多情况下，使用赋值操作符或复制构造函数是更安全、更清晰的选择。

推荐阅读

可平凡复制类型

std::is_trivially_copyable

C++之std::is_pod(平凡的数据)

这篇关于C++之std::is_trivially_copyable(平凡可复制类型检测)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1005599。

相关文章

Win32下C++实现快速获取硬盘分区信息

Win32下C++实现快速获取硬盘分区信息

《Win32下C++实现快速获取硬盘分区信息》这篇文章主要为大家详细介绍了Win32下C++如何实现快速获取硬盘分区信息,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 实现代码CDiskDriveUtils.h#pragma once #include <wtypesbase
阅读更多...
Python如何在Word中生成多种不同类型的图表

Python如何在Word中生成多种不同类型的图表

《Python如何在Word中生成多种不同类型的图表》Word文档中插入图表不仅能直观呈现数据,还能提升文档的可读性和专业性,本文将介绍如何使用Python在Word文档中创建和自定义各种图表,需要的... 目录在Word中创建柱形图在Word中创建条形图在Word中创建折线图在Word中创建饼图在Word
阅读更多...
SpringBoot接收JSON类型的参数方式

SpringBoot接收JSON类型的参数方式

《SpringBoot接收JSON类型的参数方式》：本文主要介绍SpringBoot接收JSON类型的参数方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、jsON二、代码准备三、Apifox操作总结一、JSON在学习前端技术时，我们有讲到过JSON，而在
阅读更多...
通过Python脚本批量复制并规范命名视频文件

通过Python脚本批量复制并规范命名视频文件

《通过Python脚本批量复制并规范命名视频文件》本文介绍了如何通过Python脚本批量复制并规范命名视频文件,实现自动补齐数字编号、保留原始文件、智能识别有效文件等功能,听过代码示例介绍的非常详细,... 目录一、问题场景：杂乱的视频文件名二、完整解决方案三、关键技术解析1. 智能路径处理2. 精准文件名
阅读更多...
C++ Primer 标准库vector示例详解

C++ Primer 标准库vector示例详解

《C++Primer标准库vector示例详解》该文章主要介绍了C++标准库中的vector类型,包括其定义、初始化、成员函数以及常见操作,文章详细解释了如何使用vector来存储和操作对象集合,... 目录3.3标准库Vector定义和初始化vector对象通列表初始化vector对象创建指定数量的元素值
阅读更多...
C++实现回文串判断的两种高效方法

C++实现回文串判断的两种高效方法

《C++实现回文串判断的两种高效方法》文章介绍了两种判断回文串的方法：解法一通过创建新字符串来处理,解法二在原字符串上直接筛选判断,两种方法都使用了双指针法,文中通过代码示例讲解的非常详细,需要的朋友... 目录一、问题描述示例二、解法一：将字母数字连接到新的 string思路代码实现代码解释复杂度分析三、
阅读更多...
linux如何复制文件夹并重命名

linux如何复制文件夹并重命名

《linux如何复制文件夹并重命名》在Linux系统中,复制文件夹并重命名可以通过使用“cp”和“mv”命令来实现,使用“cp-r”命令可以递归复制整个文件夹及其子文件夹和文件,而使用“mv”命令可以... 目录linux复制文件夹并重命名我们需要使用“cp”命令来复制文件夹我们还可以结合使用“mv”命令总
阅读更多...
Rust中的BoxT之堆上的数据与递归类型详解

Rust中的BoxT之堆上的数据与递归类型详解

《Rust中的BoxT之堆上的数据与递归类型详解》本文介绍了Rust中的BoxT类型,包括其在堆与栈之间的内存分配,性能优势,以及如何利用BoxT来实现递归类型和处理大小未知类型,通过BoxT,Rus... 目录1. Box<T> 的基础知识1.1 堆与栈的分工1.2 性能优势2.1 递归类型的问题2.2
阅读更多...
C++一个数组赋值给另一个数组方式

C++一个数组赋值给另一个数组方式

《C++一个数组赋值给另一个数组方式》文章介绍了三种在C++中将一个数组赋值给另一个数组的方法：使用循环逐个元素赋值、使用标准库函数std::copy或std::memcpy以及使用标准库容器,每种方... 目录C++一个数组赋值给另一个数组循环遍历赋值使用标准库中的函数 std::copy 或 std::
阅读更多...
C++使用栈实现括号匹配的代码详解

C++使用栈实现括号匹配的代码详解

《C++使用栈实现括号匹配的代码详解》在编程中,括号匹配是一个常见问题,尤其是在处理数学表达式、编译器解析等任务时,栈是一种非常适合处理此类问题的数据结构,能够精确地管理括号的匹配问题,本文将通过C+... 目录引言问题描述代码讲解代码解析栈的状态表示测试总结引言在编程中，括号匹配是一个常见问题，尤其是在
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2