C++避坑指南(九)

平凡、标准布局

前阵子我和一个同事对这样一个问题进行了非常激烈的讨论:

到底应不应该定义 std::string 类型的全局变量

这个问题乍一看好像没什么值得讨论的地方,我相信很多程序员都在不经意间写过类似的代码,并且确实没有发现什么执行上的问题,所以可能从来没有意识到,这件事还有可能出什么问题。

我们和我同事之所以激烈讨论这个问题,一切的根源来源于谷歌的 C++编程规范,其中有一条是:

Static or global variables of class type are forbidden: they cause hard-to-find bugs due to indeterminate order of construction and destruction. Objects with static storage duration, including global variables, static variables, static class member variables, and function static variables, must be Plain Old Data (POD): only ints, chars, floats, or pointers, or arrays/structs of POD.

大致翻译一下就是说:不允许非 POD 类型的全局变量、静态全局变量、静态成员变量和静态局部变量,因为可能会导致难以定位的 bug。而std::string是非 POD 类型的,自然,按照规范,也不允许std::string类型的全局变量。

但是如果我们真的写了,貌似也从来没有遇到过什么问题,程序也不会出现任何 bug 或者异常,甚至下面的几种写法都是在日常开发中经常遇到的,但都不符合这谷歌的这条代码规范。

  • 全局字符串

const std::string ip = "127.0.0.1"; const uint16_t port = 80; void Demo() {   // 开启某个网络连接   SocketSvr svr{ip, port};   // 记录日志   WriteLog("net linked: ip:port={%s:%hu}", ip.c_str(), port); }

  • 静态映射表

std::string GetDesc(int code) {   static const std::unordered_map<int, std::string> ma {     {0, "SUCCESS"},     {1, "DATA_NOT_FOUND"},     {2, "STYLE_ILLEGEL"},     {-1, "SYSTEM_ERR"}   };   if (auto res = ma.find(code); res != ma.end()) {     return res->second;   }   return "UNKNOWN"; }

  • 单例模式

class SingleObj {  public:   SingleObj &GetInstance();   SingleObj(const SingleObj &) = delete;   SingleObj &operator =(const SingleObj &) = delete;  private:    SingleObj();    ~SingleObj(); }; SingleObj &SingleObj::GetInstance() {   static SingleObj single_obj;   return single_obj; }

上面的几个例子都存在“非 POD 类型全局或静态变量”的情况。

全局、静态的生命周期问题

既然谷歌规范中禁止这种情况,那一定意味着,这种写法存在潜在风险,我们需要搞明白风险点在哪里。 首先明确变量生命周期的问题:

  1. 全局变量和静态成员变量在主函数执行前构造,在主函数执行结束后释放;

  2. 静态局部变量在第一次执行到定义位置时构造,在主函数执行后释放。

这件事如果在 C 语言中,并没有什么问题,设计也很合理。但是 C++就是这样悲催,很多 C 当中合理的问题在 C++中会变得不合理,并且缺陷会被放大。

由于 C 当中的变量仅仅是数据,因此,它的“构造”和“释放”都没有什么副作用。但在 C++当中,“构造”是要调用构造函数来完成的,“释放”之前也是要先调用析构函数。这就是问题所在!照理说,主函数应该是程序入口,那么在主函数之前不应该调用任何自定义的函数才对。但这件事放到 C++当中就不一定成立了,我们看一下下面例程:

class Test {  public:   Test();   ~Test(); }; Test::Test() {   std::cout << "create" << std::endl; } Test::~Test() {   std::cout << "destroy" << std::endl; } Test g_test; // 全局变量 int main(int argc, const char *argv[]) {   std::cout << "main function" << std::endl;   return 0; }

运行上面程序会得到以下输出:

create main function destroy

也就是说,Test 的构造函数在主函数前被调用了。解释起来也很简单,因为“全局变量在主函数执行之前构造,主函数执行结束后释放”,而因为Test类型是类类型,“构造”时要调用构造函数,“释放”时要调用析构函数。所以上面的现象也就不奇怪了。

这种单一个的全局变量其实并不会出现什么问题,但如果有多变量的依赖,这件事就不可控了,比如下面例程:

test.h

struct Test1 {   int a; }; extern Test1 g_test1; // 声明全局变量

test.cc

Test1 g_test1 {4}; // 定义全局变量

main.cc

#include "test.h" class Test2 {  public:   Test2(const Test1 &test1); // 传Test1类型参数  private:   int m_; }; Test2::Test2(const Test1 &test1): m_(test1.a) {} Test2 g_test2{g_test1}; // 用一个全局变量来初始化另一个全局变量 int main(int argc, const char *argv) {   return 0; }

上面这种情况,程序编译、链接都是没问题的,但运行时会概率性出错,问题就在于,g_test1g_test2都是全局变量,并且是在不同文件中定义的,并且由于全局变量构造在主函数前,因此其初始化顺序是随机的

假如g_test1g_test2之前初始化,那么整个程序不会出现任何问题,但如果g_test2g_test1前初始化,那么在Test2的构造函数中,得到的就是一个未初始化的test1引用,这时候访问test1.a就是操作野指针了。

这时我们就能发现,全局变量出问题的根源在于全局变量的初始化顺序不可控,是随机的,因此,如果出现依赖,则会导致问题。 同理,析构发生在主函数后,那么析构顺序也是随机的,可能出问题,比如:

struct Test1 {   int count; }; class Test2 {  public:   Test2(Test1 *test1);   ~Test2();  private:   Test1 *test1_; }; Test2::Test2(Test1 *test1): test1_(test1) {   test1_->count++; } Test2::~Test2() {   test1_->count--; } Test1 g_test1 {0}; // 全局变量 void Demo() {   static Test2 t2{&g_test1}; // 静态局部变量 } int main(int argc, const char *argv[]) {   Demo(); // 构造了t2   return 0; }

在上面示例中,构造t2的时候使用了g_test1,由于t2是静态局部变量,因此是在第一个调用时(主函数中调用Demo时)构造。这时已经是主函数执行过程中了,因此g_test1已经构造完毕的,所以构造时不会出现问题。

但是,静态成员变量是在主函数执行完成后析构,这和全局变量相同,因此,t2g_test1析构顺序无法控制。如果t2g_test1先析构,那么不会出现任何问题。但如果g_test1t2先析构,那么在析构t2时,对test1_访问count成员这一步,就会访问野指针。因为test1_所指向的g_test1已经先行析构了。

那么这个时候我们就可以确定,全局变量、静态变量之间不能出现依赖关系,否则,由于其构造、析构顺序不可控,因此可能会出现问题。

谷歌标准中的规定

回到我们刚才提到的谷歌标准,这里标准的制定者正是因为担心这样的问题发生,才禁止了非 POD 类型的全局或静态变量。但我们分析后得知,也并不是说所有的类类型全局或静态变量都会出现问题。

而且,谷歌规范中的“POD 类型”的限定也过于广泛了。所谓“POD 类型”指的是“平凡”+“标准内存布局”,这里我来解释一下这两种性质,并且分析分析为什么谷歌标准允许 POD 类型的全局或静态变量。

平凡

“平凡(trivial)”指的是:

  1. 拥有默认无参构造函数

  2. 拥有默认析构函数

  3. 拥有默认拷贝构造函数

  4. 拥有默认移动构造函数

  5. 拥有默认拷贝赋值函数

  6. 拥有默认移动赋值函数

换句话说,六大特殊函数都是默认的。这里要区分 2 个概念,我们要的是“语法上的平凡”还是“实际意义上的平凡”。语法上的平凡就是说能够被编译期识别、认可的平凡。而实际意义上的平凡就是说里面没有额外操作。 比如说:

class Test1 {  public:   Test1() = default; // 默认无参构造函数   Test1(const Test1 &) = default; // 默认拷贝构造函数   Test &operator =(const Test1 &) = default; // 默认拷贝赋值函数   ~Test1() = default; // 默认析构函数 }; class Test2 {  public:   Test2() {} // 自定义无参构造函数,但实际内容为空   ~Test2() {std::printf("destory\n");} // 自定义析构函数,但实际内容只有打印 };

上面的例子中,Test1就是个真正意义上的平凡类型,语法上是平凡的,因此编译器也会认为其是平凡的。我们可以用 STL 中的工具来判断一个类型是否是平凡的:

bool is_test1_tri = std::is_trivial_v<Test1>; // true

但这里的 Test2,由于我们自定义了其无参构造函数和析构函数,那么对编译器来说,它就是非平凡的,我们用std::is_trivial来判断也会得到false_value。但其实内部并没有什么外链操作,所以其实我们把Test2类型定义全局变量时也不会出现任何问题,这就是所谓“实际意义上的平凡”。

C++对“平凡”的定义比较严格,但实际上我们看看如果要做全局变量或静态变量的时候,是不需要这样严格定义的。对于全局变量来说,只要定义全局变量时,使用的是“实际意义上平凡”的构造函数,并且拥有“实际意义上平凡”的析构函数,那这个全局变量定义就不会有任何问题。而对于静态局部变量来说,只要拥有“实际意义上平凡”的析构函数的就一定不会出问题。

标准内存布局

标准内存布局的定义是:

  1. 所有成员拥有相同的权限(比如说都public,或都protected,或都private);

  2. 不含虚基类、虚函数;

  3. 如果含有基类,基类必须都是标准内存布局;

  4. 如果函数成员变量,成员的类型也必须是标准内存布局。

我们同样可以用 STL 中的std::is_standard_layout来判断一个类型是否是标准内存布局的。这里的定义比较简单,不在赘述。

POD(Plain Old Data)类型

所谓 POD 类型就是同时符合“平凡”和“标准内存布局”的类型。符合这个类型的基本就是基本数据类型,加上一个普通 C 语言的结构体。换句话说,符合“旧类型(C 语言中的类型)行为的类型”,它不存在虚函数指针、不存在虚表,可以视为普通二进制来操作的。

因此,在 C++中,只有 POD 类型可以用memcpy这种二进制方法来复制而不会产生副作用,其他类型的都必须用用调用拷贝构造。

以前有人向笔者提出疑问,为何vector扩容时不直接用类似于memcpy的方式来复制,而是要以此调用拷贝构造。原因正是在此,对于非 POD 类型的对象,其中可能会包含虚表、虚函数指针等数据,复制时这些内容可能会重置,并且内部可能会含有一些类似于“计数”这样操作其他引用对象的行为,因为一定要用拷贝构造函数来保证这些行为是正常的,而不能简单粗暴地用二进制方式进行拷贝。

STL 中可以用std::is_pod来判断是个类型是否是 POD 的。

小结

我们再回到谷歌规范中,POD 的限制比较多,因此,确实 POD 类型的全局/静态变量是肯定不会出问题的,但直接将非 POD 类型的一棍子打死,笔者个人认为有点过了,没必要。

所以,笔者认为更加精确的限定应该是:对于全局变量、静态成员变量来说,初始化时必须调用的是平凡的构造函数,并且其应当拥有平凡的析构函数,而且这里的“平凡”是指实际意义上的平凡,也就是说可以自定义,但是在内部没有对任何其他的对象进行操作;对于静态局部变量来说,其应当拥有平凡的析构函数,同样指的是实际意义上的平凡,也就是它的析构函数中没有对任何其他的对象进行操作。

最后举几个例子:

class Test1 {  public:   Test1(int a): m_(a) {}   void show() const {std::printf("%d\n", m_);}  private:   int m_; }; class Test2 {  public:   Test2(Test1 *t): m_(t) {}   Test2(int a): m_(nullptr) {}   ~Test2() {}  private:   Test1 *m_; }; class Test3 {   public:    Test3(const Test1 &t): m_(&t) {}    ~Test3() {m_->show();}   private:    Test1 *m_; }; class Test4 {  public:   Test4(int a): m_(a) {}   ~Test4() = default;  private:   Test1 m_; };

Test1是非平凡的(因为无参构造函数没有定义),但它仍然可以定义全局/静态变量,因为Test1(int)构造函数是“实际意义上平凡”的。

Test2是非平凡的,并且Test2(Test1 *)构造函数需要引用其他类型,因此它不能通过Test2(Test1 *)定义全局变量或静态成员变量,但可以通过Test2(int)来定义全局变量或静态成员变量,因为这是一个“实际意义上平凡”的构造函数。而且因为它的析构函数是“实际意义上平凡”的,因此Test2类型可以定义静态局部变量。

Test3是非平凡的,构造函数对Test1有引用,并且析构函数中调用了Test1::show方法,因此Test3类型不能用来定义局部/静态变量。

Test4也是非平凡的,并且内部存在同样非平凡的Test1类型成员,但是因为m1_不是引用或指针,一定会随着Test4类型的对象的构造而构造,析构而析构,不存在顺序依赖问题,因此Test4可以用来定义全局/静态变量。

所以全局 std::string 变量到底可以不可以?

最后回到这个问题上,笔者认为定义一个全局的std::string类型的变量并不会出现什么问题,在std::string的内部,数据空间是通过new的方式申请的,并且一般情况下都不会被其他全局变量所引用,在std::string对象析构时,对这片空间会进行delete,所以并不会出现析构顺序问题。

但是,如果你用的不是默认的内存分配器,而是自定义了内存分配器的话,那确实要考虑构造析构顺序的问题了,你要保证在对象构造前,内存分配器是存在的,并且内存分配器的析构要在所有对象之后。

当然了,如果你仅仅是想给字符串常量起个别名的话,有一种更好的方式:

constexpr const char *ip = "127.0.0.1";

毕竟指针一定是平凡类型,而且用constexpr修饰后可以变为编译期常量。这里详情可以在后面“constexpr”的章节了解。

而至于其他类型的静态局部变量(比如说单例模式,或者局部内的map之类的映射表),只要让它不被析构就好了,所以可以用堆空间的方式:

static Test &Test::GetInstance() {   static Test &inst = *new Test;   return inst; }

std::string GetDesc(int code) {   static const auto &desc = *new std::map<int, std::string> {     {1, "desc1"},  {2, "desc2"},   };   auto iter = desc.find(code);   return iter == desc.end() ? "no_desc" : iter->second; }

非平凡析构类型的移动语义

在讨论完平凡类型后,我们发现平凡析构其实是更加值得关注的场景。这里就引申出非平凡析构的移动语义问题,请看例程:

class Buffer {  public:   Buffer(size_t size): buf(new int[size]), size(size) {}   ~Buffer() {delete [] buf;}   Buffer(const Buffer &ob): buf(new int[ob.size]), size(ob.size) {}   Buffer(Buffer &&ob): buf(ob.buf), size(ob.size) {}  private:   int *buf;   size_t size; }; void Demo() {   Buffer buf{16};   Buffer nb = std::move(buf); } // 这里会报错

还是这个简单的缓冲区的例子,如果我们调用Demo函数,那么结束时会报重复释放内存的异常。

那么在上面例子中,bufnb中的buf指向的是同一片空间,当Demo函数结束时,buf销毁会触发一次Buffer的析构,nb析构时也会触发一次Buffer的析构。而析构函数中是delete操作,所以堆空间会被释放两次,导致报错。

这也就是说,对于非平凡析构类型,其发生移动语义后,应当放弃对原始空间的控制

如果我们修改一下代码,那么这种问题就不会发生:

class Buffer {  public:   Buffer(size_t size): buf(new int[size]), size(size) {}   ~Buffer();   Buffer(const Buffer &ob): buf(new int[ob.size]), size(ob.size) {}   Buffer(Buffer &&ob): buf(ob.buf), size(ob.size) {ob.buf = nullptr;} // 重点在这里  private:   int *buf; }; Buffer::~Buffer() {   if (buf != nullptr) {     delete [] buf;   } } void Demo() {   Buffer buf{16};   Buffer nb = std::move(buf); } // OK,没有问题

由于移动构造函数和移动赋值函数是我们可以自定义的,因此,可以把重复析构产生的问题在这个里面考虑好。例如上面的把对应指针置空,而析构时再进行判空即可。

因此,我们得出的结论是并不是说非平凡析构的类型就不可以使用移动语义,而是非平凡析构类型进行移动构造或移动赋值时,要考虑引用权释放问题

原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/1264

转载文章受原作者版权保护。转载请注明原作者出处!

(0)
上一篇 2022年11月2日 下午12:20
下一篇 2022年11月2日 下午12:23

相关推荐