万字避坑指南!C++的缺陷与思考(下)

 

导读 | 在万字避坑指南!C++的缺陷与思考(上)一文中,微信后台开发工程师胡博豪,分享了C++的发展历史、右值引用与移动语义、类型说明符等内容,深受广大开发者喜爱!此篇,我们邀请作者继续总结其在C++开发过程中对一些奇怪、复杂的语法的理解和思考,分享C++开发的避坑指南。

static

我在前面章节吐槽了const这个命名,也吐槽了“右值引用”这个命名。那么static就是笔者下一个要重点吐槽的命名了。static这个词本身没有什么问题,其主要的槽点就在于“一词多用”,也就是说,这个词在不同场景下表示的是完全不同的含义。(作者可能是出于节省关键词的目的吧,明明是不同的含义,却没有用不同的关键词)。

第一,在局部变量前的static,限定的是变量的生命周期。

第二,在全局变量/函数前的static,限定的是变量/函数的作用域。

第三,在成员变量前的static,限定的是成员变量的生命周期。

第四在成员函数前的static,限定的是成员函数的调用方(或隐藏参数)。

上面是static关键字的4种不同含义,接下来我会逐一解释。

1)静态局部变量

当用static修饰局部变量时,static表示其生命周期:

void f() {
  static int count = 0;
  count++;
}

上述例子中,count是一个局部变量,既然已经是“局部变量”了,那么它的作用域很明显,就是f函数内部,而这里的static表示的是其生命周期。普通的全局变量在其所在函数(或代码块)结束时会被释放,而用static修饰的则不会,我们将其称为“静态局部变量”。静态局部变量会在首次执行到定义语句时初始化,在主函数执行结束后释放,在程序执行过程中遇到定义(和初始化)语句时会被忽略。

void f() {
   static int count = 0;
   count++;
   std::cout << count << std::endl;
}
int main(int argc, const char *argv[]) {
  f(); // 第一次执行时count被定义,并且初始化为0,执行后count值为1,并且不会释放
  f(); // 第二次执行时由于count已经存在,因此初始化语句会无视,执行后count值为2,并且不会释放
  f(); // 同上,执行后count值为3,不会释放
} // 主函数执行结束后会释放f中的count

例如上面例程的输出结果会是:

1
2
3

2)内部全局变量/函数

当static修饰全局变量或函数时,用于限定其作用域为“当前文件内”。同理,由于已经是“全局”变量了,生命周期一定是符合全局的,也就是“主函数执行前构造,主函数执行结束后释放”。至于全局函数就不用说了,函数都是全局生命周期的。因此,这时候的static不会再对生命周期有影响,而是限定了其作用域。与之对应的是extern。用extern修饰的全局变量/函数作用于整个程序内,换句话说,就是可以跨文件。‍

// a1.cc
int g_val = 4; // 定义全局变量
// a2.cc
extern int g_val; // 声明全局变量
void Demo() {
  std::cout << g_val << std::endl; // 使用了在另一个文件中定义的全局变量
}

而用static修饰的全局变量/函数则只能在当前文件中使用,不同文件间的static全局变量/函数可以同名,并且互相独立。

// a1.cc
static int s_val1 = 1; // 定义内部全局变量
static int s_val2 = 2; // 定义内部全局变量
static void f1() {} // 定义内部函数
// a2.cc
static int s_val1 = 6; // 定义内部全局变量,与a1.cc中的互不影响
static int s_val2; // 这里会视为定义了新的内部全局变量,而不会视为“声明”
static void f1(); // 声明了一个内部函数
void Demo() {
  std::cout << s_val1 << std::endl; // 输出6,与a1.cc中的s_val1没有关系
  std::cout << s_val2 << std::endl; // 输出0,同样不会访问到a1.cc中的s_val2
  f1(); // ERR,这里链接会报错,因为在a2.cc中没有找到f1的定义,并不会链接到a1.cc中的f1
}

所以我们发现,在这种场景下,static并不表示“静态”的含义,而是表示“内部”的含义,所以,为什么不再引入个类似于inner的关键字呢?这里很容易让程序员造成迷惑。

3)静态成员变量

静态成员变量指的是用static修饰的成员变量。普通的成员变量其生命周期是跟其所属对象绑定的。构造对象时构造成员变量,析构对象时释放成员变量。

struct Test {
  int a; // 普通成员变量
};


int main(int argc, const char *argv[]) {
  Test t; // 同时构造t.a
  auto t2 = new Test; // 同时构造t2->a
  delete t2; // t2所指对象析构,同时释放t2->a
} // t析构,同时释放t.a

而用static修饰后,其声明周期变为全局,也就是“主函数执行前构造,主函数执行结束后释放”,并且不再跟随对象,而是全局一份。

struct Test {
  static int a; // 静态成员变量(基本等同于声明全局变量)
};


int Test::a = 5; // 初始化静态成员变量(主函数前执行,基本等同于初始化全局变量)
int main(int argc, const char *argv[]) {
  std::cout << Test::a << std::endl; // 直接访问静态成员变量
  Test t;
  std::cout << t.a << std::endl; // 通过任意对象实例访问静态成员变量
} // 主函数结束时释放Test::a

所以静态成员变量基本就相当于一个全局变量,而这时的类更像一个命名空间了。唯一的区别在于,通过类的实例(对象)也可以访问到这个静态成员变量,就像上面的t.a和Test::a完全等价。

4)静态成员函数

static关键字修饰在成员函数前面,称为“静态成员函数”。我们知道普通的成员函数要以对象为主调方,对象本身其实是函数的一个隐藏参数(this指针):

struct Test {
  int a;
  void f(); // 非静态成员函数
};


void Test::f() {
  std::cout << this->a << std::endl;
}


void Demo() {
  Test t;
  t.f(); // 用对象主调成员函数
}

上面其实等价于:

struct Test {
  int a;
};


void f(Test *this) {
  std::cout << this->a << std::endl;
}


void Demo() {
  Test t;
  f(&t); // 其实对象就是函数的隐藏参数
}

也就是说,obj.f(arg)本质上就是f(&obj, arg),并且这个参数强制叫做this。这个特性在Go语言中尤为明显,Go不支持封装到类内的成员函数,也不会自动添加隐藏参数,这些行为都是显式的:

type Test struct {
  a int
}


func(t *Test) f() {
  fmt.Println(t.a) 
}


func Demo() {
  t := new(Test)
  t.f()
}

回到C++的静态成员函数这里来。用static修饰的成员函数表示“不需要对象作为主调方”,也就是说没有那个隐藏的this参数。

struct Test {
  int a;
  static void f(); // 静态成员函数
};


void Test::f() {
  // 没有this,没有对象,只能做对象无关操作
  // 也可以操作静态成员变量和其他静态成员函数
}

可以看出,这时的静态成员函数,其实就相当于一个普通函数而已。这时的类同样相当于一个命名空间,而区别在于,如果这个函数传入了同类型的参数时,可以访问私有成员,例如:

class Test {
 public:
   static void f(const Test &t1, const Test &t2); // 静态成员函数
 private:
   int a; // 私有成员
};


void Test::f(const Test &t1, const Test &t2) {
  // t1和t2是通过参数传进来的,但因为是Test类型,因此可以访问其私有成员
  std::cout << t1.a + t2.a << std::endl;
}

或者我们可以把静态成员函数理解为一个友元函数,只不过从设计角度上来说,与这个类型的关联度应该是更高的。但是从语法层面来解释,基本相当于“写在类里的普通函数”。

5)小结

其实C++中static造成的迷惑,同样也是因为C中的缺陷被放大导致的。毕竟在C中不存在构造、析构和引用链的问题。说到这个引用链,其实C++中的静态成员变量、静态局部变量和全局变量还存在一个链路顺序问题,可能会导致内存重复释放、访问野指针等情况的发生。这部分的内容详见后面“平凡、标准布局”的章节。总之,我们需要了解static关键字有多义性,了解其在不同场景下的不同含义,更有助于我们理解C++语言,防止踩坑。

08d6c6e9327c0bb9b487863cae862347.jpeg

平凡、标准布局

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

到底应不应该定义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类型的全局变量。(公司编程规范中并没有直接限制POD类型,而是限制了非平凡析构,它确实会比谷歌规范中用POD一刀砍会合理得多,但笔者仍然觉得其实限制仍然可以继续再放开些。可以参考公司C++编程规范第3.5条)

但是如果我们真的写了,貌似也从来没有遇到过什么问题,程序也不会出现任何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 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)全局、静态的生命周期问题

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

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

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

这件事如果在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_test1和g_test2都是全局变量,并且是在不同文件中定义的,并且

由于全局变量构造在主函数前,因此其初始化顺序是随机的

假如g_test1在g_test2之前初始化,那么整个程序不会出现任何问题,但如果g_test2在g_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已经构造完毕的,所以构造时不会出现问题。

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

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

2)谷歌标准中的规定

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

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

3)平凡

“平凡(trivial)”指的是:

拥有默认无参构造函数;

拥有默认析构函数;

拥有默认拷贝构造函数;

拥有默认移动构造函数;

拥有默认拷贝赋值函数;

拥有默认移动赋值函数。

换句话说,六大特殊函数都是默认的。这里要区分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; // true

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

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

4)标准内存布局

标准内存布局的定义是:

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

不含虚基类、虚函数;

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

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

我们同样可以用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 {
    {1, "desc1"},
  {2, "desc2"},
  };
  auto iter = desc.find(code);
  return iter == desc.end() ? "no_desc" : iter->second;
}

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

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

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函数,那么结束时会报重复释放内存的异常。

那么在上面例子中,buf和nb中的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,没有问题

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

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

bb2eef5592b24ab4b1509a687e2e9fe6.jpeg

私有继承和多继承

1)C++是多范式语言

在讲解私有继承和多继承之前,笔者要先澄清一件事:C++不是单纯的面相对象的语言。同样地,它也不是单纯的面向过程的语言,也不是函数式语言,也不是接口型语言……

真的要说,C++是一个多范式语言,也就是说它并不是为了某种编程范式来创建的。C++的语法体系完整且庞大,很多范式都可以用C++来展现。因此,不要试图用任一一种语言范式来解释C++语法,不然你总能找到各种漏洞和奇怪的地方。

举例来说,C++中的“继承”指的是一种语法现象,而面向对象理论中的“继承”指的是一种类之间的关系。这二者是有本质区别的,请读者一定一定要区分清楚。

以面向对象为例,C++当然可以面向对象编程(OOP),但由于C++并不是专为OOP创建的语言,自然就有OOP理论解释不了的语法现象。比如说多继承,比如说私有继承。

C++与java不同,java是完全按照OOP理论来创建的,因此所谓“抽象类”,“接口(协议)类”的语义是明确可以和OOP对应上的,并且,在OOP理论中,“继承”关系应当是"A is a B"的关系,所以不会存在A既是B又是C的这种情况,自然也就不会出现“多继承”这样的语法。

但是在C++中,考虑的是对象的布局,而不是OOP的理论,所以出现私有继承、多继承等这样的语法也就不奇怪了。

笔者曾经听有人持有下面这样类似的观点:

虚函数都应该是纯虚的;

含有虚函数的类不应当支持实例化(创建对象);

能实例化的类不应当被继承,有子类的类不应当被实例化;

一个类至多有一个“属性父类”,但可以有多个“协议父类”。

等等这些观点,它们其实都有一个共同的前提,那就是“我要用C++来支持OOP范式”。如果我们用OOP范式来约束C++,那么上面这些观点都是非常正确的,否则将不符合OOP的理论,例如:

class Pet {};
class Cat : public Pet {};
class Dog : public Pet {};


void Demo() {
  Pet pet; // 一个不属于猫、狗等具体类型,仅仅属于“宠物”的实例,显然不合理
}

Pet既然作为一个抽象概念存在,自然就不应当有实体。同理,如果一个类含有未完全实现的虚函数,就证明这个类属于某种抽象,它就不应该允许创建实例。而可以创建实例的类,一定就是最“具象”的定义了,它就不应当再被继承。

在OOP的理论下,多继承也是不合理的:

class Cat {};
class Dog {};
class SomeProperty : public Cat, public Dog {}; // 啥玩意会既是猫也是狗?

但如果是“协议父类”的多继承就是合理的:

class Pet { // 协议类
 public:
  virtual void Feed() = 0; // 定义了喂养方式就可以成为宠物
};


class Animal {};
class Cat : public Animal, public Pet { // 遵守协议,实现其需方法
 public:
  void Feed() override; // 实现协议方法
};

上面例子中,Cat虽然有2个父类,但Animal才是真正意义上的父类,也就是Cat is a (kind of) Animal的关系,而Pet是协议父类,也就是Cat could be a Pet,只要一个类型可以完成某些行为,那么它就可以“作为”这样一种类型。

在java中,这两种类型是被严格区分开的:

interface Pet { // 接口类
  public void Feed();
}


abstract class Animal {} // 抽象类,不可创建实例


class Cat extends Animal implements Pet {
  public void Feed() {}
}

子类与父类的关系叫“继承”,与协议(或者叫接口)的关系叫“实现”。

与C++同源的Objective-C同样是C的超集,但从名称上就可看出,这是“面向对象的C”,语法自然也是针对OOP理论的,所以OC仍然只支持单继承链,但可以定义协议类(类似于java中的接口类),“继承”和“遵守(类似于java中的实现语义)”仍然是两个分离的概念:

@protocol Pet  // 定义协议
- (void)Feed;
@end


@interface Animal : NSObject
@end


@interface Cat : Animal // 继承自Animal类,遵守Pet协议
- (void)Feed;
@end


@implementation Cat
- (void)Feed {
  // 实现协议接口
}
@end

相比,C++只能说“可以”用做OOP编程,但OOP并不是其唯一范式,也就不会针对于OOP理论来限制其语法。这一点,希望读者一定要明白。

2)私有继承与EBO

  • 私有继承本质不是「继承」

在此强调,这个标题中,第一个“继承”指的是一种C++语法,也就是class A : B {};这种写法。而第二个“继承”指的是OOP(面向对象编程)的理论,也就是A is a B的抽象关系,类似于“狗”继承自“动物”的这种关系。

所以我们说,私有继承本质是表示组合的,而不是继承关系,要验证这个说法,只需要做一个小实验即可。我们知道最能体现继承关系的应该就是多态了,如果父类指针能够指向子类对象,那么即可实现多态效应。请看下面的例程:

class Base {};
class A : public Base {};
class B : private Base {};
class C : protected Base {};


void Demo() {
  A a;
  B b;
  C c;


  Base *p = &a; // OK
  p = &b; // ERR
  p = &c; // ERR
}

这里我们给Base类分别编写了A、B、C三个子类,分别是public、private和protected继承。然后用Base *类型的指针去分别指向a、b、c。发现只有public继承的a对象可以用p直接指向,而b和c都会报这样的错:

Cannot cast 'B' to its private base class 'Base'
Cannot cast 'C' to its protected base class 'Base'

也就是说,私有继承是不支持多态的,那么也就印证了,他并不是OOP理论中的“继承关系”,但是,由于私有继承会继承成员变量,也就是可以通过b和c去使用a的成员,那么其实这是一种组合关系。或者,大家可以理解为,把b.a.member改写成了b.A::member而已。

那么私有继承既然是用来表示组合关系的,那我们为什么不直接用成员对象呢?为什么要使用私有继承?这是因为用成员对象在某种情况下是有缺陷的。

  • 空类大小

在解释私有继承的意义之前,我们先来看一个问题,请看下面例程

class T {};
// sizeof(T) = ?

T是一个空类,里面什么都没有,那么这时T的大小是多少?照理说,空类的大小就是应该是0,但如果真的设置为0的话,会有很严重的副作用,请看例程:

class T {};
void Demo() {
  T arr[10];
  sizeof(arr); // 0
  T *p = arr + 5;
  // 此时p==arr
  p++; // ++其实无效
}

发现了吗?假如T的大小是0,那么T指针的偏移量就永远是0,T类型的数组大小也将是0,而如果它成为了一个成员的话,问题会更严重:

struct Test {
  T t;
  int a;
};
// t和a首地址相同

由于T是0大小,那么此时Test结构体中,t和a就会在同一首地址。所以,为了避免这种0长的问题,编译器会针对于空类自动补一个字节的大小,也就是说其实sizeof(T)是1,而不是0

这里需要注意的是,不仅是绝对的空类会有这样的问题,只要是不含有非静态成员变量的类都有同样的问题,例如下面例程中的几个类都可以认为是空类:

class A {};
class B {
  static int m1;
  static int f();
};
class C {
public:
  C();
  ~C();
  void f1();
  double f2(int arg) const;
};

有了自动补1字节,T的长度变成了1,那么T*的偏移量也会变成1,就不会出现0长的问题。但是,这么做就会引入另一个问题,请看例程:

class Empty {};
class Test {
  Empty m1;
  long m2;
};
// sizeof(Test)==16

由于Empty是空类,编译器补了1字节,所以此时m1是1字节,而m2是8字节,m1之后要进行字节对齐,因此Test变成了16字节。如果Test中出现了很多空类成员,这种问题就会被继续放大。

这就是用成员对象来表示组合关系时,可能会出现的问题,而私有继承就是为了解决这个问题的。

  • 空基类成员压缩(EBO,Empty Base Class Optimization)

在上一节最后的历程中,为了让m1不再占用空间,但又能让Test中继承Empty类的其他内容(例如函数、类型重定义等),我们考虑将其改为继承来实现,EBO就是说,当父类为空类的时候,子类中不会再去分配父类的空间,也就是说这种情况下编译器不会再去补那1字节了,节省了空间。但如果使用public继承会怎么样?

class Empty {};
class Test : public Empty {
  long m2;
};


// 假如这里有一个函数让传Empty类对象
void f(const Empty &obj) {}
// 那么下面的调用将会合法
void Demo() {
  Test t;
  f(t); // OK
}

Test由于是Empty的子类,所以会触发多态性,t会当做Empty类型传入f中。这显然问题很大呀!如果用这个例子看不出问题的话,我们换一个例子:

class Alloc {
public:
  void *Create();
  void Destroy();
};


class Vector : public Alloc {
};


// 这个函数用来创建buffer
void CreateBuffer(const Alloc &alloc) {
  void *buffer = alloc.Create(); // 调用分配器的Create方法创建空间
}


void Demo() {
  Vector ve; // 这是一个容器
  CreateBuffer(ve); // 语法上是可以通过的,但是显然不合理
}

内存分配器往往就是个空类,因为它只提供一些方法,不提供具体成员。Vector是一个容器,如果这里用public继承,那么容器将成为分配器的一种,然后调用CreateBuffer的时候可以传一个容器进去,这显然很不合理呀!那么此时,用私有继承就可以完美解决这个问题了

class Alloc {
public:
  void *Create();
  void Destroy();
};


class Vector : private Alloc {
private:
  void *buffer;
  size_t size;
  // ...
};


// 这个函数用来创建buffer
void CreateBuffer(const Alloc &alloc) {
  void *buffer = alloc.Create(); // 调用分配器的Create方法创建空间
}


void Demo() {
  Vector ve; // 这是一个容器
  CreateBuffer(ve); // ERR,会报错,私有继承关系不可触发多态
}

此时,由于私有继承不可触发多态,那么Vector就并不是Alloc的一种,也就是说,从OOP理论上来说,他们并不是继承关系。而由于有了私有继承,在Vector中可以调用Alloc里的方法以及类型重命名,所以这其实是一种组合关系。而又因为EBO,所以也不用担心Alloc占用Vector的成员空间的问题。

谷歌规范中规定了继承必须是public的,这主要还是在贴近OOP理论。另一方面就是说,虽然使用私有继承是为了压缩空间,但一定程度上也是牺牲了代码的可读性,让我们不太容易看得出两种类型之间的关系,因此在绝大多数情况下,还是应当使用public继承。不过笔者仍然持有“万事皆不可一棒子打死”的观点,如果我们确实需要EBO的特性否则会大幅度牺牲性能的话,那么还是应当允许使用私有继承。

3)多继承

与私有继承类似,C++的多继承同样是“语法上”的继承,而实际意义上可能并不是OOP中的“继承”关系。再以前面章节的Pet为例:

class Pet {
 public:
  virtual void Feed() = 0;
};


class Animal {};


class Cat : public Animal, public Pet {
 public:
  void Feed() override;
};

从形式上来说,Cat同时继承自Anmial和Pet,但从OOP理论上来说,Cat和Animal是继承关系,而和Pet是实现关系,前面章节已经介绍得很详细了,这里不再赘述。

但由于C++并不是完全针对OOP的,因此支持真正意义上的多继承,也就是说,即便父类不是这种纯虚类,也同样支持集成,从语义上来说,类似于“交叉分类”。请看示例:

class Organic { // 有机物
};
class Inorganic { // 无机物
};
class Acid { // 酸
};
class Salt { // 盐
};


class AceticAcid : public Organic, public Acid { // 乙酸
};
class HydrochloricAcid : public Inorganic, public Acid { // 盐酸
};
class SodiumCarbonate : public Inorganic, public Salt { // 碳酸钠
};

上面就是一个交叉分类法的例子,使用多继承语法合情合理。如果换做其他OOP语言,可能会强行把“酸”或者“有机物”定义为协议类,然后用继承+实现的方式来完成。但如果从化学分类上来看,无论是“酸碱盐”还是“有机物无机物”,都是一种强分类,比如说“碳酸钠”,它就是一种“无机物”,也是一种“盐”,你并不能用类似于“猫是一种动物,可以作为宠物”的理论来解释,不能说“碳酸钠是一种盐,可以作为一种无机物”。

因此C++中的多继承是哪种具体意义,取决于父类本身是什么。如果父类是个协议类,那这里就是“实现”语义,而如果父类本身就是个实际类,那这里就是“继承”语义。当然了,像私有继承的话表示是“组合”语义。不过C++本身并不在意这种语义,有时为了方便,我们也可能用公有继承来表示组合语义,比如说:

class Point {
 public:
  double x, y;
};


class Circle : public Point {
 public:
  double r; // 半径
};

这里Circle继承了Point,但显然不是说“圆是一个点”,这里想表达的就是圆类“包含了”点类的成员,所以只是为了复用。从意义上来说,Circle类中继承来的x和y显然表达的是圆心的坐标。不过这样写并不符合设计规范,但笔者用这个例子希望解释的是C++并不在意类之间实际是什么关系,它在意的是数据复用,因此我们更需要了解一下多继承体系中的内存布局。

对于一个普通的类来说,内存布局就是按照成员的声明顺序来布局的,与C语言中结构体布局相同,例如:

class Test1 {
 public:
  char a;
  int b;
  short c;
};

那么Test1的内存布局就是

字节编号 内容
0 a
1~3 内存对齐保留字节
4~7 b
8~9 c
9~11 内存对齐保留字节

但如果类中含有虚函数,那么还会在末尾添加虚函数表的指针,例如:

class Test1 {
 public:
  char a;
  int b;
  short c;


  virtual void f() {}
};
字节编号 内容
0 a
1~3 内存对齐保留字节
4~7 b
8~9 c
9~15 内存对齐保留字节
16~23 虚函数表指针

多继承时,第一父类的虚函数表会与本类合并,其他父类的虚函数表单独存在,并排列在本类成员的后面。

4)菱形继承与虚拟继承

C++由于支持“普适意义上的多继承”,那么就会有一种特殊情况——菱形继承,请看例程:

struct A {
  int a1, a2;
};


struct B : A {
  int b1, b2;
};


struct C : A {
  int c1, c2;
};


struct D : B, C {
  int d1, d2;
};

根据内存布局原则,D类首先是B类的元素,然后D类自己的元素,最后是C类元素:

字节序号 意义
0~15 B类元素
16~19 d1
20~23 d2
24~31 C类元素

如果再展开,会变成这样:

字节序号 意义
0~3 a1(B类继承自A类的)
4~7 a2(B类继承自A类的)
8~11 b1
12~15 b2
16~19 d1
20~23 d2
24~27 a1(C类继承自A类的)
28~31 a2(C类继承自A类的)
32~35 c1
36~39 c2

可以发现,A类的成员出现了2份,这就是所谓“菱形继承”产生的副作用。这也是C++的内存布局当中的一种缺陷,多继承时第一个父类作为主父类合并,而其余父类则是直接向后扩写,这个过程中没有去重的逻辑(详情参考上一节)。这样的话不仅浪费空间,还会出现二义性问题,例如d.a1到底是指从B继承来的a1还是从C里继承来的呢?

C++引入虚拟继承的概念就是为了解决这一问题。但怎么说呢,C++的复杂性往往都是因为为了解决一种缺陷而引入了另一种缺陷,虚拟继承就是非常典型的例子,如果你直接去解释虚拟继承(比如说和普通继承的区别)你一定会觉得莫名其妙,为什么要引入一种这样奇怪的继承方式。所以这里需要我们了解到,它是为了解决菱形继承时空间爆炸的问题而不得不引入的。

首先我们来看一下普通的继承和虚拟继承的区别:普通继承:

struct A {
  int a1, a2;
};


struct B : A {
  int b1, b2;
};

B的对象模型应该是这样的: 

万字避坑指南!C++的缺陷与思考(下)_第1张图片

 而如果使用虚拟继承:

struct A {
  int a1, a2;
};


struct B : virtual A {
  int b1, b2;
};

对象模型是这样的: 

万字避坑指南!C++的缺陷与思考(下)_第2张图片

虚拟继承的排布方式就类似于虚函数的排布,子类对象会自动生成一个虚基表来指向虚基类成员的首地址。

就像刚才说的那样,单纯的虚拟继承看上去很离谱,因为完全没有必要强行更换这样的内存布局,所以绝大多数情况下我们是不会用虚拟继承的。但是菱形继承的情况,就不一样了,普通的菱形继承会这样:

struct A {
  int a1, a2;
};


struct B : A {
  int b1, b2;
};


struct C : A {
  int c1, c2;
};


struct D : B, C {
  int d1, d2;
};

D的对象模型:  

万字避坑指南!C++的缺陷与思考(下)_第3张图片

但如果使用虚拟继承,则可以把每个类单独的东西抽出来,重复的内容则用指针来指向:

struct A {
  int a1, a2;
};


struct B : virtual A {
  int b1, b2;
};


struct C : virtual A {
  int c1, c2;
};


struct D : B, C {
  int d1, d2;
};

D的对象模型将会变成:  

万字避坑指南!C++的缺陷与思考(下)_第4张图片

也就是说此时,共有的虚基类只会保存一份,这样就不会有二义性,同时也节省了空间。

但需要注意的是,D继承自B和C时是普通继承,如果用了虚拟继承,则会在D内部又额外添加一份虚基表指针。要虚拟继承的是B和C对A的继承,这也是虚拟继承语法非常迷惑的地方,也就是说,菱形继承的分支处要用虚拟继承,而汇聚处要用普通继承。所以我们还是要明白其底层原理,以及引入这个语法的原因(针对解决的问题),才能更好的使用这个语法,避免出错。

82845254a1b85a56189f48f59dabc0d3.jpeg

隐式构造

隐式构造指的就是隐式调用构造函数。换句话说,我们不用写出类型名,而是仅仅给出构造参数,编译期就会自动用它来构造对象。举例来说:

class Test {
 public:
  Test(int a, int b) {}
};


void f(const Test &t) {
}


void Demo() {
 f({1, 2}); // 隐式构造Test临时对象,相当于f(Test{a, b})
}

上面例子中,f需要接受的是Test类型的对象,然而我们在调用时仅仅使用了构造参数,并没有指定类型,但编译器会进行隐式构造。

尤其,当构造参数只有1个的时候,可以省略大括号:

class Test {
 public:
  Test(int a) {}
  Test(int a, int b) {}
};


void f(const Test &t) {
}


void Demo() {
  f(1); // 隐式构造Test{1},单参时可以省略大括号
  f({2}); // 隐式构造Test{2}
  f({1, 2}); // 隐式构造Test{1, 2}
}

这样做的好处显而易见,就是可以让代码简化,尤其是在构造string或者vector的时候更加明显:

void f1(const std::string &str) {}
void f2(const std::vector &ve) {}


void Demo() {
  f1("123"); // 隐式构造std::string{"123"},注意字符串常量是const char *类型
  f2({1, 2, 3}); // 隐式构造std::vector,注意这里是initialize_list构造
}

当然,如果遇到函数重载,原类型的优先级大于隐式构造,例如:

class Test {
public:
  Test(int a) {}
};


void f(const Test &t) {
  std::cout << 1 << std::endl;
}


void f(int a) {
  std::cout << 2 << std::endl;
}


void Demo() {
  f(5); // 会输出2
}

但如果有多种类型的隐式构造则会报二义性错误:

class Test1 {
public:
  Test1(int a) {}
};


class Test2 {
public:
  Test2(int a) {}
};


void f(const Test1 &t) {
  std::cout << 1 << std::endl;
}


void f(const Test2 &t) {
  std::cout << 2 << std::endl;
}


void Demo() {
  f(5); // ERR,二义性错误
}

在返回值场景也支持隐式构造,例如:

struct err_t {
  int err_code;
  const char *err_msg;
};


err_t f() {
  return {0, "success"}; // 隐式构造err_t
}

但隐式构造有时会让代码含义模糊,导致意义不清晰的问题(尤其是单参的构造函数),例如:

class System {
 public:
  System(int version);
};


void Operate(const System &sys, int cmd) {}


void Demo() {
  Operate(1, 2); // 意义不明确,不容易让人意识到隐式构造
}

上例中,System表示一个系统,其构造参数是这个系统的版本号。那么这时用版本号的隐式构造就显得很突兀,而且只通过Operate(1, 2)这种调用很难让人想到第一个参数竟然是System类型的。

因此,是否应当隐式构造,取决于隐式构造的场景,例如我们用const char *来构造std::string就很自然,用一组数据来构造一个std::vector也很自然,或者说,代码的阅读者非常直观地能反应出来这里发生了隐式构造,那么这里就适合隐式构造,否则,这里就应当限定必须显式构造。用explicit关键字限定的构造函数不支持隐式构造:

class Test {
 public:
  explicit Test(int a);
  explicit Test(int a, int b);
  Test(int *p);
};


void f(const Test &t) {}


void Demo() {
  f(1); // ERR,f不存在int参数重载,Test的隐式构造不允许用(因为有explicit限定),所以匹配失败
  f(Test{1}); // OK,显式构造
  f({1, 2}); // ERR,同理,f不存在int, int参数重载,Test隐式构造不许用(因为有explicit限定),匹配失败
  f(Test{1, 2}); // OK,显式构造


  int a;
  f(&a); // OK,隐式构造,调用Test(int *)构造函数 
}

还有一种情况就是,对于变参的构造函数来说,更要优先考虑要不要加explicit,因为变参包括了单参,并且默认情况下所有类型的构造(模板的所有实例,任意类型、任意个数)都会支持隐式构造,例如:

class Test {
 public:
  template 
  Test(Args&&... args);
};


void f(const Test &t) {}


void Demo() {
  f(1); // 隐式构造Test{1}
  f({1, 2}); // 隐式构造Test{1, 2}
  f("abc"); // 隐式构造Test{"abc"}
  f({0, "abc"}); // 隐式构造Test{0, "abc"}
}

所以避免爆炸(生成很多不可控的隐式构造),对于变参构造最好还是加上
explicit,如果不加的话一定要慎重考虑其可能实例化的每一种情况。

在谷歌规范中,单参数构造函数必须用explicit限定(公司规范中也是这样的,可以参考公司C++编程规范第4.2条),但笔者认为这个规范并不完全合理,在个别情况隐式构造意义非常明确的时候,还是应当允许使用隐式构造。另外,即便是多参数的构造函数,如果当隐式构造意义不明确时,同样也应当用explicit来限定。所以还是要视情况而定。C++支持隐式构造,自然考虑的是一些场景下代码更简洁,但归根结底在于C++主要靠STL来扩展功能,而不是语法。举例来说,在Swift中,原生语法支持数组、map、字符串等:

let arr = [1, 2, 3] // 数组
let map = [1 : "abc", 25 : "hhh", -1 : "fail"] // map
let str = "123abc" // 字符串

因此,它并不需要所谓隐式构造的场景,因为语法本身已经表明了它的类型。

而C++不同,C++并没有原生支持std::vector、std::map、std::string等的语法,这就会让我们在使用这些基础工具的时候很头疼,因此引入隐式构造来简化语法。所以归根结底,C++语言本身考虑的是语法层面的功能,而数据逻辑层面靠STL来解决,二者并不耦合。但又希望程序员能够更加方便地使用STL,因此引入了一些语言层面的功能,但它却像全体类型开放了。

举例来说,Swift中,[1, 2, 3]的语法强绑定Array类型,[k1:v1, k2,v2]的语法强绑定Map类型,因此这里的“语言”和“工具”是耦合的。但C++并不和STL耦合,他的思路是{x, y, z}就是构造参数,哪种类型都可以用,你交给vector时就是表示数组,你交给map时就是表示kv对,并不会将“语法”和“类型”做任何强绑定。因此把隐式构造和explicit都提供出来,交给开发者自行处理是否支持。

这是我们需要体会的C++设计理念,当然,也可以算是C++的缺陷。

f6cb33761ea37c2bbced2e491e108f99.jpeg

C风格字符串

字符串同样是C++特别容易踩坑的位置。出于对C语言兼容、以及上一节所介绍的C++希望将“语言”和“类型”解耦的设计理念的目的,在C++中,字符串并没有映射为std::string类型,而是保留C语言当中的处理方式。编译期会将字符串常量存储在一个全局区,然后再使用字符串常量的位置用一个指针代替。所以基本可以等价认为,字符串常量(字面量)是const char *类型。

但是,更多的场景下,我们都会使用std::string类型来保存和处理字符串,因为它功能更强大,使用更方便。得益于隐式构造,我们可以把一个字符串常量轻松转化为std::string类型来处理。

但本质上来说,std::string和const char *是两种类型,所以一些场景下它还是会出问题。

1)类型推导问题

在进行类型推导时,字符串常量会按const char *来处理,有时会导致问题,比如:

template 
void f(T t) {
  std::cout << 1 << std::endl;
}


template 
void f(T *t) {
  std::cout << 2 << std::endl;
}


void Demo() {
  f("123");
  f(std::string{"123"});
}

代码的原意是将“值类型”和“指针类型”分开处理,至于字符串,照理说应当是一个“对象”,所以要按照值类型来处理。但如果我们用的是字符串常量,则会识别为const char *类型,直接匹配到了指针处理方式,而并不会触发隐式构造。

2)截断问题

C风格字符串有一个约定,就是以0结尾。它并不会去单独存储数据长度,而是很暴力地从首地址向后查找,找到0为止。但std::string不同,其内部有统计个数的成员,因此不会受0值得影响:

std::string str1{"123\0abc"}; // 0处会截断
std::string str2{"123\0abc", 7}; // 不会截断

截断问题在传参时更加明显,比如说:

void f(const char *str) {}


void Demo() {
  std::string str2{"123\0abc", 7}; 
  // 由于f只支持C风格字符串,因此转化后传入
  f(str2.c_str()); // 但其实已经被截断了
}

前面的章节曾经提到过,C++没有引入额外的格式符,因此把std::string传入格式化函数的时候,也容易发生截断问题:

std::string MakeDesc(const std::string &head, double data) {
  // 拼凑一个xxx:ff%的形式
  char buf[128];
  std::sprintf(buf, "%s:%lf%%", head.c_str(), data); // 这里有可能截断
  return buf; // 这里也有可能截断
}

总之,C风格的字符串永远难逃0值截断问题,而又因为C++中仍然保留了C风格字符串的所有行为,并没有在语言层面直接关联std::string,因此在使用时一定要小心截断问题。

3)指针意义不明问题

由于C++保留了C风格字符串的行为,因此在很多场景下,把const char *就默认为了字符串,都会按照字符串去解析。但有时可能会遇到一个真正的指针,那么此时就会有问题,比如说:

void Demo() {
  int a;
  char b;
  std::cout << &a << std::endl; // 流接受指针,打印指针的值
  std::cout << &b << std::endl; // 流接收char *,按字符串处理
}

STL中所有流接收到char 或const char 时,并不会按指针来解析,而是按照字符串解析。在上面例子中,&b本身应当就是个单纯指针,但是输出流却将其按照字符串处理了,也就是会持续向后搜索找到0值为止,那这里显然是发生越界了。

因此,如果我们给char、signed char、unsigned char类型取地址时,一定要考虑会不会被识别为字符串。

4)int8_t和uint8_t

原本int8_t和uint8_t是用来表示“8位整数”的,但是不巧的是,他们的定义是:

using int8_t = signed char;
using uint8_t = unsigned char;

由于C语言历史原因,ASCII码只有7位,所以“字符”类型有无符号是没区别的,而当时没有定制规范,因此不同编译器可能有不同处理。到后来干脆把char当做独立类型了。所以char和signed char以及unsigned char是不同类型。这与其他类型不同,例如int和signed int是同一类型。

但是类似于流的处理中,却没有把signed char和unsigned char单独拿出来处理,都是按照字符来处理了(这里笔者也不知道什么原因)。而int8_t和uint8_t又是基于此定义的,所以也会出现奇怪问题,比如:

uint8_t n = 56; // 这里是单纯想放一个整数
std::cout << n << std::endl; // 但这里会打印出8,而不是56

原本uint8_t是想屏蔽掉char这层含义,让它单纯地表示8位整数的,但是在STL的解析中,却又让它有了“字符”的含义,去按照ASCII码来解析了,让uint8_t的定义又失去了原本该有的含义,所以这里也是很容易踩坑的地方。

(这一点笔者真的没想明白为什么,明明是不同类型,但为什么没有区分开。可能同样是历史原因吧,总之这个点可以算得上真正意义上的“缺陷”了。)

f2f8b6d642c87c884c35f87ff635e76c.jpeg

new和delete

new这个运算符相信大家一定不陌生,即便是非C++系其他语言一般都会保留new这个关键字。而且这个已经成为业界的一个哏了,比如说“没有对象怎么办?不怕,new一个!”

从字面意思就能看得出,这是“新建”的意思,不过在C++中,new远不止字面看上去这么简单。而且,delete关键字基本算得上是C++的特色了,其他语言中基本见不到。

1)分配和释放空间

“堆空间”的概念同样继承自C语言,它是提供给程序手动管理、调用的内存空间。在C语言中,malloc用于分配堆空间,free用于回收。自然,在C++中仍然可以用malloc和free

但使用malloc有一个不方便的地方,我们来看一下malloc的函数原型:

void *malloc(size_t size);

malloc接收的是字节数,也就是我们需要手动计算出我们需要的空间是多少字节。它不能方便地通过某种类型直接算出空间,通常需要sizeof运算。malloc返回值是void *类型,是一个泛型指针,也就是没有指定默认解类型的,使用时通常需要类型转换,例如:

int *data = (int *)malloc(sizeof(int));

而new运算符可以完美解决上面的问题,注意,在C++中new是一个运算符

int *data = new int;

同理,delete也是一个运算符,用于释放空间:

delete data;

2)运算符本质是函数调用

熟悉C++运算符重载的读者一定清楚,C++中运算符的本质其实就是一个函数的语法糖,例如a + b实际上就是operator +(a, b),a++实际上就是a.operator++(),甚至仿函数、下标运算也都是函数调用,比如f()就是f.operator()(),a[i]就是a.operator[](i)。

既然new和delete也是运算符,那么它就应当也符合这个原理,一定有一个operator new的函数存在,下面是它的函数原型:

void *operator new(size_t size);
void *operator new(size_t size, void *ptr);

这个跟我们直观想象可能有点不一样,它的返回值仍然是void *,也并不是一个模板函数用来判断大小。所以,new运算符跟其他运算符并不一样,它并不只是单纯映射成operator new,而是做了一些额外操作。

另外,这个拥有2个参数的重载又是怎么回事呢?这个等一会再来解释。

系统内置的operator new本质上就是malloc,所以如果我们直接调operator new和operator delete的话,本质上来说,和malloc和free其实没什么区别:

int *data = static_cast(operator new(sizeof(int)));
operator delete(data);

而当我们用运算符的形式来书写时,编译器会自动处理类型的大小,以及返回值。new运算符必须作用于一个类型,编译器会将这个类型的size作为参数传给operator new,并把返回值转换为这个类型的指针,也就是说:

new T;
// 等价于
static_cast(operator new(sizeof(T)))

delete运算符要作用于一个指针,编译器会将这个指针作为参数传给operator delete,也就是说:

delete ptr;
// 等价于
operator delete(ptr);

3)重载new和delete

之所以要引入operator new和operator delete还有一个原因,就是可以重载。默认情况下,它们操作的是堆空间,但是我们也可以通过重载来使得其操作自己的内存池。

std::byte buffer[16][64]; // 一个手动的内存池
std::array buf_mark {nullptr}; // 统计已经使用的内存池单元


struct Test {
  int a, b;
  static void *operator new(size_t size) noexcept; // 重载operator new
  static void operator delete(void *ptr); // 重载operator delete
};


void *Test::operator new(size_t size) noexcept {
  // 从buffer中分配资源
  for (int i = 0; i < 16; i++) {
    if (buf_mark.at(i) == nullptr) {
      buf_mark.at(i) = buffer[i];
      return buffer[i];
    }
  }
  return nullptr;
}


void Test::operator delete(void *ptr) {
  for (int i = 0; i < 16; i++) {
    if (buf_mark.at(i) == ptr) {
      buf_mark.at(i) = nullptr;
    }
  }
}


void Demo() {
  Test *t1 = new Test; // 会在buffer中分配
  delete t1; // 释放buffer中的资源
}

另一个点,相信大家已经发现了,operator new和operator delete是支持异常抛出的,而我们这里引用直接用空指针来表示分配失败的情况了,于是加上了noexcept修饰。而默认的情况下,可以通过接收异常来判断是否分配成功,而不用每次都对指针进行判空。

4)构造函数和placement new

malloc的另一个问题就是处理非平凡构造的类类型。当一个类是非平凡构造时,它可能含有虚函数表、虚基表,还有可能含有一些额外的构造动作(比如说分配空间等等),我们拿一个最简单的字符串处理类为例:

class String {
 public:
  String(const char *str);
  ~String();
 private:
  char *buf;
  size_t size;
  size_t capicity;
};


String::String(const char *str):
    buf((char *)std::malloc(std::strlen(str) + 1)), 
    size(std::strlen(str)), 
    capicity(std::strlen(str) + 1) {
  std::memcpy(buf, str, capicity);
}
String::~String() {
  if (buf != nullptr) {
    std::free(buf);
  }
}


void Demo() {
  String *str = (String *)std::malloc(sizeof(String)); 
  // 再使用str一定是有问题的,因为没有正常构造
}

上面例子中,String就是一个非平凡的类型,它在构造函数中创建了堆空间。如果我们直接通过malloc分配一片String大小的空间,然后就直接用的话,显然是会出问题的,因为构造函数没有执行,其中buf管理的堆空间也是没有进行分配的。所以,在C++中,创建一个对象应该分2步:

第一步,分配内存空间

第二步,调用构造函数

同样,释放一个对象也应该分2步:

第一步,调用析构函数

第二步,释放内存空间

这个理念在OC语言中贯彻得非常彻底,OC中没有默认的构造函数,都是通过实现一个类方法来进行构造的,因此构造前要先分配空间:

NSString *str = [NSString alloc]; // 分配NSString大小的内存空间
[str init]; // 调用初始化函数
// 通常简写为:
NSString *str = [[NSString alloc] init];

但是在C++中,初始化方法并不是一个普通的类方法,而是特殊的构造函数,那如何手动调用构造函数呢?

我们知道,要想调用构造函数(构造一个对象),我们首先需要一个分配好的内存空间。因此,要拿着用于构造的内存空间,以构造参数,才能构造一个对象(也就是调用构造函数)。C++管这种语法叫做就地构造(placement new)

String *str = static_cast(std::malloc(sizeof(String))); // 分配内存空间
new(str) String("abc"); // 在str指向的位置调用String的构造函数

就地构造的语法就是new(addr) T(args...),看得出,这也是new运算符的一种。这时我们再回去看operator new的一个重载,应该就能猜到它是干什么的了:

void *operator new(size_t size, void *ptr);

就是用于支持就地构造的函数。要注意的是,如果是通过就地构造方式构造的对象,需要再回收内存空间之前进行析构。以上面String为例,如果不析构直接回收,那么buf所指的空间就不能得到释放,从而造成内存泄漏:

str->~String(); // 析构
std::free(str); // 释放内存空间

5)new = operator new + placement new

看到本节的标题,相信读者会恍然大悟。C++中new运算符同时承担了“分配空间”和“构造对象”的任务。上一节的例子中我们是通过malloc和free来管理的,自然,通过operator new和operator delete也是一样的,而且它们还支持针对类型的重载。

因此,我们说,一次new,相当于先operator new(分配空间)加placement new(调用构造函数)。

String *str = new String("abc"); 
// 等价于
String *str = static_cast(operator new(sizeof(String)));
new(str) String("abc");

同理,一次delete相当于先“析构”,再operator delete(释放空间)

delete str;
// 等价于
str->~String();
operator delete(str);

这就是new和delete的神秘面纱,它确实和普通的运算符不一样,除了对应的operator函数外,还有对构造、析构的处理。但也正是由于C++总是进行一些隐藏操作,才会复杂度激增,有时也会出现一些难以发现的问题,所以我们一定要弄清楚它的本质。

6)new []和delete []

new []和delete []的语法看起来是“创建/删除数组”的语法。但其实它们也并不特殊,就是封装了一层的new和delete

void *operator new[](size_t size);
void operator delete[](void *ptr);

可以看出,operator new[]和operator new完全一样,opeator delete[]和operator delete也完全一样,所以区别应当在编译器的解释上。operator new T[size]的时候,会计算出size个T类型的总大小,然后调用operator new[],之后,会依次对每个元素进行构造。也就是说:

String *arr_str = new String [4] {"abc", "def", "123"};
// 等价于
String *arr_str = static_cast(opeartor new[](sizeof(String) * 3));
new(arr_str) String("abc");
new(arr_str + 1) String("def");
new(arr_str + 2) String("123");
new(arr_str + 3) String; // 没有写在列表中的会用无参构造函数

同理,delete []会首先依次调用析构,然后再调用operator delete []来释放空间:

delete [] arr_str;
// 等价于
for (int i = 0; i < 4; i++) {
  arr_str[i].~String();
}
operator delete[] (arr_str);

总结下来new []相当于一次内存分配加多次就地构造,delete []运算符相当于多次析构加一次内存释放。

266d4986fe4c9c580aefc87c8bcb497e.jpeg

constexpr

constexpr全程叫“常量表达式(constant expression)”,顾名思义,将一个表达式定义为“常量”。

关于“常量”的概念笔者在前面“const引用”的章节已经详细叙述过,只有像1,'a',2.5f之类的才是真正的常量。储存在内存中的数据都应当叫做“变量”。

但很多时候我们在程序编写的时候,会遇到一些编译期就能确定的量,但不方便直接用常量表达的情况。最简单的一个例子就是“魔鬼数字”:

using err_t = int;
err_t Process() {
  // 某些错误
  return 25;
  // ...
  return 0;
}

作为错误码的时候,我们只能知道业界约定0表示成功,但其他的错误码就不知道什么含义了,比如这里的25号错误码,非常突兀,根本不知道它是什么含义。

C中的解决的办法就是定义宏,又有宏是预编译期进行替换的,因此它在编译的时候一定是作为常量存在的,我们又可以通过宏名称来增加可读性:

#define ERR_DATA_NOT_FOUNT 25
#define SUCC 0


using err_t = int;
err_t Process() {
  // 某些错误
  return ERR_DATA_NOT_FOUNT;
  // ...
  return SUCC;
}

(对于错误码的场景当然还可以用枚举来实现,这里就不再赘述了。

用宏虽然可以解决魔数问题,但是宏本身是不推荐使用的,详情大家可以参考前面“宏”的章节,里面介绍了很多宏滥用的情况。

不过最主要的一点就是宏不是类型安全的。我们既希望定义一个类型安全的数据,又不希望这个数据成为“变量”来占用内存空间。这时,就可以使用C++11引入的constexpr概念。

constexpr double pi = 3.141592654;
double Squ(double r) {
  return pi * r * r;
}

这里的pi虽然是double类型的,类型安全,但因为用constexpr修饰了,因此它会在编译期间成为“常量”,而不会占用内存空间。

用constexpr修饰的表达式,会保留其原有的作用域和类型(例如上面的pi就跟全局变量的作用域是一样的),只是会变成编译期常量。

1)constexpr可以当做常量使用

既然constexpr叫“常量表达式”,那么也就是说有一些编译期参数只能用常量,用constexpr修饰的表达式也可以充当。

举例来说,模板参数必须是一个编译期确定的量,那么除了常量外,constexpr修饰的表达式也可以:

template 
struct Array {
  int data[N];
};


constexpr int default_size = 16;
const int g_size = 8;
void Demo() {
  Array<8> a1; // 常量OK
  Array a2; // 常量表达式OK
  Array a3; // ERR,非常量不可以,只读变量不是常量
}

至于其他类型的表达式,也支持constexpr,原则在于它必须要是编译期可以确定的类型,比如说POD类型:

constexpr int arr[] {1, 2, 3}; 
constexpr std::array arr2 {1, 2, 3};


void f() {}


constexpr void (*fp)() = f;
constexpr const char *str = "abc123";


int g_val = 5;
constexpr int *pg = &g_val;

这里可能有一些和直觉不太一样的地方,我来解释一下。首先,数组类型是编译期可确定的(你可以单纯理解为一组数,使用时按对应位置替换为值,并不会真的分配空间)。

std::array是POD类型,那么就跟普通的结构体、数组一样,所以都可以作为编译期常量。

后面几个指针需要重点解释一下。用constexpr修饰的除了可以是绝对的常量外,在编译期能确定的量也可以视为常量。比如这里的fp,由于函数f的地址,在运行期间是不会改变的,编译期间尽管不能确定其绝对地址,但可以确定它的相对地址,那么作为函数指针fp,它就是f将要保存的地址,所以,这就是编译期可以确定的量,也可用constexpr修饰。

同理,str指向的是一个字符串常量,字符串常量同样是有一个固定存放地址的,位置不会改变,所以用于指向这个数据的指针str也可以用constexpr修饰。要注意的是:constexpr表达式有固定的书写位置,与const的位置不一定相同。比如说这里如果定义只读变量应该是const char const str,后面的const修饰str,前面的const修饰char。但换成常量表达式时,constexpr要放在最前,因此不能写成const char constexpr str,而是要写成constexpr const char *str。当然,少了这个const也是不对的,因为不仅是指针不可变,指针所指数据也不可变。这个也是C++中推荐的定义字符串常量别名的方式,优于宏定义。

最后的这个pg也是一样的道理,因为全局变量的地址也是固定的,运行期间不会改变,因此pg也可以用常量表达式。

当然,如果运行期间可能发生改变的量(也就是编译期间不能确定的量)就不可以用常量表达式,例如:

void Demo() {
  int a;
  constexpr int *p = &a; // ERR,局部变量地址编译期间不能确定
  static int b;
  constexpr int *p2 = &b; // OK,静态变量地址可以确定


  constexpr std::string str = "abc"; // ERR,非平凡POD类型不能编译期确定内部行为
}

2)constexpr表达式也可能变成变量

希望读者看到这一节标题的时候不要崩溃,C++就是这么难以捉摸。

没错,虽然constexpr已经是常量表达式了,但是用constexpr修饰变量的时候,它仍然是“定义变量”的语法,因此C++希望它能够兼容只读变量的情况。

当且仅当一种情况下,constexpr定义的变量会真的成为变量,那就是这个变量被取址的时候:

void Demo() {
  constexpr int a = 5;
  const int *p = &a; // 会让a退化为const int类型
}

道理也很简单,因为只有变量才能取址。上面例子中,由于对a进行了取地址操作,因此,a不得不真正成为一个变量,也就是变为const int类型。

那另一个问题就出现了,如果说,我对一个常量表达式既取了地址,又用到编译期语法中了怎么办?

template 
struct Test {};


void Demo() {
  constexpr int a = 5;
  Test t; // 用做常量
  const int *p = &a; // 用做变量
}

没关系,编译器会让它在编译期视为常量去给那些编译期语法(比如模板实例化)使用,之后,再把它用作变量写到内存中。

换句话说,在编译期,这里的a相当于一个宏,所有的编译期语法会用5替换a,Test< a >就变成了Test< 5>。之后,又会让a成为一个只读变量写到内存中,也就变成了const int a = 5;那么const int *p = &a;自然就是合法的了。

5b6346a4929644c47eebad112108ff79.jpeg

就地构造

“就地构造”这个词本身就很C++。很多程序员都能发现,到处纠结对象有没有拷贝,纠结出参还是返回值的只有C++程序员。

无奈,C++确实没法完全摆脱底层考虑,C++程序员也会更倾向于高性能代码的编写。当出现嵌套结构的时候,就会考虑复制问题了。举个最简单的例子,给一个vector进行push_back操作时,会发生一次复制:

struct Test {
  int a, b;
};


void Demo() {
  std::vector ve;
  ve.push_back(Test{1, 2}); // 用1,2构造临时对象,再移动构造
}

原因就在于,push_back的原型是:

template 
void vector::push_back(const T &);
template 
void vector::push_back(T &&);

如果传入左值,则会进行拷贝构造,传入右值会移动构造。但是对于Test来说,无论深浅复制,都是相同的复制。这多构造一次Test临时对象本身就是多余的。

既然,我们已经有{1, 2}的构造参数了,能否想办法跳过这一次临时对象,而是直接在vector末尾的空间上进行构造呢?这就涉及了就地构造的问题。我们在前面“new和delete”的章节介绍过,“分配空间”和“构造对象”的步骤可以拆解开来做。首先对vector的buffer进行扩容(如果需要的话),确定了要放置新对象的空间以后,直接使用placement new进行就地构造。

比如针对Test的vector我们可以这样写:

template <>
void vector::emplace_back(int a, int b) {
  // 需要时扩容
  // new_ptr表示末尾为新对象分配的空间
  new(new_ptr) Test{a, b};
}

STL中把容器的就地构造方法叫做emplace,原理就是通过传递构造参数,直接在对应位置就地构造。所以更加通用的方法应该是:

template 
void vector::emplace_back(Args &&...args) {
  // new_ptr表示末尾为新对象分配的空间
  new(new_ptr) T{std::forward(args)...};
}

1)嵌套就地构造

就地构造确实能在一定程度上解决多余的对象复制问题,但如果是嵌套形式就实则没办法了,举例来说:

struct Test {
  int a, b;
};


void Demo() {
  std::vector> ve;
  ve.emplace_back(1, Test{1, 2}); // tuple嵌套的Test没法就地构造
}

也就是说,我们没法在就地构造对象时对参数再就地构造。

这件事情放在map或者unordered_map上更加有趣,因为这两个容器的成员都是std::pair,所以对它进行emplace的时候,就地构造的是pair而不是内部的对象:

struct Test {
  int a, b;
};


void Demo() {
  std::map ma;
  ma.emplace(1, Test{1, 2}); // 这里emplace的对象是pair
}

不过好在,map和unordered_map提供了try_emplace方法,可以在一定程度上解决这个问题,函数原型是:

template 
std::pair map::try_emplace(const K &key, Args &&...args);

这里把key和value拆开了,前者还是只能通过复制的方式传递,但后者可以就地构造。(实际使用时,value更需要就地构造,一般来说key都是整数、字符串这些。)那么我们可用它代替emplace:

void Demo() {
  std::map ma;
  ma.try_emplace(1, 1, 2); // 1, 2用于构造Test
}

但看这个函数名也能猜到,它是“不覆盖逻辑”。也就是如果容器中已有对应的key,则不会覆盖。返回值中第一项表示对应项迭代器(如果是新增,就返回新增这一条的迭代器,如果是已有key则放弃新增,并返回原项的迭代器),第二项表示是否成功新增(如果已有key会返回false)。

void Demo() {
  std::map ma {{1, Test{1, 2}}};
  auto [iter, is_insert] = ma.try_emplace(1, 7, 8);
  auto ¤t_test = iter->second;
  std::cout << current_test.a << ", " << current_test.b << std::endl; // 会打印1, 2
}

不过有一些场景利用try_emplace会很方便,比如处理多重key时使用map嵌套map的场景,如果用emplace要写成:

void Demo() {
  std::map> ma;
  // 例如想给key为(1, 2)新增value为"abc"的
  // 由于无法确定外层key为1是否已经有了,所以要单独判断
  if (ma.count(1) == 0) {
    ma.emplace(1, std::map{});
  }
  ma.at(1).emplace(1, "abc");
}

但是利用try_emplace就可以更取巧一些:

void Demo() {
  std::map> ma;
  ma.try_emplace(1).first->second.try_emplace(1, "abc");
}

解释一下,如果ma含有key为1的项,就返回对应迭代器,如果没有的话则会新增(由于没指定后面的参数,所以会构造一个空map),并返回迭代器。迭代器在返回值的第一项,所以取first得到迭代器,迭代器指向的是map内部的pair,取second得到内部的map,再对其进行一次try_emplace插入内部的元素。

当然了,这么做确实可读性会下降很多,具体使用时还需要自行取舍。

6016ddd685df2a09c278d650886bf3c2.jpeg

模板的全特化

先跑个小题~,模板的「模」正确发音应该是「mú」,原本是工程上的术语,生产一种工件可能需要一种样本,但它和实际生产出的工件可能并不相同。所以说,「模板」本身并不是实际的工件,但可以用于生产出工件。更通俗来说,可以理解成一个浇注用的壳,比如说是圆柱形状,如果你往里灌铁水,那出来的就是铁柱;如果你灌铝水出来的就是铝柱;如果你灌水泥,那出来的就是水泥柱……

所以C++中用“模板”这个词特别贴切,它本身并不是实际代码,而在实例化的时候才会生成对应的代码。

而模板又存在“特化”的问题,分为“偏特化”和“全特化”。偏特化也就是部分特化,也就是半成品,本质上来说仍然属于“模板”。但全特化就很特殊了,全特化的模板就已经不是模板了,而是真正的代码了,因此这里的行为也会和模板有所不同,而更加接近普通代码。

最简单的例子就是,模板的声明和实现一般都会写在头文件中(除非仅在某个源文件中使用)。这是由于模板是编译期代码,在编译期会生成实际代码,而“编译”过程是单文件行为,因此你必须保证每个独立的源文件都能找到这段模板定义。(include头文件本质就是文件内容的复制,所以还是相当于每个使用的源文件都获取了一份模板定义)。而如果拆开则会在编译期间找不到而报错:

demo.h

template 
void f(T t);

demo.cpp

template 
void f(T t) {
// ...
}

main.cpp

#include "demo.h" // 这里只获得了声明


int main() {
  f(5); // ERR,链接报错,因为只有声明而没有实现
  return 0;
}

上例中,main.cpp包含了demo.h,因此获得的是f函数的声明。当main.cpp在编译期间,是不会去关联demo.cpp的,在主函数中调用了f,因此会标记f函数已经声明。

而编译demo.cpp的时候,由于f并没有任何实例化,因此不会产生任何代码。

此后链接main.cpp和demo.cpp,发现main.cpp中的f没有实现,因此链接阶段报错。

所以,我们才要求模板的实现也要写在头文件中,也就是变成:

demo.h

// 声明
template 
void f(T t);


// ...其他内容


// 定义
template 
void f(T t) {
}

main.cpp

#include "demo.h"


int main() {
  f(5); // OK
  return 0;
}

由于实现也写在了demo.h中,因此当主函数中调用了f时,既会用模板f的声明生成出f的声明,也会用模板f的实现生成出f的实现。

但是对于全特化的模板,情况将完全不同。因为全特化的模板已经不是模板了,而是一个确定的函数,编译期不会再用它来生成代码,因此,这时如果你把实现也写在头文件里,就会出现重定义错误:

demo.h

template 
void f(T t) {}


// f全特化
template <>
void f(int t) {}

src1.cpp

#include "demo.h" // 这里有一份f的实现

main.cpp

#include "demo.h" // 这里也有一份f的实现


int main() {
  f(a); // ERR, redefine f
  return 0;
}

这时会报重定义错误,因为f的实现写在了demo.h中,那么src.cpp包含了一次,相当于实现了一次,然后main.cpp也包含了一次,相当于又实现了一次,所以报重定义错误。

因此,正确的做法是把全特化模板当做普通函数来对待,只能在源文件中定义一次:

demo.h

template 
void f(T t) {}


// 特化f的声明
template <>
void f(int t);

demo.cpp

#include "demo.h"
// 特化f的定义
template <>
void f(int t) {}

src1.cpp

#include "demo.h" // 只得到了声明,没有重复实现

main.cpp

#include "demo.h" // 只得到了声明,没有重复实现


int main() {
  f(5); // OK,全局只有一份实现
  return 0;
}

所以在使用模板特化的时候,一定要小心,如果是全特化的话,就要按照普通函数/类来对待,声明和实现需要分开。

当然了,硬要把实现写在头文件里也是可以的,只不过要用inline修饰,防止重定义。

demo.h
template 
void f(T t) {}


// 特化f声明
template <>
void f(int t);


// 特化f内联定义
template <>
inline void f(int t) {}

8abcf0bc980c3ccb8ed0646e4f441bd4.png

构造/析构函数调用虚函数

我们知道C++用来实现“多态”的语法主要是虚函数。当调用一个对象的虚函数时,会根据对象的实际类型来调用,而不是根据引用/指针的类型。

class Base {
 public:
  virtual void f() {std::cout << "Base::f" << std::endl;}
};


class Child1 : public Base {
 public:
  void f() override {std::cout << "Child1::f" << std::endl;}
};


class Child2 : public Base {
 public:
  void f() override {std::cout << "Child2::f" << std::endl;}
};


void Demo() {
  Base *obj1 = new Child1;
  Child2 ch;
  Base &obj2 = ch;
  Base obj3;


  obj1->f(); // Child1::f
  obj2.f(); // Child2::f
  obj3.f(); // Base::f
}

但有一种特殊情况,会让多态性失效,请看下面例程:

class Base {
 public:
  Base() {f();} // 构造函数调用虚函数
  virtual void f() {std::cout << "Base::f" << std::endl;}
};


class Child : public Base {
 public:
  Child() {}
  void f() override {std::cout << "Child::f" << std::endl;}
};


void Demo() {
  Child ch; // Base::f
}

我们知道子类构造时需要先调用父类构造函数。这里由于Child中没有指定Base的构造函数,因此会调用无参的构造。在Base的无参构造函数中调用了虚函数f。照理说,我们是在构造Child的过程中调用了f,那么应该调用的是Child的f,但实际调的是Base的f,也就是多态性失效了。

究其原因,我们就要知道C++构造的模式了。由于Child是Base的子类,因此会含有Base类的成员,并且构造时也要先构造。在构造Child的Base部分时,先初始化了虚函数表,由于此时还属于Base的构造函数,因此虚函数表中指向的是Base::f。虚函数表初始化后开始构造Base的成员,示例中由于是空的所以跳过。再执行Base构造函数的函数体,函数体里调用了f。以上都属于Base的构造,完成后才会继续Child独有部分的构造。首先会构造虚函数表,把f指向Child::f。然后是初始化成员,示例中为空所以跳过。最后执行Child构造函数函数体,示例中是空的。

所以,我们看到,这里调用f的时机,是在Base构造的过程中。f由于是虚函数,因此会通过虚函数表来访问,但又因为此时虚函数表里指向的就是Base::f,所以会调用到Base类的f。

同理,如果在析构函数中调用虚函数的话,同样会失去多态性。原则就是哪个类里调用的,实际就会调用哪个类的实现

bfc0a4310a1daac9a63b6a82ef26a4c0.png

经典二义性问题

C++中存在3个非常经典的二义性问题,并且他们的默认含义都是反直觉的。

1)临时对象传参时的二义性

请看下面的代码:

struct Test {};
struct Data {
 explicit Data(const Test &test);
};
void Demo() {
  Data data(Test()); // 这句是什么含义?
}

上面这种类型的代码确实有时会一不留神就写出来。我们愿意是想创建一个Data类型的对象叫做data,构造参数是一个Test类型,这里我们直接创建了一个临时对象作为构造参数。

但如果你真的这样写的话,会得到一个warning,并且data这个对象并没有创建成功。为什么呢?因为编译期把它误以为是函数声明了。这里首先需要了解一个语法糖:

void f(void d(int));
// 等价于
void f(void (*d)(int));

C++中允许参数为“函数类型”,又因为函数并不是一种存储类型,因此这种语法会当做“函数指针类型”来处理。所以说当函数参数是一个函数的时候,本质上是让传一个函数指针进去。

与此同时,C++也支持了“函数取地址”和“解函数指针”的操作。函数取地址后仍然是函数指针,解函数指针后仍然是函数指针:

void f() {}
void Demo() {
  void (*p1)() = f; // 函数类型转化为函数指针(C语言只支持这种写法)
  void (*p2)() = &f; // 函数类型取地址还是函数指针类型
  p2(); // 函数指针直接调用相当于函数调用
  (*p2)(); // 函数指针解指针后仍然是函数指针
  auto p3 = *p2; // 同上,p3仍然是void (*)()类型
  (*************p2)(); // 逐渐离谱,但确实是合法的
}

再回到一开始的例子,假如我们要声明一个函数名为data,返回值是Data类型,参数是一个函数类型,一个返回值为Test,空参类型的函数。那么就是:

Data data(Test());
// 或者是
Data data(Test (*)());

第一种写法正好和我们刚才想表示“定义Data类型的对象名为data,参数是一个Test类型的临时对象”给撞脸了。引发了二义性。

解决方法也很简单,我们知道表示“值”的时候,套一层或者多层括号是不影响“值”的意义的:

// 下面都等价
a;
(a);
((a));

那么表示“函数调用”时,传值也是可以套多层括号的:

f(a);
f((a));
f(((a)));

但是当你表示函数声明的时候,你就不能套多层括号了:

void f(int); // 函数声明
void f((int)); // ERR,错误语法

所以,第一种解决方法就是,套一层括号,那么就只能解释为“函数调用”而不是“函数声明”了:

Data data((Test())); // 定义对象data,不会出现二义性

第二种方法就是不要用小括号表示构造参数,而是换成大括号:

Data data{Test{}}; // 大括号表示构造参数列表,不能表示函数类型

在要不就不要用临时对象,改用普通变量:

Test t;
Data data{t};

2)模板参数嵌套时的二义性

当两个模板参数套在一起的时候,两个>会碰在一起:

std::vector> ve; // 这里出现了一个>>

而这和参数中的右移运算给撞脸了:

std::array> 5> arr; // 这里也出现了一个>>

在C++11以前,>>会优先识别为右移符号,因此对于模板嵌套,就必须加空格:

std::vector > ve; // 加空格避免歧义

但可能是因为模板参数右移的情况远远少过模板嵌套的情况,因此在C++11开始,把这种默认情况改了过来,遇见>>会识别为模板嵌套:

std::vector> ve; // OK

但相对的,如果要进行右移运算的话,就会识别错误,解决方法是加括号

std::array> 5> arr; // ERR
std::array> 5)> arr; // OK,要通过加小括号避免歧义

3)模板中类型定义和静态变量二义性

直接上代码:

template 
struct Test {
  void f() {
    T::abc *p;
  }
};


struct T1 {
  static int abc;
};


struct T2 {
  using abc = int;
};


void Demo() {
  Test t1;
  Test t2;
}

Test是一个模板类,里面取了参数T的成员abc。对于T1的实例化来说,T1::abc是一个整型变量,所以T::abc p相当于两个变量相乘,会理解为“乘法”。

而对于T2来说,T2::abc是一个类型重命名,那么T::abc p相当于定义一个int类型的指针,会理解为指针类型。

所以,对于模板Test来说,由于T还没有实例化,所以不能确定T::abc到底是静态变量还是类型重命名。因此会出现二义性。

解决方式是用typename关键字,强制表名这里T::abc是一个类型:

template 
struct Test {
  void f() {
    typename T::abc *p; // 一定表示指针定义
  }
};

typename关键字大家应该并不陌生,但一般都是在模板参数中见到的。其实在C++11以前,模板参数中表示“类型”参数的关键字是class,但用这个关键字会对人产生误导,其实这里不一定非要传类类型,传基本类型也是OK的,因此C++11的时候让typename可以承担这个责任,因为它更能表示“类型名称”这种含义。但其实在此之前typename仅仅是为了解决上面二义性问题的。

另外值得说明的一点是,C++17以前,模板参数是模板的情况时仍然只能用class:

// 要求参数要传一个模板类型,其含有两个类型参数
// C++14及以前版本这里必须用class
template