本文翻译自乔纳森·特纳（Jonathan Turner）和史蒂夫·弗朗西亚（Steve Francia）的文章《Rust vs. Go: Why They’re Better Together》。

史蒂夫·弗朗西亚（Steve Francia）：在过去的25年里，Steve Francia建立了一些最具创新性和成功的技术和公司，这些技术和公司已经成为云计算的基础，被全世界的企业和开发者所接受。他目前是谷歌Go编程语言的产品和战略负责人。他是Hugo、Cobra、Viper、spf13-vim和许多其他开源项目的创建者，拥有领导世界上最大的五个开源项目的独特荣誉。

乔纳森-特纳（Jonathan Turner）在开源领域工作了20多年，从小型项目到大型项目，包括帮助微软向开源转型。他是创建TypeScript团队的一员，并作为项目经理和设计团队的负责人帮助其成长。他还作为Rust社区成员和Mozilla Rust团队的一员参与Rust的工作，包括共同设计Rust的错误信息和IDE支持。

虽然其他人可能认为Rust和Go是竞争性的编程语言，但Rust和Go团队却都不这么认为。恰恰相反，我们的团队非常尊重其他团队正在做的事情，并认为这两种编程语言是相辅相成的，有着共同的愿景，即在整个行业内实现软件开发状态的现代化。

在本文中，我们将讨论Rust和Go的优缺点、它们如何相互补充和支持以及我们对每种语言的最佳使用时机的建议。

一些公司正在发掘采用这两种语言的价值以及它们的互补价值。为了从我们的观点转向用户的实际体验，我们采访了三家这样的公司，Dropbox 、Fastly和Cloudflare，讲述了他们共同使用Go和Rust的经验。他们的经验之谈将被引用并贯穿本文，为大家提供更进一步的观点。

1. 语言比较

2. 相似之处

Go和Rust有很多共同点。两者都是现代软件语言，都是出于为影响软件开发的问题提供一个安全和可扩展的解决方案的需要而诞生的。两者都是为了应对创建者在行业内现有语言中遇到的缺点而创建的，尤其是开发者生产力、可扩展性、安全性和并发性方面的缺点。

当今流行的大多数语言都是30多年前设计的。当这些语言被设计出来的时候，与今天有五个关键的区别：

• 摩尔定律被认为是永恒不变的。
• 大多数软件项目都是由小团队编写的，并且经常一个人单干。
• 大多数软件有相对较少的依赖性，大多数是专有的。
• 安全性是次要的考虑因素……或者根本不是考虑因素。
• 软件通常是为单一平台编写的。

相比之下，Rust和Go都是为今天的世界而写的，并都采取了相似的方法来设计一种适合今天开发需求的语言。

1) 性能和并发

Go和Rust都是专注于生产高效代码的编译语言。它们还可以方便地使用当今机器的多个处理器，使它们成为编写高效并行代码的理想语言。

“使用Go使得MercadoLibre公司将他们用于这项服务的服务器数量减少到原来的八分之一（从32台服务器减少到4台），另外，每台服务器可以用更少的功率运行（原来是4个CPU核，现在减少到2个CPU核）。有了Go，该公司省去了88%的服务器，并将剩余服务器上的CPU削减了一半–产生了巨大的成本节约。”–“MercadoLibre与Go一起成长”

“在我们严格管理的环境中，在我们运行Go代码的环境中，我们看到CPU减少了大约百分之十[与C++相比]，代码更干净，更可维护。” – Bala Natarajan，Paypal

“在AWS，我们也很喜欢Rust，因为它能帮助AWS编写高性能、安全的基础设施级网络和其他系统软件。亚马逊第一个用Rust构建的重要产品Firecracker于2018年公开发布，它提供了开源虚拟化技术，为AWS Lambda和其他无服务器产品提供动力。但我们也使用Rust来提供亚马逊简单存储服务（Amazon S3）、亚马逊弹性计算云（Amazon EC2）、Amazon CloudFront、Amazon Route 53等服务。最近，我们推出了基于Linux的容器操作系统Bottlerocket，它是用Rust编写的。” – Matt Asay，亚马逊网络服务

我们”看到我们的速度非凡地提高了1200-1500%! 我们从实现了较少解析规则的Scala的模式下的300-450ms，到实现了更多解析模式的Rust模式下的25-30ms！” – Josh Hannaford，IBM

2) 团队可扩展—-可审查

今天的软件开发是由团队建立的，这些团队不断成长和扩大，经常使用源码控制以分布式的方式进行协作。Go和Rust都是针对团队的工作方式而设计的，通过消除不必要的担忧，如格式(比如go的gofmt)、安全和复杂的组织，来改善代码审查。这两种语言都需要相对较少的上下文来理解代码的工作，使审查人员能够更快速地使用其他人编写的代码，并审查团队成员的代码和你团队以外的开源开发人员贡献的代码。

“我早期的职业生涯有Java和Ruby的背景，构建Go和Rust代码对我来说就像卸下了无法承受的重担。当我在Google时，遇到用Go编写的服务让我很欣慰，因为我知道它易于构建和运行。Rust的情况也是如此，尽管我只是在更小的工作范围内使用了它。我希望无限可配置的构建系统的日子已经过去了，而语言都有自己的专用构建工具，开箱即用。”– Sam Rose，CV合伙人。

“用Go写服务的时候，我往往会松一口气，因为与动态语言相比，Go的静态类型系统非常简单，易于推理，并发性是一等公民，Go的标准库既无比精致强大，又切中要害。安装一个标准的Go，再使用一个grpc库和一个数据库连接器，你在服务器端几乎不需要其他的东西，每个工程师都能看懂代码，看懂库。在用Rust编写模块时，Dropbox工程师在2019年Async-await稳定下来之前，感受到了Rust在服务器端的成长之痛，但从那时起，crate(译注：Rust中的概念)正在趋向于使用它，我们得到了Async模式并从并发中受益。” – Daniel Reiter Horn，Dropbox

3) 开放源码意识

今天一般软件项目所使用的依赖关系数量是惊人的。长达几十年的软件重用目标在现代开发中已经实现，今天的软件可能是复用了100多个项目而构建的。为此，开发人员使用软件仓库，这越来越成为软件开发的主旋律，并在越来越广泛的领域应用。开发者所包含的每一个软件包，又有自己的依赖关系。为今天的编程环境而设计出的编程语言需要毫不费力地处理这种复杂性。

Go和Rust都有包管理系统，允许开发人员列出一个简单的清单，列出他们想要构建的包，语言工具就会自动为他们获取和维护这些包，这样开发人员就可以把更多的精力放在自己的代码上，而不是放在对其他包的管理上。

4) 安全性

Go和Rust都很好地解决了当今应用的安全问题，保证了用这些语言构建的代码在运行时不会让用户暴露在各种经典的安全漏洞中，比如缓冲区溢出、use-after-free(内存释放后还使用)等。通过消除这些顾虑，开发者可以专注于手头的问题，并在默认情况下构建更安全的应用程序。

“Rust编译器在解决您遇到的错误时确实能助您一臂之力。这样一来，您就可以专注于自己的业务目标，而不必寻找错误或解密隐秘消息。” -Josh Hannaford，IBM

简而言之，Rust的灵活性，安全性和安全性带给我们的益处超过了必须遵循严格的lifetime，borrow(rust中的概念)和其他编译器规则甚至缺乏垃圾收集器所带来的任何不便。这些功能是云软件项目中非常需要的功能，将有助于避免其中常见的许多错误。” —微软高级泰勒·托马斯（Taylor Thomas）。

“Go是强静态类型化的，没有隐式转换，但语法开销还是小得惊人。这是通过赋值中简单的类型推理与非类型化的数值常量一起实现的。这使得Go比Java（有隐式转换）具有更强的类型安全性，但代码读起来更像Python（有非类型变量）。” – Stefan Nilsson，计算机科学教授。

“当我们在Dropbox构建用于存储块数据的Brotli压缩库时，我们将自己限制在Rust的安全子集上，而且，也限制在核心库（no-stdlib）上，分配器指定为通用。这样使用Rust的子集，使得在客户端从Rust调用Rust-Brotli库，以及在服务器上使用Python和Go的C FFI变得非常容易。这种编译模式也提供了大量的安全保障。经过一些调整，Rust Brotli的实现尽管是100%安全的、经过数组边界检查的代码，但仍然比C语言中相应的原生Brotli代码快。” – Daniel Reiter Horn，Dropbox

5) 真正的可移植性

在Go和Rust中，写一个软件，在许多不同的操作系统和架构上运行是很容易的。”一次编写，随处编译”。此外，Go和Rust都原生支持交叉编译，消除了旧编译语言常见的”build farm”的需要。

“Go在生产优化方面拥有很好的特质，比如拥有较小的内存占用，这支持其在大型项目中被用于构建模块，以及开箱即用，易于交叉编译到其他架构。由于Go代码被编译成单一的静态二进制，我们可以轻松将其容器化，并且通过扩展，我们可以很轻松地将Go部署到任何高可用环境（如Kubernetes）中。” – Dewet Diener，Curve。

“当你看一个基于云的基础设施时，通常你会使用类似Docker容器这样的东西来部署你的工作负载。通过在Go中构建的静态二进制，你可以拥有一个10、11、12兆字节的Docker文件，而不是带来整个Node.js生态系统，或像Python或Java那样动辄数百兆字节大小的Docker镜像文件。所以，交付那个微小的二进制文件是很神奇的。” – Brian Ketelsen，微软。

“有了Rust，我们将拥有一个高性能和可移植的平台，我们可以轻松地在Mac、iOS、Linux、Android和Windows上运行。” – Matt Ronge，Astropad。

3. 差异

在设计中，总是要做出一些取舍。虽然Go和Rust大约在同一时间出现，目标相似，但由于他们决策时选择了不同的取舍，使得这两种语言在关键的方面有所区别。

1) 性能方面

Go开箱即有出色的性能。在设计上，几乎没有预留任何旋钮或开关可以让你从Go中榨取更多的性能。Rust的设计是为了让您能够从代码中榨取每一滴性能；在这方面，您确实无法找到比Rust更快的语言。然而，Rust的性能提升是以额外的复杂性为代价的。

“值得注意的是，在编写Rust版本时，我们只在优化方面投入了非常基本的思考。即使只做了基本的优化，Rust的性能也能超过超手工调整的Go版本。这极大地证明了用Rust编写高效的程序是多么容易，相比之下，我们不得不对Go进行深挖。” – Jesse Howarth，Discord。

“Dropbox工程师通过将行对行的Python代码移植到Go中，往往可以看到5倍的性能提升和延迟下降，与Python相比，内存使用率往往会大幅下降，因为没有GIL，进程数可能会减少。然而，当我们的内存受限时，比如在桌面客户端软件或某些服务器进程中，我们会转而使用Rust，因为Rust中的手动内存管理效率大大高于Go GC。” – Daniel Reiter Horn，Dropbox

2) 适应性/交互性

Go快速迭代的优势让开发人员可以快速尝试各种想法，并磨合出能解决手头任务的工作代码。通常情况下，这就足够了，可以让开发者腾出手来处理其他任务。另一方面，与Go相比，Rust的编译时间更长，导致迭代时间更慢。这就导致了Go在一些场景中能更好地工作，因为更快的周转时间能让开发人员适应不断变化的需求，而Rust则在一些场景中茁壮成长，因为在这些场景中，可以给予更多的时间来做出更精致、更高性能的实现。

“Go类型系统的天才之处在于调用者可以定义Interface，允许库返回仅需满足小接口但却支持扩展的结构。Rust类型系统的天才设计在于匹配语法与Result<>的结合，你可以静态地确定每一种可能性都会被处理，永远不必发明空值来满足未使用的返回参数。” – Daniel Reiter Horn，Dropbox

“(我)如果你的用例离客户更近，更容易受到需求变化的影响，那么用Go就会好很多，因为持续重构的成本要便宜很多。这就是你能多快地表达新的需求并尝试它们。” – Peter Bourgon，Fastly

3) 可学性

简单来说，真的没有比Go更“平易近人”的语言了。有很多团队能够在几周内采用Go并将Go服务/应用投入生产的故事。此外，Go在语言中是比较独特的，它的语言设计和实践在它10多年的生命中是相当一致的。所以，投入到学习Go上的时间可以保持很长一段时间的价值。相比之下，Rust由于其复杂性，被认为是一门难学的语言。一般来说，学习Rust需要几个月的时间才能感觉到自如，但这种额外的复杂性也带来了精确的控制和性能的提高。

“当时，没有一个团队成员知道Go，但在一个月内，每个人都在用Go写作”–Jaime Garcia，Capital One。

“Go与其他编程语言不同的地方在于认知负担。你可以用更少的代码做更多的事情，这使得你更容易推理和理解你最终编写的代码。大多数Go代码最终看起来都很相似，所以，即使你在使用一个全新的代码库，你也可以很快上手并运行。” – Glen Balliet 美国运通忠诚度平台工程总监 美国运通使用Go进行支付和奖励

“然而，与其他编程语言不同，Go是为了最大限度地提高用户效率而创建的。因此，具有Java或PHP背景的开发人员和工程师可以在几周内获得使用Go的高级技能和培训–根据我们的经验，他们中的许多人最终都喜欢上了Go。” – Dewet Diener，Curve

4) 精确控制

也许Rust最大的优势之一就是开发者对如何管理内存、如何使用机器的可用资源、如何优化代码以及如何制作问题解决方案的控制。与Go相比，这并不是没有很大的复杂度成本，因为Go的设计并不是为了这种精确的制作，而是为了更快的探索时间和更快的周转时间。

“随着我们对Rust经验的增长，它在另外两个轴上显示出了优势：作为一种具有强大内存安全性的语言，它是边缘处理的好选择；作为一种具有巨大热情的语言，它成为了重写组件的流行语言。” – John Graham-Cumming，Cloudflare。

3. 总结/主要收获

Go的简单性、性能和开发人员的生产力使Go成为创建面向用户的应用程序和服务的理想语言。快速的迭代让团队能够快速地作出反应以满足用户不断变化的需求，让团队有办法将精力集中在灵活性上。

Rust更精细的控制允许更多的精确性，使得Rust成为低级操作的理想语言，这些低级操作不太可能发生变化，并且会从比Go略微提高的性能中受益，特别是在非常大的规模部署时。

Rust的优势在最接近“金属”(指底层机器)的地方。Go的优势是在离用户更近的地方最有利。这并不是说两者都不能在对方的空间里工作，但这样做会增加摩擦。当你的需求从灵活性转变为效率时，用Rust重写库的理由就更充分了。

虽然Go和Rust的设计有很大的不同，但它们的设计发挥了兼容的优势，而且–当一起使用时–既可以有很大的灵活性，又可以有很好的性能。

4. 我们的建议

对于大多数公司和用户来说，Go是正确的默认选择。它的性能很强，Go很容易采用，而且Go的高度模块化特性使它特别适合需求不断变化或发展的情况。

随着你的产品逐渐成熟，需求趋于稳定，可能会有机会从性能的边际增长中获得巨大的胜利。在这些情况下，使用Rust来最大限度地提高性能可能很值得你进行初始投资。

“Gopher部落”知识星球正式转正（从试运营星球变成了正式星球）！“gopher部落”旨在打造一个精品Go学习和进阶社群！高品质首发Go技术文章，“三天”首发阅读权，每年两期Go语言发展现状分析，每天提前1小时阅读到新鲜的Gopher日报，网课、技术专栏、图书内容前瞻，六小时内必答保证等满足你关于Go语言生态的所有需求！部落目前虽小，但持续力很强。在2021年上半年，部落将策划两个专题系列分享，并且是部落独享哦：

• Go技术书籍的书摘和读书体会系列
• Go与eBPF系列

欢迎各位Gopher加入！

Go技术专栏“改善Go语⾔编程质量的50个有效实践”正在慕课网火热热销中！本专栏主要满足广大gopher关于Go语言进阶的需求，围绕如何写出地道且高质量Go代码给出50条有效实践建议，上线后收到一致好评！欢迎大家订阅！目前该技术专栏正在新春促销！关注我的个人公众号“iamtonybai”，发送“go专栏活动”即可获取专栏专属优惠码，可在订阅专栏时抵扣20元哦(2021.2月末前有效)。

我的网课“Kubernetes实战：高可用集群搭建、配置、运维与应用”在慕课网热卖中，欢迎小伙伴们订阅学习！

我爱发短信：企业级短信平台定制开发专家 https://tonybai.com/。smspush : 可部署在企业内部的定制化短信平台，三网覆盖，不惧大并发接入，可定制扩展； 短信内容你来定，不再受约束, 接口丰富，支持长短信，签名可选。2020年4月8日，中国三大电信运营商联合发布《5G消息白皮书》，51短信平台也会全新升级到“51商用消息平台”，全面支持5G RCS消息。

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式：

• 微博：https://weibo.com/bigwhite20xx
• 微信公众号：iamtonybai
• 博客：tonybai.com
• github: https://github.com/bigwhite
• “Gopher部落”知识星球：https://public.zsxq.com/groups/51284458844544

微信赞赏：

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

我在日常工作中使用C语言中的位域(bit field)的场景甚少，原因大致有二：

* 一直从事于服务器后端应用的开发，现在的服务器的内存容量已经达到了数十G的水平，我们一般不需要为节省几个字节而使用内存布局更加紧凑的位域。
* 结构体中位域的实现是平台相关或Compiler相关的，移植性较差，我们不会贸然地给自己造“坑”的。

不过近期Linux技术内核社区（www.linux-kernel.cn) mail list中的一个问题让我觉得自己对bit field的理解还欠火候，于是乎我又花了些时间就着那个问题重新温习一遍bit field。

零、对bit field的通常认知

在C语言中，我们可以得到某个字节的内存地址，我们具备了操作任意内存字节的能力；在那个内存空间稀缺的年代，仅仅控制到字节级别还不足以满足C 程序员的胃口，为此C语言中又出现了bit级别内存的“有限操作能力” – 位域。这里所谓的“有限”指的是机器的最小粒度寻址单位是字节，我们无法像获得某个字节地址那样得到某个bit的地址，因此我们仅能通过字节的运算来设置 和获取某些bit的值。在C语言中，尝试获得一个bit field的地址是非法操作：

struct flag_t {
    int a : 1;
};

struct flag_t flg;
printf("%p\n", &flg.a);

error: cannot take address of bit-field ‘a’

以下是C语言中bit field的一般形式：

struct foo_t {
    unsigned int b1 : n1,
                 b2 : n2,
                 … …
                 bn : nk;
};

其中n1，n2，nk为对应位域所占据的bit数。

位域(bit field)的出现让我们可以用变量名代表某些bit，并通过变量名直接获得和设置一些内存中bit的值，而不是通 过晦涩难以理解的位操作来进行，例如：

struct foo_t {
    unsigned int a : 3,
                 b : 2,
                 c : 4;
};

struct foo_t f;
f.a = 3;
f.b = 1;
f.c = 12;

另外使用位域我们可以在展现和存储相同信息的同时，自定义更加紧凑的内存布局，节约内存的使用量。这使得bit field在嵌入式领域，在驱动程序领域得到广泛的应用，比如可以仅用两个字节就可以将tcpheader从dataoffset到fin的信息全部表示 和存储起来：

struct tcphdr {
    … …
    __u16   doff:4,
            res1:4,
            cwr:1,
            ece:1,
            urg:1,
            ack:1,
            psh:1,
            rst:1,
            syn:1,
            fin:1;
    … …
};

一、存储单元(storage unit)

C标准允许unsigned int/signed int/int类型的位域声明，C99中加入了_Bool类型的位域。但像Gcc这样的编译器自行加入了一些扩展，比如支持short、char等整型类 型的位域字段，使用其他类型声明位域将得到错误的结果，比如：

struct flag_t {
    char* a : 1;
};
 error: bit-field ‘a’ has invalid type

C编译器究竟是如何为bit field分配存储空间的呢？我们以Gcc编译器(Ubuntu 12.04.2 x86_64 Gcc 4.7.2 )为例一起来探究一下。

我们先来看几个基本的bit field类型的例子：

struct bool_flag_t {
    _Bool a : 1,
          b : 1;
};

struct char_flag_t {
    unsigned char a : 2,
                  b : 3;
};

struct short_flag_t {
    unsigned short a : 2,
                   b : 3;
};

struct int_flag_t {
    int a : 2,
        b : 3;
};

int
main()
{
    printf("%ld\n", sizeof(struct bool_flag_t));
    printf("%ld\n", sizeof(struct char_flag_t));
    printf("%ld\n", sizeof(struct short_flag_t));
    printf("%ld\n", sizeof(struct int_flag_t));

    return 0;
}

编译执行后的输出结果为：
1
1
2
4

可以看出Gcc为不同类型的bit field分配了不同大小的基本内存空间。_Bool和char类型的基本存储空间为1个字节；short类型的基本存储空间为2个字节，int型的为4 个字节。这些空间的分配是基于结构体内部的bit field的size没有超出基本空间的界限为前提的。以short_flag_t为例：

struct short_flag_t {
    unsigned short a : 2,
                   b : 3;
};

a、b两个bit field总共才使用了5个bit的空间，所以Compiler只为short_flag_t分配一个基本存储空间就可以存储下这两个bit field。如果bit field的size变大，size总和超出基本存储空间的size时，编译器会如何做呢？我们还是看例子：

struct short_flag_t {
    unsigned short a : 7,
                   b : 10;
};

将short_flag_t中的两个bit字段的size增大后，我们得到的sizeof(struct short_flag_t)变成了4，显然Compiler发现一个基础存储空间已经无法存储下这两个bit field了，就又为short_flag_t多分配了一个基本存储空间。这里我们所说的基本存储空间就称为“存储单元(storage unit)”。它是Compiler在给bit field分配内存空间时的基本单位，并且这些分配给bit field的内存是以存储单元大小的整数倍递增的。但从上面来看，不同类型bit field的存储单元大小是不同的。

sizeof(struct short_flag_t)变成了4，那a和b有便会有至少两种内存布局方式：
* a、b紧邻
* b在下一个可存储下它的存储单元中分配内存

具体采用哪种方式，是Compiler相关的，这会影响到bit field的可移植性。我们来测试一下Gcc到底采用哪种方式：

void
dump_native_bits_storage_layout(unsigned char *p, int bytes_num)
{

    union flag_t {
        unsigned char c;
        struct base_flag_t {
            unsigned int p7:1,
                         p6:1,
                         p5:1,
                         p4:1,
                         p3:1,
                         p2:1,
                         p1:1,
                         p0:1;
        } base;
    } f;

    for (int i = 0; i < bytes_num; i++) {
        f.c = *(p + i);
        printf("%d%d%d%d %d%d%d%d ",
                         f.base.p7,
                         f.base.p6, 
                         f.base.p5, 
                         f.base.p4, 
                         f.base.p3,
                         f.base.p2, 
                         f.base.p1, 
                         f.base.p0);
    }
    printf("\n");
}

struct short_flag_t {
    unsigned short a : 7,
                   b : 10;
};

 struct short_flag_t s;
 memset(&s, 0, sizeof(s));
 s.a = 113; /* 0111 0001 */
 s.b = 997; /* 0011 1110 0101 */

 dump_native_bits_storage_layout((unsigned char*)&s, sizeof(s));
 
编译执行后的输出结果为： 1000 1110 0000 0000 1010 0111 1100 0000。可以看出Gcc采用了第二种方式，即在为a分配内存后，发现该存储单元剩余的空间(9 bits)已经无法存储下字段b了，于是乎Gcc又分配了一个存储单元(2个字节)用来为b分配空间，而a与b之间也因此存在了空隙。

我们还可以通过匿名0长度位域字段的语法强制位域在下一个存储单元开始分配，例如：

struct short_flag_t {
    unsigned short a : 2,
                   b : 3;
};
这个结构体本来是完全可以在一个存储单元(2字节)内为a、b两个位域分配空间的。如果我们非要让b放在与a不同的存储单元中，我们可以通过加入 匿名0长度位域的方法来实现：

struct short_flag_t {
    unsigned short a : 2;
    unsigned short   : 0;
    unsigned short b : 3;
};

这样声明后，sizeof(struct short_flag_t)变成了4。

 struct short_flag_t s;
 memset(&s, 0, sizeof(s));
 s.a = 2; /* 10 */
 s.b = 4; /* 100 */

 dump_native_bits_storage_layout((unsigned char*)&s, sizeof(s));

执行后，输出的结果为：

0100 0000 0000 0000 0010 0000 0000 0000

可以看到位域b被强制放到了第二个存储单元中。如果没有那个匿名0长度的位域，那结果应该是这样的：

0100 1000 0000 0000

最后位域的长度是不允许超出其类型的最大长度的，比如：

struct short_flag_t {
    short a : 17;
};

error: width of ‘a’ exceeds its type

二、位域的位序

再回顾一下上一节的最后那个例子（不使用匿名0长度位域时）：

 struct short_flag_t s;
 memset(&s, 0, sizeof(s));
 s.a = 2; /* 10 */
 s.b = 4; /* 100 */

dump bits的结果为0100 1000 0000 0000。

怎么感觉输出的结果与s.a和s.b的值对不上啊！根据a和b的值，dump bits的输出似乎应该为1010 0000 0000 0000。对比这两个dump结果不同的部分：1010 0000 vs. 0100 1000，a和b的bit顺序恰好相反。之前一直与字节序做斗争，难不成bit也有序之分？事实就是这样的。bit也有order的概念，称为位序。位域字 段的内存位排序就称为该位域的位序。

我们来回顾一下字节序的概念，字节序分大端(big-endian，典型体系Sun Sparc)和小端(little-endian，典型体系Intel x86)：
大端指的是数值（比如0×12345678）的逻辑最高位(0×12)放在起始地址（低地址）上，简称高位低址，就是高位放在起始地址。
小端指的是数值（比如0×12345678）的逻辑最低位(0×78)放在起始地址（低地址）上，简称低位低址，就是低位放在起始地址。

看下面例子：

int
main()
{
    char c[4];
    unsigned int i = 0×12345678;
    memcpy(c, &i, sizeof(i));

    printf("%p – 0x%x\n", &c[0], c[0]);
    printf("%p – 0x%x\n", &c[1], c[1]);
    printf("%p – 0x%x\n", &c[2], c[2]);
    printf("%p – 0x%x\n", &c[3], c[3]);
}

在x86 (小端机器)上输出结果如下：

0x7fff1a6747c0 – 0×78
0x7fff1a6747c1 – 0×56
0x7fff1a6747c2 – 0×34
0x7fff1a6747c3 – 0×12

在sparc(大端机器)上输出结果如下：

ffbffbd0 – 0×12
ffbffbd1 – 0×34
ffbffbd2 – 0×56
ffbffbd3 – 0×78

通过以上输出结果可以看出，小端机器的数值低位0×78放在了低地址0x7fff1a6747c0上；而大端机器则是将数值高位0×12放在了低 地址0xffbffbd0上。

机器的最小寻址单位是字节，bit无法寻址，也就没有高低地址和起始地址的概念，我们需要定义一下bit的“地址”。以一个字节为例，我们把从左到右的8个bit的位置(position)命名按顺序命名如下：

p7 p6 p5 p4 p3 p2 p1 p0

其中最左端的p7为起始地址。这样以一字节大小的数值10110101(b)为例，其在不同平台下的内存位序如下：

大端的含义是数值的最高位1（最左边的1）放在了起始位置p7上，即数值10110101的大端内存布局为10110101。
小端的含义是数值的最低位1(最右边的1)放在了起始位置p7上，即数值10110101的小端内存布局为10101101。

前面的函数dump_native_bits_storage_layout也是符合这一定义的，即最左为起始位置。

同理，对于一个bit个数为3且存储的数值为110(b)的位域而言，将其3个bit的位置按顺序命名如下：

p2 p1 p0

其在大端机器上的bit内存布局，即位域位序为： 110;
其在小端机器上的bit内存布局，即位域位序为： 011。

在此基础上，理解上面例子中的疑惑就很简单了。

 s.a = 2; /* 10(b) ，大端机器上位域位序为 10，小端为01 */
 s.b = 4; /* 100(b)，大端机器上位域位序为100，小端为001 */

于是在x86（小端）上的dump bits结果为：0100 1000 0000 0000
而在sparc(大端）上的dump bits结果为：1010 0000 0000 0000

同时我们可以看出这里是根据位域进行单独赋值的，这样位域的位序是也是以位域为单位排列的，即每个位域内部独立排序， 而不是按照存储单元（这里的存储单元是16bit）或按字节内bit序排列的。

三、tcphdr定义分析

前面提到过在linux-kernel.cn mail list中的那个问题大致如下：

tcphdr定义中的大端代码：

__u16   doff:4,
        res1:4,
        cwr:1,
        ece:1,
        urg:1,
        ack:1,
        psh:1,
        rst:1,
        syn:1,
        fin:1;

问题是其对应的小端代码该如何做字段排序？似乎有两种方案摆在面前：

方案1:
__u16    res1:4,
         doff:4,
         fin:1,
         syn:1,
         rst:1,
         psh:1,
         ack:1,
         urg:1,
         ece:1,
         cwr:1;

or

方案2:
__u16   cwr:1,
        ece:1,
        urg:1,
        ack:1,
        psh:1,
        rst:1,
        syn:1,
        fin:1,
        res1:4
        doff:4;

个人觉得这两种方案从理论上都是没错的，关键还是看tcphdr是如何进行pack的，是按__u16整体打包，还是按byte打包。原代码中使用的是方 案1，推测出tcphdr采用的是按byte打包的方式，这样我们只需调换byte内的bit顺序即可。res1和doff是一个字节内的两个位域，如果 按自己打包，他们两个的顺序对调即可在不同端的平台上得到相同的结果。用下面实例解释一下：

假设在大端系统上，doff和res1的值如下：

doff res1
1100 1010 大端

在大端系统上pack后，转化为网络序：

doff res1
1100 1010 网络序

小端系统接收后，转化为本地序：

0101 0011

很显然，我们应该按如下方法对应：

res1 doff
0101 0011

也就相当于将doff和res1的顺序对调，这样在小端上依旧可以得到相同的值。