effective c++条款4-8

item4:对象使用前需初始化

成员变量的初始化顺序和初始化列表中无关，和在类中的声明顺序有关。

#include <iostream>
#include <vector>
using namespace std;
class A {
public:
  explicit A(std::string name, int x = 0) : name_(std::move(name)), x_(x) {
    cout << name_.c_str() << " " << x_ << endl;
    ;
  }
  ~A() { cout << name_.c_str() << " " << x_ << endl; }

private:
  string name_;
  int x_;
};
class B {
public:
  explicit B(int v) : v_(v) {
    v_ = v;
    cout << v_ << endl;
  }
  ~B() { cout << v_ << endl; }
  int v_;
};
class C {
public:
  C(string aName, int bValue) : b_(bValue), a_(aName, b_.v_) {}
  static A staticA;
private:
  A a_;		// 将此处的AB声明对调一下就可以了
  B b_;
};
int main() { C c("111", 111); }

构造函数成员初始化列表优于函数体内赋值

初始化列表开销小。

非局部变量的初始化顺序问题

比如：

// before_use1.cpp
#include "A.h"
Foo globalA("123", 123);
int main(){	cout << "main" << endl;

// before_use2.cpp
#include "A.h"
extern A globalA;
class B{
public:
	explicit B(A &a){ cout << a.name << endl;}
};
B b(globalA);	// 此处不一定根据自己想要的顺序初始化，不同的make文件顺序，不同的编译器可能都有不同

非局部变量的初始化依赖替换为函数调用结合local static对象

// before_use1.cpp
#include "A.h"
Foo &globalA(){
	static A globalA("123", 123);
	return globalA;
}
int main(){	cout << "main" << endl;

// before_use2.cpp
#include "A.h"
extern A globalA();
class B{
public:
	explicit B(A &a){ cout << a.name << endl;}
};
B b(globalA());

条款5:了解c++默认生成的函数

同effective modern c++ 条款17
c++会自动给类生成移动构造、拷贝构造、移动赋值、拷贝赋值等函数

class Bar{
public:
	explicit Bar(std::string &name, int intValue = 10)
				: name_(name), intValue_(intValue){}
public:
	std::string &name_;
	const int intValue_;
	std::mutex mutex;
}

int main(){
	std::string name1 = “bar1”;
	std::string name2 = “bar1”;
	Bar bar1(name1), bar2(name2); 	// 默认构造函数
	Bar bar3(bar1);			// 拷贝构造函数
	Bar bar4(std::move(bar1));	// 移动构造
	bar3 = bar2;			// 拷贝赋值
	bar4 = std::move(bar2);	// 移动赋值
	return 0;
}

注意⚠️在上面的类的成员中因为name是引用类型、intValue是const类型，所以上面的赋值语句是无法执行的：即移动赋值和拷贝赋值语句。
在这种情况下，编译器是不会自动生成函数的，如果要使用，需要自己实现。
mutex成员不可移动不可拷贝

条款6:不想要的特种成员函数，明确禁止编译器自动生成

1、在c++98里，是将不想要的函数（如拷贝赋值，拷贝构造等）声明为私有函数，但是这样在他的成员函数和友元函数中仍然是可以调用的。所以采用了只声明不定义来达到效果。或者可以定义一个uncopyable的类，然后不需要拷贝构造的类继承该类，这样该类也不可以复制了

class Uncopyable{
protected:
	Uncopyable(){};
	~Uncopyable(){};
private:
	Uncopyable(const Uncopyable&);	// private method
}

class HomeForSale:private Uncopyable{ 
}		// class no longer declares copy chords

2、在现在c++中，可以在拷贝构造函数后面加上delete来禁止方法的使用

sale &operator=(const sale&) = delete;

条款7:为多台基类声明virtual析构函数

1、为多台基类声明virtual析构函数，使子类在析构时调用自己的函数
2、不是为了多态的特性，不要随意声明virual析构函数。

使用虚函数会使类自动创建一个虚表，在类的初始地址处增加一个8个字节的虚指针

3、类继承时小心父类析构函数不具有多态特性

条款8:析构函数不要抛出异常

1、析构函数不要抛出异常

class Widget{
public:
	~Widget(){};		//assume this might emit an exception
};
Void doWork(){
	std::vector<Widget> v;
}			// v is automatically destroyed here

v在析构的时候会调用每一个widget的析构函数，如果其中一个widget抛出异常，其他的widget将不会被析构，就会造成内存泄漏

避免析构函数抛异常的方法，自动处理异常

class DBConnection{
public:
	static DBConnection create();
	void close();	
};

class DBConn{
public:
	~DBConn(){ DBConn.close();}	//make DBConn can destroy automatically 
private:
	DBConnection db;
};

int main(){
	DBConn dbc(DBConnection::create());
}

• 当发生异常时，使函数直接终止

DBConn::~DBConn(){
	try{db.close();}
	catch(…){
		make log entry that the call to close failed;
		std::abort();
	}
}

• 记录日志，将异常直接吞掉

DBConn::~DBConn(){
	try{db.close();}
	catch(…){
		make log entry that the call to close failed;
	}
}

以上两种方法都有缺点，即：在关闭连接时，用户没有机会处理异常

抽取单独方法，将异常处理留给调用者

class DBConn{
public:
	void close(){		// new function for client use
		db.close();
		closed = true;
	}
	~DBConn(){
		If(!closed){	// if db wasn’t closed
			try{
				db.close();
			}catch(…){	// if closing fails, note that 
				Make log entry that call to close failed
			}
		}
	}
private:
	DBConnection db;
	bool closed;
}