C++类（六）——C++11的初始化列表、左值引用和右值引用、shared_ptr、weak_ptr、enable_shared_from_this（CRTP）、 unique_ptr、智能指针的坑

C++11的初始化列表

基本概念：https://www.cnblogs.com/LuckCoder/p/8467656.html

class A {
public:
	explicit A(int value) : m_value(value) {}
private:
	int m_value;
};

static void newVersionConstruct() {
	int avector[] = { 1, 2, 3 };
	std::vector bv = { 1, 2, 3 };
	A a(10);
	A b{ 3 };

	//bool类型转成int类型的精度没有损失。true会转化成0，false转成1.
	//因为没有精度损失，所以这种转化是允许的
	A c(true);  
	A d{ true };

	//A e(1.1);
	//A f{1.0};
}

 

 

 

左值引用和右值引用

//由于传入的参数类型是const引用，因此传入左值或者右值都是可以的
void printInfo(const int& a) {
	std::cout << a << std::endl;
}

static void leftRefAndRightRef() {

	int a = 10;
	int& refA = a;             //引用类似于别名
	const int& constRefA = a;  //const引用可以防止对原数据的修改

	std::cout << " a " << a << " ref of a " << refA << " const ref a "
		<< constRefA << std::endl;

	// this is a error
	//int& refB = 10;
	const int& constRefB = 10;  //const引用可以指向一个右值
	printInfo(constRefB);
	printInfo(10);
	printInfo(a);
	printInfo(refA);
	std::cout << "different version const ref " << constRefB << std::endl;

	auto&& rrA = 10;  //右值引用
	const int&& crrB = 20;
	rrA = 30;  //可以通过右值引用改变一个右值的大小
	std::cout << " right ref of b " << rrA << " const right ref b "
		<< crrB << std::endl;

	int b = 20;
	// 下面两句是错误的，编译器不支持隐式的将左值转成右值
	//int&& rrB = b;
	//const int&& crrB = b;

	//显示的将左值转成右值
	int&& newRRB = std::move(b);
	const int&& cNewRRB = std::move(b);

	//b的地址和newRRB的地址和cNewRRB的地址相同
	std::cout << " b " << b << " right ref of b " << newRRB << " const right ref b "
		<< cNewRRB << std::endl;
	std::cout << "address " << &b << " ref " << &newRRB << " c ref " << &cNewRRB << std::endl;
}

 

 

---

构造函数和析构函数的经典应用——智能指针

 

引言

//getName和getName2两个函数都只返回一个指针，这种设计存在一定的的缺陷：
//用户不明确指针指向的内存是否属于自己管理的范围
//多线程的环境下，该函数返回的指针只能当场使用，因为其他线程可以修改valueGroup的值
const char* getName() {
	static char valueGroup[1000];
	// do some thing
	return valueGroup;
}
//多线程下返回的指针所指的值可以一直用，但是要记得手动释放内存
const char* getName2() {
	char* value = (char*)malloc(1000);
	// do something
	return value;
}
//下面的函数可以解决上面函数的问题：返回的指针所指的那块内存是否需要程序员去手动释放
char* getName(char* v, size_t bufferSize) {
	// do something
	return v;
}

对于堆上的内存，可以使用malloc和free或者new和delete进行控制。但是如果不注意，还是会发生内存泄漏。如下：

void badThing() {
	//抛出异常
	throw 1;
}

void versionOne() {
	//void*
	int* ageC = (int*)malloc(sizeof(int));
	//判断是否生成成功
	if (ageC) {}
	free(agcC);
	char* c = (char*)malloc(100);
	free(c);

	int* age = new int(25);
	int* height = new int(160);

	//当badThing抛出异常之后，即使下面写了delete，age和height所指向的内存依然泄漏了
	badThing();

	std::cout << "VersionOne: your age is " << *age << ", and your height is "
		<< *height << std::endl;

	// if forget, TOO BAD thing will happen
	delete height;
	delete age;
}

当函数badThing()抛出异常之后，即使下面写了delete，age和height所指向的内存依然泄漏了。

如果我们写了一个类，用来控制内存的产生和释放，如下，在多线程的情况下，还是会出现一些问题：

class SafeIntPointer {
public:
	explicit SafeIntPointer(int v) : m_value(new int(v)), m_used(1) {}
	~SafeIntPointer() {
		//下面的三句代码存在问题：在多线程情况下，可能会出现
		//多个线程同时满足条件if (m_used <= 0)的情况
		//此时就会出现问题m_value所指向的资源会被重复释放
		m_used--;
		if (m_used <= 0)
			delete m_value;
	}
	// copy
	// operator =
	int* get() { return m_value; }
private:
	int m_used;  //记录使用者人数，当该值为0时，释放资源
	int* m_value;
};

为此，C++11推出用于管理内存的智能指针——shared_ptr

void versionTwo() {
	std::shared_ptr age(new int(28));
	std::shared_ptr height(new int(160));

	std::cout << "VersionTwo: your age is " << *age << ", and your height is "
		<< *height << std::endl;
	// 不需要做任何额外的事情，内存会自动的释放掉
}

 

智能指针总体概述

• auto_ptr  不推荐使用
• shared_ptr 通过引用来实现指针共享
•  weak_ptr     和shared_ptr搭配使用
• unique_ptr   一个指针只能有一个用户使用
• enable_shared_from_this  // CRTP

 

 

 

shared_ptr

 

shared_ptr的使用例子

class Object {
public:
	Object(int id) : m_id(id) { std::cout << "init obj " << m_id << std::endl; }
	~Object() { std::cout << "bye bye " << m_id << std::endl; }
	int id() const { return m_id; }
private:
	int m_id;
};

typedef std::shared_ptr