c++(三)-易微帮

1. STL

1.1. 迭代器

迭代器是访问容器中元素的通用方法。如果使用迭代器，不同的容器，访问元素的方法是相同的；
迭代器支持的基本操作：赋值（=）、解引用（*）、比较（==和!=）、从左向右遍历（++）；
一般情况下，迭代器是指针和移动指针的方法。

1.1.1. 正向迭代器

只能使用++运算符从左向右遍历容器，每次沿容器向右移动一个元素。

容器名<元素类型>::iterator 迭代器名;        // 正向迭代器。
容器名<元素类型>::const_iterator 迭代器名;  // 常量正向迭代器。

// 区别在于通过非常量迭代器还能修改其指向的元素

1.1.2. 双向迭代器

具备正向迭代器的功能，还可以反向（从右到左）遍历容器（也是用++），不管是正向还是反向遍历，都可以用--让迭代器后退一个元素。

容器名<元素类型>:: reverse_iterator 迭代器名;        // 反向迭代器。
容器名<元素类型>:: const_reverse_iterator 迭代器名;  // 常反向迭代器。

1.1.3. 随机访问迭代器

具备双向迭代器的功能，还支持以下操作：

用于比较两个迭代器相对位置的关系运算（<、<=、>、>=）；
迭代器和一个整数值的加减法运算（+、+=、-、-=）；
支持下标运算（iter[n]）。

容器	对应的迭代器类型
array	随机访问迭代器
vector	随机访问迭代器
deque	随机访问迭代器
list	双向迭代器
set / multiset	双向迭代器
map / multimap	双向迭代器
forward_list	前向迭代器
unordered_map / unordered_multimap	前向迭代器
unordered_set / unordered_multiset	前向迭代器
stack	不支持迭代器
queue	不支持迭代器

1.1.4. 迭代器失效

erase方法和insert方法都会导致迭代器失效

当容器调用erase方法后，当前位置到容器末尾元素的所有的迭代器全部失效了；
当容器调用insert方法后，当前位置到容器末尾元素的所有的迭代器全部失效了

1.2. 容器

1.2.1. unordered_map

特性操作

size_t bucket_count(); // 返回容器桶的数量，空容器有8个桶。
float load_factor(); // 返回容器当前的装填因子，load_factor() = size() / bucket_count()。
float max_load_factor(); // 返回容器的最大装填因子，达到该值后，容器将扩充，缺省为1。
void max_load_factor (float z ); // 设置容器的最大装填因子。

#include<iostream>
#include<unordered_map>
#include<map>

using namespace std;

template<class K, class V>
//取别名
using umap = unordered_map<K, V>;


int main()
{
	//umap<int, string> m;
	//cout << m.bucket_count() << endl;		// 输出默认桶的数量

	//size_t itmp = m.bucket_count();

	//for (int i = 0; i < 200000; i++)
	//{
	//	char name[50];
	//	sprintf_s(name, "西施%d", i);		// 将数据格式化输出到字符串
	//	m.emplace(i, name);					// 向map中插入元素
	//}
	//if (itmp != m.bucket_count())
	//{
	//	cout << m.bucket_count() << endl;
	//	itmp = m.bucket_count();
	//}

	umap<int, string> m1;
	cout << "最大装填因子：" << m1.max_bucket_count() << endl;
	m1.insert({ { 1, "西施1" }, { 2, "西施2" }, { 3, "西施3" }, { 4, "西施4" } });
	cout << "当前桶数："	<<  m1.bucket_count() << endl;
	cout << "当前装填因子：" << m1.load_factor() << endl;

	m1.insert({ { 5, "西施5" }, { 6, "西施6" }, { 7, "西施7" }, { 8, "西施8" } });
	cout << "当前桶数：" << m1.bucket_count() << endl;
	cout << "当前装填因子：" << m1.load_factor() << endl;

	m1.emplace(9, "西瓜");
	cout << "当前桶数：" << m1.bucket_count() << endl;
	cout << "当前装填因子：" << m1.load_factor() << endl;
}

iterator begin(size_t n); // 返回第n个桶中第一个元素的迭代器。
iterator end(size_t n); // 返回第n个桶中最后一个元素尾后的迭代器。

#include<iostream>
#include<string>
#include<unordered_map>
#include<map>

using namespace std;

template<class K, class V>
//取别名
using umap = unordered_map<K, V>;


int main()
{
	umap<int, string> m1;
	m1.max_load_factor(5);
	m1.insert({ { 1, "西施1" }, { 2, "西施2" }, { 3, "西施3" }, { 4, "西施4" } });
	m1.insert({ { 5, "西施5" }, { 6, "西施6" }, { 7, "西施7" }, { 8, "西施8" } });
	m1.insert({ { 9, "西施9" }, { 10, "西施10" }, { 11, "西施11" }, { 12, "西施12" } });
	m1.insert({ { 13, "西施13" }, { 14, "西施14" }, { 15, "西施15" }, { 16, "西施16" } });
	m1.emplace(17, "西瓜");
	// 遍历整个容器的方式1
	for (auto& item : m1)
	{
		cout << item.first << "," << item.second << " ";
	}
	// 遍历整个容器的方式2
	for (auto it = m1.begin(); it != m1.end(); it++)
	{
		cout << it->first << "," << it->second << " ";
	}
	cout << endl;

	// 遍历桶中的元素
	for (int i = 0; i < m1.bucket_count(); i++)
	{
		cout << "桶" << i << ": ";
		for (auto it = m1.begin(i); it != m1.end(i); it++)
		{
			cout << it->first << "," << it->second << " ";
		}
		cout << endl;
	}
}

void reserve(size_t n); // 将容器设置为至少n个桶。
void rehash(size_t n); // 将桶的数量调整为>=n。如果n大于当前容器的桶数，该方法会将容器重新哈希；如果n的值小于当前容器的桶数，该方法可能没有任何作用。
size_t bucket_size(size_t n); // 返回第n个桶中元素的个数，0 <= n < bucket_count()。
size_t bucket(K &key); // 返回值为key的元素对应的桶的编号。

1.3. 算法

1.3.1. for_each

模拟实现for_each算法的功能。特别是要掌握仿函数的用法。

//
//  main.cpp
//  foreach_demo
//
//  Created by apple on 2023/10/5.
//

#include <iostream>
#include <vector>
using namespace std;

// 模板函数
template<typename T>
void show(const T& t)
{
    cout << "亲爱的 " << t << " 号，我是一只傻傻鸟" << endl;
}

// 仿函数
template<class T>
class CGirl
{
public:
    CGirl(){};
    void operator()(const T& t)
    {
        cout << "亲爱的 " << t << " 号，我是一只傻傻鸟" << endl;

    }
};
// 自定义的foreach函数，用于遍历容器，并对每个元素执行操作
/**
 T2 func：func是一个函数指针，函数指针的类型是T2
 */
template<typename T1, typename T2>
void foreach(const T1& start, const T1& end, T2 func)
{
    for(auto it=start; it!=end;it++)
    {
        func(*it);
    }
}

int main(int argc, const char * argv[]) {

    // 存放int的vector容器
    vector<int> v = {3,4,23,2,1};
    foreach(v.begin(),  v.end(), show<int>);
    cout << endl;
    // 显式地创建对象
    CGirl<int> c;
    foreach(v.begin(),  v.end(), c);
    // 匿名对象的括号不能省略
    foreach(v.begin(),  v.end(), CGirl<int>());
    return 0;
}

1.3.2. find_if

模拟实现find_if算法的功能

//
//  main.cpp
//  findif_demo
//
//  Created by apple on 2023/10/5.
//

#include <iostream>
#include <vector>
#include <list>

using namespace std;

// 使用模板函数
template<typename T>
bool show(const T& t, const T& no)
{
    return t == no;
}

// 使用仿函数
template<class T>
class CGirl
{
public:
    T m_no;
    CGirl(T no):m_no(no){};
    bool operator()(const T& t)
    {
        return t == m_no;
    }
};

// 自定义find_if函数，使用模板函数，返回的是一个迭代器
template<typename T1, typename T2, typename T3>
T1 findif(const T1& start, const T1& end, T2 pfunc, T3 no)
{
    for(auto it = start; it!=end;it++)
    {
        if (pfunc(*it, no))
        {
            return it;
        }
    }
    return end;
}

// 自定义find_if函数，使用仿函数，返回的是一个迭代器
template<typename T1, typename T2>
T1 findif(const T1& start, const T1& end, T2 pfunc)
{
    for(auto it = start; it!=end;it++)
    {
        if (pfunc(*it))
        {
            return it;
        }
    }
    return end;
}

int main(int argc, const char * argv[]) {
    vector<int> v1 {1,2,3,4,5,7};
    list<string> v2 {"05", "07", "08"};
    auto t1 = findif(v2.begin(), v2.end(), show<string>, "03");
    auto t2 = findif(v2.begin(), v2.end(), CGirl<string>("03"));
    if(t2 == v2.end())
    {
        cout << "查找失败" << endl;
    }
    else{
        cout << "查找成功：" << *t2 << endl;
    }
    
    return 0;
}

2. 对象优化

2.1. 对象构造时的对象优化

不同方式构造对象，其背后都调用了哪些方法呢?

#include <iostream>

using namespace std;

class Test
{
public:
	Test(int a=10) :ma(a)
	{
		cout << "Test(int)" << endl;
	}
	~Test()
	{
		cout << "~Test()" << endl;
	}
	Test(const Test& t)
	{
		cout << "Test(const Test&)" << endl;
		ma = t.ma;
	}
	Test& operator=(const Test& t)
	{
		cout << "operator=" << endl;
		ma = t.ma;
		return *this;
	}
private:
	int ma;
};
#if 0

int main()
{
	Test t1;
	Test t2(t1);
	Test t3 = t1;
	// 等价于Test t4(20)
	Test t4 = Test(20);	 // c++编译器对对象构造做了优化，这里的临时对象不产生了，直接构造新对象。不会打印Test(const Test&)，只会打印Test(int)

	t4 = Test(40);		// 这里就必须要生成临时对象了，因为这行代码调用的是赋值函数，需要将临时对象当做参数传递给operator=函数

	cout << "-------------------" << endl;
	// 指针指向对象的优化
	//Test* p = &Test(40); // 不能用一个指针去保留一个临时对象的地址，这样会造成野指针

	Test&&ri = Test(40); // 这样是可以的。Test(40)是一个临时对象，是一个右值，需要使用右值引用
}

#endif // 1

上面的代码中，Test t4 = Test(20)这行代码，按照正常的构造对象方式是，Test(20)生成一个临时对象（即调用构造方法）；然后将这个临时对象拷贝构造给t4（即调用拷贝构造方法）。但是因为Test(20)生成的是一个临时对象，出了这行代码之后就被销毁了。因此编译器在这里就做了优化，不再产生这个临时对象，而是直接构造t4新对象。因此Test t4 = Test(20)等价于Test t4(20)。

如果想要看到编译器未做优化的打印结果，可以在 Linux 系统下设置set(CMAKE_CXX_FLAGS -fno-elide-constructors)

添加带右值引用参数的拷贝构造函数和赋值函数

#include <iostream>
using namespace std;

class CMyString
{
public:
	// 构造函数
	CMyString(const char* p = nullptr)
	{
		if (p != nullptr)
		{
			mptr = new char[strlen(p) + 1];		// 开辟空间并初始化
			strcpy(mptr, p);  //  将p空间中的内容拷贝到mptr
		}
		// 防止mptr是一个空指针
		else {
			mptr = new char[1];
			*mptr = '\0';
		}
		cout << "CMyString()" << endl;
	}
	// 析构函数
	~CMyString()
	{
		delete[]mptr;
		mptr = nullptr;		// 标准写法，释放空间后再将指针指向空，因为释放空间后，指针还保留着地址
		cout << "~CMyString()" << endl;
	}
	// 拷贝构造函数
	CMyString(const CMyString& str) // 传入的是一个左值对象，即有地址或者有名字的对象
	{
		mptr = new char[strlen(str.mptr) + 1];
		strcpy(mptr, str.mptr);
		cout << "CMyString(const CMyString&)" << endl;
	}
	// 拷贝构造函数
	CMyString(CMyString&& str) // 传入的是一个右值对象，即没有地址或者没有名字的对象
	{
		mptr = str.mptr;
		str.mptr = nullptr;		// 要置为空，不然两个指针都指向同一个对象，在对象析构的时候会报错
		cout << "CMyString(CMyString&&)" << endl;
	}
    // 赋值构造函数
	CMyString& operator=(CMyString&& str)
	{
		cout << "String& operator=(String&&)" << endl;
		// 防止自赋值
		if (this == &str)
		{
			return *this;
		}
		delete[] mptr; // 先把原先的内存释放掉
		mptr = str.mptr;
		str.mptr = nullptr;

		return *this;
	}
	const char* c_str() const { return mptr; }
private:
	char* mptr;
	friend CMyString operator+ (const CMyString& str1, const CMyString& str2);
	friend ostream& operator<<(ostream& out, const CMyString& str);
};

CMyString operator+ (const CMyString& str1, const CMyString& str2)
{
    cout << "operator+" << endl;
	CMyString tempstr;		//CMyString()
	tempstr.mptr = new char[strlen(str1.mptr) + strlen(str2.mptr) + 1];
	strcpy(tempstr.mptr, str1.mptr);
	strcat(tempstr.mptr, str2.mptr);
	return tempstr;	
}

ostream& operator<<(ostream& out, const CMyString& str)
{
	out << str.mptr;
	return out;
}
#if 1
int main()
{
	CMyString str1 = "aaaaaaaaaaaaaaaaa";		//CMyString()
	CMyString str2 = "bbbbbbbbbbbbbb";			//CMyString()
	CMyString str3 = str1 + str2;				//operator+,CMyString(),CMyString(CMyString&&)
	cout << str3 << endl;

	cout << "--------------------" << endl;
}
#endif

打印结果如下：

CMyString()
CMyString()
operator+
CMyString()
CMyString(CMyString&&)	// 直接使用临时对象tempstr拷贝构造str3对象
~CMyString()						// 析构掉临时对象tempstr
aaaaaaaaaaaaaaaaabbbbbbbbbbbbbb
--------------------
~CMyString()
~CMyString()
~CMyString()

2.2. 函数调用时的对象优化

正常代码

#include <iostream>

using namespace std;

class Test
{
public:
	Test(int a = 10) :ma(a)
	{
		cout << "Test(int)" << endl;
	}
	~Test()
	{
		cout << "~Test()" << endl;
	}
	Test(const Test& t)
	{
		cout << "Test(const Test&)" << endl;
		ma = t.ma;
	}
	Test& operator=(const Test& t)
	{
		cout << "operator=" << endl;
		ma = t.ma;
		return *this;
	}
	int getData()const { return ma; }
private:
	int ma;
};

Test getObject(Test t)
{
	int val = t.getData();
	Test tmp(val);
	return tmp;
}

#if 1
int main()
{
	Test t1;
	Test t2;
	t2 = getObject(t1);
}
#endif

上面代码中，执行过程如下：

Test t1; 会调用构造方法，构造t1对象。即打印Test(int)
Test t2; 会调用构造方法，构造t2对象。即打印Test(int)
t2 = getObject(t1); 调用getObject函数，会将t1传递给形参t,这里有一个拷贝构造，即打印Test(const Test&)。然后在getObject函数中，会创建tmp对象，即打印Test(int)。然后return tmp，为了将临时对象带出getObject函数，会调用拷贝构造函数在main函数的栈上创建一个临时对象(tmp1)，即打印Test(const Test&)。出了getObject函数后，tmp对象就会被销毁，即打印~Test()。形参t也会被析构，即打印~Test()。然后将临时对象(tmp1)赋值给t2对象，即打印operator=。之后销毁临时对象(tmp1)，即打印~Test()。
最后依次销毁对象t2和t1。即打印~Test()，~Test()

Test(int)
Test(int)
Test(const Test&)
Test(int)
Test(const Test&)
~Test()
~Test()
operator=
~Test()
~Test()
~Test()

优化代码

#include <iostream>

using namespace std;

class Test
{
public:
	Test(int a = 10) :ma(a)
	{
		cout << "Test(int)" << endl;
	}
	~Test()
	{
		cout << "~Test()" << endl;
	}
	Test(const Test& t)
	{
		cout << "Test(const Test&)" << endl;
		ma = t.ma;
	}
	Test& operator=(const Test& t)
	{
		cout << "operator=" << endl;
		ma = t.ma;
		return *this;
	}
	int getData()const { return ma; }
private:
	int ma;
};

Test getObject(Test &t)
{
	int val = t.getData();
	return Test(val);
}

#if 1
int main()
{
	Test t1;
	Test t2 = getObject(t1);
}
#endif

优化后的代码，执行过程如下：

Test t1;会调用构造方法，构造t1对象。即打印Test(int)
Test t2 = getObject(t1);由于getObject函数的形参接收的是Test对象的引用，因此这里就不会再拷贝对象了。进入getObject函数内，return Test(val)这行代码，这里编译器做了优化，不再产生临时对象 Test(val)，而是直接构造t2对象，即打印Test(int)。
最后依次销毁对象t2和t1。即打印~Test()，~Test()

打印结果如下：

Test(int)
Test(int)
~Test()
~Test()

2.3. 移动语义与完美转发

右值引用变量本身还是一个左值。如T &&val，val本身还是一个左值，因为它也有地址。

std::move()，将左值强转成右值

std::forward<T>，类型完美转发，能够识别左值和右值类型

以下是一个vector容器存放自定义对象的例子

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class CMyString1
{
public:
	CMyString1(const char* p = nullptr)
	{
		if (p != nullptr)
		{
			mptr = new char[strlen(p) + 1];
			strcpy(mptr, p);
		}
		else
		{
			mptr = new char[1];
			*mptr = '\0';
		}
		cout << "CMyString()" << endl;
	}
	~CMyString1()
	{
		delete[] mptr;
		mptr = nullptr;
		cout << "~CMyString()" << endl;
	}

	CMyString1(const CMyString1& str)
	{
		mptr = new char[strlen(str.mptr) + 1];
		strcpy(mptr, str.mptr);
		cout << "CMyString(const CMyString&)" << endl;
	}

	CMyString1(CMyString1&& str)
	{
		mptr = str.mptr;
		str.mptr = nullptr;
		cout << "CMyString(CMyString&&)" << endl;
	}

	CMyString1& operator=(CMyString1&& str)
	{
		cout << "String& operator=(String&&)" << endl;
		if (this == &str)
			return *this;

		delete[] mptr;

		mptr = str.mptr;
		str.mptr = nullptr;

		return *this;
	}
	const char* c_str() const { return mptr; }

private:
	char* mptr;
	friend CMyString1 operator+(const CMyString1& lhs,
		const CMyString1& rhs);
	friend ostream& operator<<(ostream& out, const CMyString1& str);
};

CMyString1 GetString(CMyString1& str)
{
	const char* pstr = str.c_str();
	CMyString1 tmpStr(pstr);
	cout << "--------------------" << endl;
	return tmpStr;
}

CMyString1 operator+(const CMyString1& lhs,
	const CMyString1& rhs)
{
	cout << "--------------------" << endl;
	// char* ptmp = new char[strlen(lhs.mptr) + strlen(rhs.mptr) + 1];
	CMyString1 tmpStr;
	tmpStr.mptr = new char[strlen(lhs.mptr) + strlen(rhs.mptr) + 1];
	strcpy(tmpStr.mptr, lhs.mptr);
	strcat(tmpStr.mptr, rhs.mptr);


	return tmpStr;
}

ostream& operator<<(ostream& out, const CMyString1& str)
{
	out << str.mptr;
	return out;
}

// 容器的空间配置器allocator做四件事情  内存开辟/内存释放  对象构造/对象析构
template<typename T>
struct Allocator
{
	T* allocate(size_t size) // 负责内存开辟
	{
		return (T*)malloc(sizeof(T) * size);
	}
	void deallocate(void* p) // 负责内存释放
	{
		free(p);
	}

	//void construct(T* p, const T& val) // 负责对象构造
	//{
	//	new (p) T(val); // 定位new
	//}
	//void construct(T* p, T&& val) // 负责对象构造
	//{
	//	new (p) T(std::move(val)); // 定位new
	//}

	template<typename Ty>
	void construct(T* p, Ty&& val)
	{
		new (p) T(std::forward<Ty>(val));
	}

	void destroy(T* p) // 负责对象析构
	{
		p->~T();
	}
};

/*
容器底层内存开辟，内存释放，对象构造和析构，都通过allocator空间配置器来实现
*/
template<typename T, typename Alloc = Allocator<T>>
class vector
{
public:
	vector(int size = 10)
	{
		// 需要把内存开辟和对象构造分开处理
		// _first = new T[size];
		_first = _allocator.allocate(size);
		_last = _first;
		_end = _first + size;
	}
	~vector()
	{
		// 析构容器有效的元素，然后释放_first指针指向的堆内存
		// delete[] _first;
		for (T* p = _first; p != _last; ++p) // 把有效的对象析构从_first到_last
		{
			_allocator.destroy(p);
		}
		_allocator.deallocate(_first); // 释放内存
		_first = _end = _last = nullptr;
	}
	vector(const vector<T>& rhs)
	{
		int size = rhs._end - rhs._first;
		//_first = new T[size];
		_first = _allocator.allocate(size);
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; ++i)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
	}
	vector<T>& operator = (const vector<T>& rhs)
	{
		if (this == &rhs)
		{
			return *this;
		}

		//delete[] _first;
		for (T* p = _first; p != _last; ++p) // 把有效的对象析构从_first到_last
		{
			_allocator.destroy(p);
		}
		_allocator.deallocate(_first);

		int size = rhs._end - rhs._first;
		//_first = new T[size];
		_first = _allocator.allocate(size);
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; ++i)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
		return *this;
	}
	//void push_back(const T& val)
	//{
	//	if (full())
	//		expand();
	//	//*_last++ = val;  _last指针指向的内存构造一个值为val的对象
	//	_allocator.construct(_last, val);
	//	_last++;
	//}
	//void push_back(T&& val)
	//{
	//	if (full())
	//		expand();
	//	_allocator.construct(_last, std::move(val));
	//	_last++;
	//}
	template<typename Ty> // 函数模板的类型推演+引用折叠
	void push_back(Ty&& val) // 引用折叠，& + && = &, && + && = &&
	{
		if (full())
			expand();

		// move:移动语义，得到右值类型
		// forward:类型完美转发，能够识别左值和右值类型
		_allocator.construct(_last, std::forward<Ty>(val));
		_last++;
	}
	void pop_back()
	{
		if (empty())
			return;
		//--_last;   不仅要把_last指针--，还需要析构删除的元素
		--_last;
		_allocator.destroy(_last);
	}
	T back() const
	{
		return *(_last - 1);
	}
	bool full() const { return _last == _end; }
	bool empty() const { return _first == _last; }
	int size() const { return _last - _first; }
private:
	T* _first;
	T* _last;
	T* _end;
	Alloc _allocator;
	void expand()
	{
		int size = _end - _first;
		//T* ptmp = new T[2 * size];
		T* ptmp = _allocator.allocate(2 * size);
		for (int i = 0; i < size; i++)
		{
			_allocator.construct(ptmp + i, _first[i]);
			//ptmp[i] = _first[i];
		}
		//delete[] _first;
		for (T* p = _first; p != _last; ++p)
		{
			_allocator.destroy(p);
		}
		_allocator.deallocate(_first);
		_first = ptmp;
		_last = _first + size;
		_end = _first + 2 * size;
	}
};

class Test
{
public:
	Test(int a = 10) : ma(a) { cout << "Test()" << endl; }
	~Test() { cout << "~Test()" << endl; }
	Test(const Test& t)
	{
		ma = t.ma;
		cout << "Test(const Test& t)" << endl;
	}
public:
	int ma;
};

#if 1
int main()
{
	CMyString1 str1 = "aaa";
	vector<CMyString1> vec;

	cout << "------------------" << endl;
	vec.push_back(str1);
	vec.push_back(CMyString1("bbbb"));
	cout << "------------------" << endl;

	return 0;
}
#endif

3. 智能指针

3.1. 不带引用计数的智能指针

3.1.1. unique_ptr

unique_ptr独享它指向的对象，也就是说，同时只有一个unique_ptr指向同一个对象，当这个unique_ptr被销毁时，指向的对象也随即被销毁。

unique_ptr是一个模板类,里面有一个内置的指针来指向对象。

使用unique_str需要包含头文件：#include <memory>

3.1.1.1. move

#include <iostream>
#include <string>
#include <memory>

int main() {
    std::unique_ptr<int> p1(new int(10));
    std::unique_ptr<int> p2 = std::move(p1);
    std::cout << "p2: " << *p2 << std::endl;
    // std::cout << "p1: " << *p1 << std::endl; // error
    return 0;
} 

// p2: 10

3.1.1.2. release

#include <iostream>
#include <string>
#include <memory>

int main()
{
    std::unique_ptr<int> auto_pointer(new int);
    int * manual_pointer;
    *auto_pointer = 10;
    // 转移该对象到另一个指针那里去
    manual_pointer = auto_pointer.release();
    // (auto_pointer is now empty)
    std::cout << "manual_pointer points to " << *manual_pointer << '\n';
    std::cout << "auto_pointer points to " << (auto_pointer ? "not null" : "nullptr") << '\n';
    delete manual_pointer;
    return 0;
}

// manual_pointer points to 10
// auto_pointer points to nullptr

3.1.1.3. swap

#include <iostream>
#include <string>
#include <memory>

int main() {
    std::unique_ptr<int> p1(new int(10));
    std::unique_ptr<int> p2(new int(20));
    p1.swap(p2);
    std::cout << "p1: " << *p1 << std::endl;
    std::cout << "p2: " << *p2 << std::endl;
    return 0;
}

// p1: 20
// p2: 10

3.1.1.4. reset

#include <iostream>
#include <string>
#include <memory>

using namespace std;

class AA
{
public:
    string m_name;
    AA(){cout << "调用AA的无参构造函数" << endl;}
    AA(string name):m_name(name){cout << "调用AA的有参构造函数" << endl;}
    ~AA(){cout << "调用AA的析构函数" << endl;}
};

int  main()
{
    // 方法1
    unique_ptr<AA>p0(new AA());
    // 方法2
    unique_ptr<AA> p1 = unique_ptr<AA>(new AA("西施"));
    // 释放对象
    p1.reset();

    cout << "auto_pointer points to " << (p1 ? "not null" : "nullptr") << '\n';
}

//调用AA的无参构造函数
//调用AA的有参构造函数
//调用AA的析构函数
//auto_pointer points to nullptr
//调用AA的析构函数

3.2. 带引用计数的智能指针

3.2.1. shared_ptr

4. 内存划分

4.1. 代码区

存放函数体的二进制代码，由操作系统进行管理；
代码区是共享的，共享的目的是对频繁被执行的程序，只需要在内存中有一份代码即可；
代码区是只读的，防止程序意外修改了它的指令；
属于程序运行前的区域

4.2. 全局/静态区

存放全局变量、静态变量；
内存空间由操作系统释放；
属于程序运行前的区域

4.3. 文字常量区

存放字符串常量
常量区是只读的

4.4. 栈区

由编译器自动分配和释放，存放函数的参数值、局部变量等；
特别注意：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

4.5. 堆区

由程序员分配和释放（释放内存使用delete关键字），若程序员不释放，程序结束后由操作系统回收；
在c++中主要利用new关键字在堆区开辟内存

#include<iostream>
#include<string>

using namespace std;

// 在堆区创建一个变量
void test()
{
	int* i = new	 int(10);
	cout << *i << endl;
    // 释放new分配的内存空间，不能连续多次释放同一块内存空间
    delete i;
    // 在释放掉内存后，手动设置指针指向空，后续再继续对空指针释放内存是安全的
    i = nullptr;
}

// 在堆区创建一个数组
void test1()
{
	int* arr = new	 int[10];
    // 给数组赋值
	for (int i = 0; i < 10; i++)
	{
		arr[i] = i + 10;
	}
    // 打印数组
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
    delete[] arr;
    arr = nullptr;
}
int main()
{
	test();
	test1();
}

#include <iostream>
using namespace std;

int num1;
int* ptr1;

int main(int argc, const char* argv[]) {
	int num2;
	char* ptr2;
	double scores[]{ 3.1,3.2 };
	char str1[10] = "我是谁";
	const char* str2  = "我是谁"; 
	static int num3(10);
	ptr1 = new int(3);
	ptr2 = new char[10];
	cout  << "num1的地址：\t" << &num1 << endl;
	cout << "scores的地址：\t" << scores << endl;
	printf("str1的地址：\t%p\n", str1);
	cout << "&str1的地址：\t" << &str1 << endl;
	printf("str2的地址：\t%p\n", str2);
	cout << "&str2的地址：\t" << &str2 << endl;
	cout << "num2的地址：\t" << &num2 << endl;
	cout << "num3的地址：\t" << &num3 <<endl;
	cout << "ptr1的地址：\t" << ptr1 << endl;
	printf("ptr2的地址：\t%p\n", ptr2);
	return 0;
}

num1的地址：    00007FF6220EF9E0		全局区
scores的地址：  000000DCBD4FF888		栈区
str1的地址：    000000DCBD4FF8B8		栈区
&str1的地址：   000000DCBD4FF8B8		栈区
str2的地址：    00007FF6220EBD0C		文字常量区
&str2的地址：   000000DCBD4FF8E8		栈区
num2的地址：    000000DCBD4FF844		栈区
num3的地址：    00007FF6220EF010		全局区
ptr1的地址：    000002AFC90623F0		堆区
ptr2的地址：    000002AFC90638E0		堆区

5. 代码编译原理

5.1. 预编译

以#开头的命令(除开 pragma lib、pragma link 等发生在链接阶段的指令)

预编译命令为： g++ -E 需要预处理的cpp文件 -o 处理后需要保存的文件名

(base) apple@appledeMacBook-Pro lesson_1 % ls
CMakelists.txt  add.cpp         add.h           main.cpp
(base) apple@appledeMacBook-Pro lesson_1 % g++ -E add.cpp -o add.i

5.2. 编译

将 c++文件编译成对应平台下的汇编指令。编译过程中，符号是不生成虚拟地址的。

编译命令为：g++ -E 原始的cpp文件 -o 处理后需要保存的文件名 或者 g++ -E 预处理之后的文件 -o 处理后需要保存的文件名

(base) apple@appledeMacBook-Pro lesson_1 % g++ -E add.cpp -o add.i
(base) apple@appledeMacBook-Pro lesson_1 % g++ -S add.i -o add.s

或者
(base) apple@appledeMacBook-Pro lesson_1 % g++ -S add.cpp -o add.s

5.3. 汇编

将汇编指令转换成机器码，也就是计算机硬件可以直接执行的指令。这一步产生的文件叫做目标文件(main.o)，是二进制格式。

汇编命令为：g++ -c 原始的cpp文件 -o 处理后需要保存的文件名 或者 g++ -c 编译之后的文件 -o 处理后需要保存的文件名

.o 文件的头文件中包含了程序的入口地址。

.o 文件的格式组成如下：

5.4. 链接

链接命令为：g++ 所有的app文件 -o 输出的文件名 或者 g++ 所有的汇编之后的文件 -o 输出的文件名

5.4.1. 文件段合并

所有.o 文件中的.text 段进行合并；所有.o 文件中的.data 段进行合并；所有.o 文件中的.bss 段进行合并；......

所有对符号的引用都要找到该符号定义的地方，如上面的 main.o 文件中的 gdata 符号和 _Z3sumii 符号，要去其他文件中找到定义的地方，找不到的话就链接失败。且也不能重复定义，不然也要报错。

5.4.2. 符号重定向

给所有的符号分配虚拟地址，并将.o 文件中的符号地址进行修改

最后生成可执行文件，可执行文件与.o 文件都是由各种段组成的，只是可执行文件多了一个 program headers 段。

c++(三)