结构体对齐详解

2023-05-16

1 -- 结构体数据成员对齐的意义

许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的起始地址的值是某个数k的倍数，这就是所谓的内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。这种强制的要求一来简化了处理器与内存之间传输系统的设计，二来可以提升读取数据的速度。
比如这么一种处理器，它每次读写内存的时候都从某个8倍数的地址开始，一次读出或写入8个字节的数据，假如软件能保证double类型的数据都从8倍数地址开始，那么读或写一个double类型数据就只需要一次内存操作。否则，我们就可能需要两次内存操作才能完成这个动作，因为数据或许恰好横跨在两个符合对齐要求的8字节内存块上。

2 -- 结构体对齐包括两个方面的含义

1)结构体总长度；
2)结构体内各数据成员的内存对齐，即该数据成员相对结构体的起始位置；

3 -- 结构体大小的计算方法和步骤

1)将结构体内所有数据成员的长度值相加，记为sum_a；
2)将各数据成员为了内存对齐，按各自对齐模数而填充的字节数累加到和sum_a上，记为sum_b。对齐模数是#pragma pack指定的数值以及该数据成员自身长度中数值较小者。该数据相对起始位置应该是对齐模式的整数倍;
3)将和sum_b向结构体模数对齐，该模数是【#pragma pack指定的数值】、【未指定#pragma pack时，系统默认的对齐模数（32位系统为4字节，64位为8字节）】和【结构体内部最大的基本数据类型成员】长度中数值较小者。结构体的长度应该是该模数的整数倍。

4 -- 结构体大小计算举例

在计算之前，我们首先需要明确的是各个数据成员的对齐模数，对齐模数和数据成员本身的长度以及pragma pack编译参数有关，其值是二者中最小数。如果程序没有明确指出，就需要知道编译器默认的对齐模数值。下表是Windows XP/DEV-C++和Linux/GCC中基本数据类型的长度和默认对齐模数。

		char	short	int	long	float	double	long long	long double
Win-32	长度	1	2	4	4	4	8	8	8
Win-32	模数	1	2	4	4	4	8	8	8
Linux-32	长度	1	2	4	4	4	8	8	12
Linux-32	模数	1	2	4	4	4	4	4	4
Linux-64	长度	1	2	4	8	4	8	8	16
Linux-64	模数	1	2	4	8	4	8	8	16

例子1：

struct my_struct 
{ 
    char a; 
    long double b; 
};

此例子Windows和Linux计算方法有些许不一致。
在Windows中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B = 9B --> sum_a = 9B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充7个字节，sum_a + 7 = 16B --> sum_b = 16 B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为4，所以结构体对齐模数是4。sum_b是4的4倍，不需再次对齐。
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图1-1所示。

在Linux中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 12B = 13B --> sum_a = 13B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_a + 3 = 16B --> sum_b = 16 B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为12后者为4，所以结构体对齐模数是4。sum_b是4的4倍，不需再次对齐。
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图1-2所示。

1-1

例子2：

#pragma pack(2) 
struct my_struct 
{ 
    char a; 
    long double b; 
}; 
#pragma pack()

例子1和例子2不同之处在于例子2中使用了#pragma pack(2)编译参数，它强制指定对齐模数是2。此例子Windows和Linux计算方法有些许不一致。

在Windows中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B = 13B --> sum_a = 9B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是2，之前需填充1个字节，sum_a + 1 = 10B --> sum_b = 10 B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为2，所以结构体对齐模数是2。sum_b是2的5倍，不需再次对齐。
综上3步，可知结构体的长度是10B，各数据成员在内存中的分布如图2-1所示。

在Linux中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 12B = 13B --> sum_a = 13B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是2，之前需填充1个字节，sum_a + 1 = 14B --> sum_b = 14 B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为2，所以结构体对齐模数是2。sum_b是2的7倍，不需再次对齐。
综上3步，可知结构体的长度是14B，各数据成员在内存中的分布如图2-2所示。

例子3：

struct my_struct 
{ 
    char a; 
    double b; 
    char c; 
};

前两例中，数据成员在Linux和Windows下都相同，例3中double的对齐模数在Linux中是4，在Windows下是8，针对这种模数不相同的情况加以分析。
在Windows中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B + 1B = 10B --> sum_a = 10B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充7个字节，sum_a + 7 = 17B --> sum_b = 17B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为8，所以结构体对齐模数是8。sum_b应该是8的整数倍，所以要在结构体后填充8*3 - 17 = 7个字节。
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图3-1所示。

在Linux中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B + 1B = 10B，sum_a = 10B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 13B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma
pack中较小者，前者为8后者为4，所以结构体对齐模数是4。sum_b应该是4的整数倍，所以要在结构体后填充4*4 - 13 = 3个字节。
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图3-2所示。

例子4：

struct my_struct 
{ 
    char a[11]; 
    int b; 
    char c; 
};

此例子Windows和Linux计算方法一样，如下：
步骤1：所有数据成员自身长度和：11B + 4B + 1B = 16B --> sum_a = 16B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_a + 1 = 17B --> sum_b = 17B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为4后者为4，所以结构体对齐模数是4。sum_b是4的整数倍，需在结构体后填充4*5 - 17 = 1个字节。
综上3步，可知结构体的长度是20B，各数据成员在内存中的分布如图4所示。

例子5：

struct my_test 
{ 
    int my_test_a; 
    char my_test_b; 
}; 
struct my_struct 
{ 
    struct my_test a; 
    double my_struct_a; 
    int my_struct_b; 
    char my_struct_c; 
};

例子5和前几个例子均不同，在此例子中我们要计算struct my_struct的大小，而my_struct中嵌套了一个my_test结构体。这种结构体应该如何计算呢？原则是将my_test在my_struct中先展开，然后再计算，即是展开成如下结构体：

struct my_struct
{
    int my_test_a;
    char my_test_b;
    double my_struct_a;
    int my_struct_b;
    char my_struct_c;
};

此例子Windows中的计算方法如下：
步骤1：所有数据成员自身长度和：4B + 1B + 8B + 4B + 1B= 18B --> sum_a = 18B
步骤2：数据成员my_struct_a为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充3个字节：sum_a + 3 = 21B --> sum_b = 21B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为8，所以结构体对齐模数是8。sum_b是8的整数倍，需在结构体后填充3*8 - 21 = 3个字节。
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图5所示。

此例子Linux中的计算方法如下：
步骤1：所有数据成员自身长度和：4B + 1B + 8B + 4B + 1B= 18B，sum_a = 18B
步骤2：数据成员my_struct_a为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 21B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma
pack中较小者，前者为4后者为4，所以结构体对齐模数是4。sum_b是4的整数倍，需在结构体后填充6*4 - 21 = 3个字节。
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图5所示。

5 -- 源代码附录

上面的例子均在Windows(VC++6.0)和Linux(GCC4.1.0)上测试验证。下面是测试程序。

#include <iostream>

#include <stdio.h>

using namespace std;

int main()
{
    cout << "sizeof(char)        = " << sizeof(char) << endl;
    cout << "sizeof(short)       = " << sizeof(short) << endl;
    cout << "sizeof(int)         = " << sizeof(int) << endl;
    cout << "sizeof(long)        = " << sizeof(long) << endl;
    cout << "sizeof(float)       = " << sizeof(float) << endl;
    cout << "sizeof(double)      = " << sizeof(double) << endl;
    cout << "sizeof(long long)   = " << sizeof(long long) << endl;
    cout << "sizeof(long double) = " << sizeof(long double) << endl << endl;    

    // 例子1
    {
        struct my_struct 
        { 
            char a; 
            long double b; 
        };
        cout << "exapmle-1: sizeof(my_struct) = " << sizeof(my_struct) << endl;
  
        struct my_struct data;
 
        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }

    // 例子2
    {
        #pragma pack(2) 
        struct my_struct 
        { 
            char a; 
            long double b; 
        }; 
        
        #pragma pack()
        struct my_struct data;
 
        cout << "exapmle-2: sizeof(my_struct) = " << sizeof(my_struct) << endl;
  
        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }
    
    // 例子3
    {
        struct my_struct 
        { 
            char a; 
            double b; 
            char c; 
        }; 
 
        struct my_struct data;
 
        cout << "exapmle-3: sizeof(my_struct) = " << sizeof(my_struct) << endl;
  
        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data.a, &data.b, &data.c);
    }

    // 例子4
    {
        struct my_struct 
        {  
            char a[11];  
            int b;  
            char c;  
        };
  
        cout << "example-4: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;
  
        struct my_struct data;
        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data, &data.b, &data.c);
    }

    // 例子5 
    {
        struct my_test 
        { 
            int my_test_a; 
            char my_test_b; 
        }; 
        
        struct my_struct 
        { 
            struct my_test a; 
            double my_struct_a; 
            int my_struct_b; 
            char my_struct_c; 
        }; 
        cout << "example-5: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;
  
        struct my_struct data;
        printf("my_struct->my_test_a  : %u\n"
            "my_struct->my_test_b  : %u\n"
            "my_struct->my_struct_a: %u\n"
            "my_struct->my_struct_b: %u\n"
            "my_struct->my_struct_c: %u\n", &data.a.my_test_a, &data.a.my_test_b, 
            &data.my_struct_a, &data.my_struct_b, &data.my_struct_c);
    }

    return 0;
}

执行结果：

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 28 19:20:26 UTC 2012 (641c197) x86_64 x86_64 x86_64 GNU/Linux
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 8
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 16

exapmle-1: sizeof(my_struct) = 32
my_struct->a: 2163695552
my_struct->b: 2163695568

exapmle-2: sizeof(my_struct) = 18
my_struct->a: 2163695680
my_struct->b: 2163695682

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2163695648
my_struct->b: 2163695656
my_struct->c: 2163695664

example-4: sizeof(my_struct) = 20
my_struct->a: 2163695616
my_struct->b: 2163695628
my_struct->c: 2163695632

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2163695584
my_struct->my_test_b  : 2163695588
my_struct->my_struct_a: 2163695592
my_struct->my_struct_b: 2163695600
my_struct->my_struct_c: 2163695604

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 26 09:36:26 UTC 2012 (641c197) i686 i686 i386 GNU/Linux
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 3213889904
my_struct->b: 3213889908

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 3213889890
my_struct->b: 3213889892

exapmle-3: sizeof(my_struct) = 16
my_struct->a: 3213889872
my_struct->b: 3213889876
my_struct->c: 3213889884

example-4: sizeof(my_struct) = 20
my_struct->a: 3213889852
my_struct->b: 3213889864
my_struct->c: 3213889868

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 3213889828
my_struct->my_test_b  : 3213889832
my_struct->my_struct_a: 3213889836
my_struct->my_struct_b: 3213889844
my_struct->my_struct_c: 3213889848

//CYGWIN_NT-6.1 motadou-PC 1.7.20(0.266/5/3) 2013-06-07 11:11 i686 Cygwin
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 2272336
my_struct->b: 2272340

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 2272322
my_struct->b: 2272324

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2272296
my_struct->b: 2272304
my_struct->c: 2272312

example-4: sizeof(my_struct) = 20
my_struct->a: 2272276
my_struct->b: 2272288
my_struct->c: 2272292

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2272248
my_struct->my_test_b  : 2272252
my_struct->my_struct_a: 2272256
my_struct->my_struct_b: 2272264
my_struct->my_struct_c: 2272268

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

结构体对齐详解的相关文章

干货 | 手把手教你搭建一套OpenStack云平台

1 前言今天我们为一位朋友搭建一套OpenStack云平台我们使用Kolla部署stein版本的OpenStack云平台 kolla是用于自动化部署OpenStack的一个项目 xff0c 它基于docker和ansible来实现 xf
完全卸载nginx的详细步骤

一个执着于技术的公众号前言在开局配置Nginx时有可能会配置错误 xff0c 报各种错误代码看不懂或者懒得去看这个报错时 xff0c 其实最简单的方式是卸载并重装咯今天就带大家一起学习下 xff0c 如何彻底卸载nginx程序卸载
Windows 11的这19个新功能，你都知道吗？

参考资料 xff1a https www windowslatest com 2021 10 06 windows 11 new features everything you need to know Windows 11 是 Windo
HttpClient 4.3 - 实现HTTP摘要认证（Digest authentication）

HttpClient 4 实现HTTP摘要认证 HttpClient 4 实现HTTP摘要认证什么是摘要认证用DefaultHttpClient实现HttpClient 4 3 实现什么是摘要认证说到摘要认证 Digest authe
全国DNS服务器IP地址大全、公共DNS大全

各省公共DNS服务器IP大全名称各省公共DNS服务器IP大全 114 DNS114 114 114 114114 114 115 115阿里 AliDNS223 5 5 5223 6 6 6百度 BaiduDNS180 76 76 76
如何在CentOS7上禁用或关闭SELinux

介绍 SELinux 是内置于 Linux 内核中的强制访问控制 MAC 执行器它限制了可能对系统构成威胁的个别服务的权限没有 SELinux 的 CentOS 系统依赖于其所有特权软件应用程序的配置单个错误配置可能会危及整个系统为
运维常用的 35 个Linux Shell 脚本，一定能帮到你！

作为一名 Linux 工程师 xff0c 会写好的脚本不仅能提高工作效率 xff0c 还能有更多的时间做自己的事最近在网上冲浪的时候 xff0c 也注意收集一些大佬写过的脚本 xff0c 汇总整理一下 xff0c 欢迎收藏 xff0c 与
超好用的开源 IP 地址管理系统，告别传统 Excel 统计方式！

来自 xff1a 释然IT杂谈一前言 xff1a 对于运维管理人员 xff0c ip地址进行管理很重要 xff0c 很多公司都是采用电子文档的形式 xff0c 以手工更新为主 xff0c 对ip地址和子网的实际使用情况无法进行有效的实时
Linux运维从入门到精通，看这一篇就够了~

作为一名 Linux 运维工程师 xff0c 总是会有种书到用时方恨少的感觉 xff0c 其根本原因还是技能掌握的不够扎实所以运维朋友一定要多学习 xff0c 提升技能 xff0c 下面分享一份专门针对运维朋友的资料包 xff0c 相
K8S CPU 请求和限制，是否有很好的选择？

Limits 和 Requests 并不是 CPU 管理的灵丹妙药 xff0c 在某些情况下 xff0c 其他替代方案可能是更好的选择在这篇博文中 xff0c 您将了解到 xff1a CPU requests 如何工作CPU limits
作为一名Linux用户，你得了解这15个工具！

来源 xff1a 浩道Linux 在普通人眼里 xff0c 使用Linux系统的用户本身已经很有极客范儿了 xff0c 但是在技术人员眼中 xff0c 这只是很普通的层级使用本文推荐的几个Linux系统下的工具 xff0c 能让你瞬间
虚拟网络namespace 到bridge

前言容器的网络是一大难点 xff0c 不管是docker 还是kubernetes 都绕不开计算机网络以下的介绍主要以计算机网络的namespace 和bridge 两个方面来展开介绍 xff0c 方便深入理解容器的网络原理 1 nam
用OpenCV实现目标追踪的八种方法（转）

原文地址 xff1a http m elecfans com article 722414 html 编者按 xff1a 目标跟踪作为机器学习的一个重要分支 xff0c 加之其在日常生活军事行动中的广泛应用 xff0c 很多国内外学者都对
turbostat超频检测工具

介绍 turbostat为Intel提供的超频检测工具 xff0c 可以真正在Linux下获取睿频频率的工具由下可知 xff1a 物理cpu个数为2 xff0c 核心数为14 xff0c 支持超线程 xff0c 逻辑cpu数为56 xff
C# HttpClient Digest 摘要认证 Cookie设置

C HttpClient Digest 摘要认证 Cookie设置 1 创建凭证信息集 2 创建HttpClientHandler 3 创建HttpClient 4 发生请求 span class token comment 创建凭证信息集
MongoDB 批量操作(bulkWrite)

一概述 mongodb 3 2 版中的新版本提供了db collection bulkWrite 方法提供了执行批量插入更新和删除操作的能力 mongodb 还支持批量插入 db collection insertMany 1 1 语法
Linux动态库的编译与使用(两种方式：链接进可执行程序、动态加载)

第一步 xff1a 编写Linux程序库文件1 动态库接口文件 span class token comment 动态库接口文件getmaxlen h span span class token macro property span c
ES 索引文档，按_id查找、更新、删除文档

一索引 xff08 新建 xff09 文档通过使用 index API xff0c 文档可以被索引存储和使文档可被搜索但是首先 xff0c 我们要确定文档的位置正如我们刚刚讨论的 xff0c 一个文档的 index type 和
ES排序

排序为了按照相关性来排序 xff0c 需要将相关性表示为一个数值在 Elasticsearch 中 xff0c 相关性得分由一个浮点数进行表示 xff0c 并在搜索结果中通过 score 参数返回 xff0c 默认排序是 score
ES基于completion suggest实现搜索提示

Term Suggester xff0c 基于编辑距离 xff0c 对analyze过的单个term去提供建议 xff0c 并不会考虑多个term 词组之间的关系 quert gt queryPhrase Suggester xff0c 在

随机推荐

时间间隔宏计算

对结果按时间间隔分桶 span class token macro property span class token directive keyword define span TIME INTERVAL a b a lt lt 32 4
容器环境下IP跨网闸映射kafka部署

一 listeners 和 advertised listeners 在公司内网部署 kafka 集群只需要用到 listeners xff0c 内外网需要作区分时才需要用到advertised listeners listeners 学名
C/C++ 中头文件相互包含引发的问题(was not declared in this scope)

问题引入最近遇到一个问题 xff0c 重构的代码编译报定义的某个宏was not declared in this scope xff0c 但是明明已经引入了包含此宏的头文件问题分析转载内容我把问题脱离于项目简单描述一下 xff1a
字符的全排列、字符的组合

一字符的全排列题目描述输入一个字符串按字典序打印出该字符串中字符的所有排列例如输入字符串abc 则打印出由字符a b c所能排列出来的所有字符串abc acb bac bca cab和cba 输入描述输入一个字符串长度不超过9
HTTP带用户名和密码请求

import java io IOException import org apache commons codec binary Base64 import com cn mid system urls UrlUtils import o
n*m的格子中正方形个数和长方形个数

问题描述 1 xff0e 设有一个nm方格的棋盘 xff08 1 m n 100 xff09 求出该棋盘中包含多少个正方形多少个长方形 xff08 不包括正方形 xff09 例如 xff1a 当n 61 2 xff0c m 61 3时正
Linux数字权限

linux系统文件夹从左至右 xff0c 第一位数字代表文件所有者的权限 xff1b 第二位数字代表同组用户的权限 xff1b 第三位数字代表其他用户的权限而具体的权限是由数字来表示的 xff1a 读取的权限等于4 xff0c 用r表示
八大排序算法C语言实现

1 插入排序 1 1 直接插入排序基本原理 xff1a 将第n个数插入已经排序好的 xff0c 长度为n 1的序列中从n 1长度的序列中查找出待插入的元素应该插入的位置 xff1b 给插入元素腾出空间操作方法 xff1a 从第2个数开
CLion下的gtest测试

在mac环境中 xff0c 使用CLion编译的简单gtest程序一下载gtest源码加入工程中 xff1a 二编写CMakeList txt 文件在文件中添加头文件和链接库文件 xff0c 并将链接库文件与目标文件进行链接 sp
python中json与dict的互相转换（编码与解码）及其简单实现

在json模块中将json转换为dict数据的方法有 xff1a load loads xff08 xff09 其中 xff0c load 方法从文件中提取数据进行转换将dict转换为json数据的方法有 xff1a dump dump
gtest中ASSERT与EXPECT断言的区别

参考资料查找到ASSERT断言与EXPECT断言的区别 xff1a ASSERT 系列的断言 xff0c 当检查点失败时 xff0c 退出当前函数 xff08 注意 xff1a 并非退出当前案例 xff09 EXPECT 系列的断言 xff
gtest参数化

步骤 xff1a 1 创建一个类 xff0c 继承testing TestWithParam xff0c T是你需要参数化的参数类型 xff0c 比如参数类型为int 2 使用新宏TEST P替代TEST 在TEST P宏里 xff0c 可
gtest中字符串比较是否相等

1 EXPECT EQ val1 xff0c val2 xff09 class StringCmpTest span class token punctuation span public testing span class token
白盒测试——逻辑覆盖

白盒测试中的逻辑覆盖有以下六种方法 xff1a 1 语句覆盖 xff1a 每个可执行语句至少被执行一次 2 判定覆盖 xff1a 每个判定的每个分支都至少执行一次 3 条件覆盖 xff1a 判定式中每个条件的每个分支至少执行一次 4 判定条
计算机网络面试题整理

面试很多时候被问到的问题 xff0c 感觉都没答好 xff0c 统一整理一下更新 8 23 GET和POST的区别 xff1f GET和POST方法没有实质上区别 xff0c 只是报文格式不同 GET和POST是HTTP协议中的两种请求方
【C语言】c/c++中常用的预定义宏：__LINE__, __func__, __FILE__, __DATE__, __TIME__

ANSI C标准中的预定义宏 xff08 也是常用的 xff09 xff1a LINE xff1a 在代码中插入当前行号 func xff1a 在代码中插入当前行所在的函数的函数名 FILE xff1a 在代码中插入当前文件的文件名 DAT
无人机入门知识

无人机入门知识无人机的定义现在提到的无人机 xff0c 通常是说无人飞行载具 xff08 Unmanned Aerial Vehicle xff0c 简称UAV xff09 xff0c 或称无人飞机无人飞机系统 xff08 Unm
http协议

一认识url url被称为统一资源定位符 xff0c 用来表示从互联网上得到的资源位置和访问这些资源的方法他的表示方法一般为 xff1a span class token operator lt span 协议 span class t
大小端区别和判断

在代码中看到往寄存器写数据的时候 xff0c 使用到 volatile uint32 t address 61 cpu to le32 value xff0c 进一步追踪 xff0c if BYTE ORDER 61 61 LITTLE E
结构体对齐详解

1 结构体数据成员对齐的意义许多实际的计算机系统对基本类型数据在内存中存放的位置有限制 xff0c 它们会要求这些数据的起始地址的值是某个数k的倍数 xff0c 这就是所谓的内存对齐 xff0c 而这个k则被称为该数据类型的对齐模数 al

结构体对齐详解

结构体对齐详解 的相关文章

随机推荐

热门标签

结构体对齐详解的相关文章