[C++知识库]C++ 智能指针和值语义/对象语义

1 值语义和对象语义

????????如果一个对象能够被拷贝，其表达出的就是值语义；如果对象不能够拷贝，表达出的就是对象语义。值语义是指此对象由源对象拷贝生成，生成后与源对象完全无关，就是所谓的“深拷贝”，而对象语义也叫做指针语义、引用语义等，其含义就是由源对象拷贝出一个对象，这个对象仍与源对象共同指向同一个内存地址，就是“浅拷贝”。这时候就会出现两个问题：

1）既然对象语义的对象只允许存在一个，不允许被“深拷贝”，那么该如何定义满足这种条件的对象呢？

2）一个堆上的对象语义对象可以被多个指针共同指向，可若不小心delete其中一个指针，这个对象就会被析构掉，此时其他指针就成了“悬垂指针”，该如何避免这种情况呢？

下文将分别进行解释

2 问题1-拷贝构造函数

当我们想对对象进行“深拷贝”时，系统会隐式调用对象的拷贝构造函数，可以看下面这个例子：

class A
{
public:
	A();
	~A();
	A(const A &) {        //重写拷贝构造函数，为了在其调用时可以被观察到
		cout << "copy" << endl;
	}
private:

};

int main(void)
{
	A a1;
	A a2 = a1;    //此时会隐式调用拷贝构造函数以及重载运算符=
    return 0;
}

输出：
copy

根据上述特性，我们可以将拷贝构造函数和重载运算符=这两个在拷贝过程中必定会调用的函数设置为私有函数来拒绝对象语义对象被复制，修改如下：

class A
{
public:
	A();
	~A();
private:
	A(const A &);
	const A &operator=(const A &);
};

int main(void)
{
	A a1;
	A a2 = a1;    //E0330	"A::A(const A &)"  不可访问
    return 0;
}

顺带提下拷贝构造函数发生的三种情况

1）当用一个对象去初始化同类的另一个对象时，会引发复制构造函数被调用。例如：

Complex c2(c1);
Complex c2 = c1;

2）如果函数 F 的参数是类 A 的对象，那么当 F 被调用时，类 A 的复制构造函数将被调用。换句话说，作为形参的对象，是用复制构造函数初始化的，而且调用复制构造函数时的参数，就是调用函数时所给的实参。

3）如果函数的返冋值是类 A 的对象，则函数返冋时，类 A 的复制构造函数被调用。换言之，作为函数返回值的对象是用复制构造函数初始化 的，而调用复制构造函数时的实参，就是 return 语句所返回的对象。

3 问题2-智能指针

智能指针是使用了RAII（资源获取即初始化）方法，将普通的指针进行封装，使这个类形为还是指针但实际是一个对象。智能指针主要是为了解决内存泄漏（忘记delete），多次释放（问题2）的问题，它可以自动释放内存，当多个指针指向同一内存时会计数来防止过早释放内存。本文主要介绍3种智能指针

1）unique_ptr(auto_ptr弃用后的替代品)

某个时刻只能有一个unique_ptr指向一个给定对象，由于一个unique_ptr拥有它指向的对象，因此unique_ptr不支持普通的拷贝或赋值操作。

class A{
public:
    int num = 5;
    void show(){......;};
    ......
}

//初始化
unique_ptr<A> p(new A);    //初始化一个类A类型指针

unique_ptr<int> q(new int)    //初始化一个int类型指针

unique_ptr<int> q1;        //初始化一个int类型指针但不分配内存
q1 = unique_ptr<int> (new int);    //分配内存

unique_ptr<int> uptr = make_unique<int>();        //调用make_unique来初始化

//调用
p->show();
*q = p->num;

//转移所有权方法1
unique_ptr<A> pp = move(p);    //p释放对内存的所有权，将p指针置为nul；pp若也有一个对象，则删除这个对象所有内容，p原指向的内存所有权转移给pp

//转移所有权方法2
p2.reset(p3.release());//reset释放了p2原来指向的内存,并指向括号中的地址（若括号为空则指向null）；release（）返回p3指向的内存，并将p3置为null

//删除智能指针的对象，但保留该指针，可以下方法二选一
p = nullptr;
p.reset();

//智能指针不支持指针的算术运算
p++;    //Error

//智能指针不支持直接复制
unique_ptr<int> p1(new int);
unique_ptr<int> p2 = p1;    //Error

2）shared_ptr

shared_ptr可以允许多个指针共同指向同一个内存空间，该内存空间每被一个shared_ptr指针指向，该指针内部的计数器就会+1，只有当计数器值为0（即该块内存没有shared_ptr指向时），该内存会被自动析构。

class A
{
public:
	int i;
	A(int n) :i(n) { };
	~A() { cout << i << " " << "destructed" << endl; }
};
int main()
{
	shared_ptr<A> sp1(new A(2)); //A(2)由sp1托管，
	shared_ptr<A> sp2(sp1);       //A(2)同时交由sp2托管
	shared_ptr<A> sp3;
	sp3 = sp2;   //A(2)同时交由sp3托管
	cout << sp1->i << "," << sp2->i << "," << sp3->i << endl;
	A * p = sp3.get();      // get返回托管的指针，p 指向 A(2)
	cout << "A(2)对象析构前p指向的地址" << p << endl;
	cout << p->i << endl;  //输出 2
	sp1.reset(new A(3));    // reset导致托管新的指针, 此时sp1托管A(3)
	sp2.reset(new A(4));    // sp2托管A(4)
	cout << sp1->i << endl; //输出 3
	sp3.reset(new A(5));    // sp3托管A(5),A(2)无人托管，被delete
	cout << "A(2)对象析构后p指向的地址" << p << "p的值" << p->i << endl;
	return 0;
}

输出：

2,2,2
析构前p指向的地址0000018EF9095AF0
2
3
2 destructed
析构后p指向的地址0000018EF9095AF0p的值-572662307
end
5 destructed
4 destructed
3 destructed

由此可以看到，一开始sp1，sp2，sp3和指针p都是指向A（2）这个对象的，他们打印出的结果都相同为2，随后sp1，sp2，sp3分别指向其他对象，此时只有p这个非shared_ptr还指向对象A（2）,计数器为0，该对象就会在最后一个shared_ptr sp3指向其他对象时被析构掉，此后p虽然还指向该内存，但值已经没了（因为对象被析构），sp1，sp2，sp3所指向的其他对象也在程序运行结束后被一一回收。

3）weak_ptr

该指针没有实际用途，一般都随shared_ptr搭配使用，通过weak_ptr可以获取该指针指向的内存此时被多少个shared_ptr所指，该内存是否已经被释放等。weak_ptr对这个内存只有访问权而不具有所属权，所以weak_ptr指向内存或不指向内存并不会影响shared_ptr中的计数器。

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

int main()
{
	weak_ptr<int> wp1;		//创建一个weak_ptr，默认为null
	weak_ptr<int> wp2(wp1);			//也可以通过一个已存在的指针来初始化

	//也可以一个已存在的shared_ptr来初始化，一般都这么用
	shared_ptr<int> sp(new int(5));
	weak_ptr<int> wp3(sp);

	//测试此时有多少个shared_ptr指向int(5)这块内存
	shared_ptr<int> sp2(sp);
	cout << "此时指向int(5)这块内存的shared_ptr数：" <<wp3.use_count() << endl;
	sp2.reset();    //转移一个，计数-1
	cout << "此时指向int(5)这块内存的shared_ptr数：" << wp3.use_count() << endl;
    //lock()会返回一个指向同一内存的共享指针
	cout << "该共享指针的值：" << *(wp3.lock()) << "	该共享指针指向的地址：" << wp3.lock() << endl;
	sp.reset();    //此时该内存已不被任何共享指针所指,weak_ptr也随之过期
    //此时lock()会返回空
	cout << "该共享指针的地址：" << wp3.lock() << endl;
	return 0;
}

输出：

此时指向int(5)这块内存的shared_ptr数：2
此时指向int(5)这块内存的shared_ptr数：1
该共享指针的值：5 ? ? ? 该共享指针指向的地址：000001EBF8F25AF0
该共享指针的地址：0000000000000000