C++智能指针详解（共享指针，唯一指针，自动指针）

shared_ptr<string> pPoint{new string("pointer")};

shared_ptr<string> pPoint;
pPoint.reset(new string("point"));

shared_ptr<string> pPoint = make_shared<string>("point");

shared_ptr<string> pPoint1 = make_shared<string>("point1");
shared_ptr<string> pPoint2 = make_shared<string>("point2");

// *point：解引用；
(*pPoint1)[0] = 'P'; //point1 -> Point1

// point->API：解引用并调用其成员函数；
pPoint2->replace(0, 1, 'P'); //point2 -> Point2

// 向容器中插入point，增加一次引用
vector< shared_ptr<string>> vtPoint;
vtPoint.push_back(pPoint1);
vtPoint.push_back(pPoint2);
vtPoint.push_back(pPoint1); //这里*pPoint1虽然被插入了两遍，但是指向的还是同一个对象
*pPoint1 = "pPoint3"; //此时vtPoint中为pPoint3，pPoint2，pPoint3

shared_ptr<int> point1 = make_shared<int>(1);
shared_ptr<int> point2 = make_shared<int>(2);
shared_ptr<int> point3;
shared_ptr<double> point4 = make_shared<double>(1);

bool p1 = point3 == point3;
bool p2 = point1 < point2;
bool p3 = point1 > point3;
bool p4 = point1 == point4; //compile error

share_ptr<void> point(new int(1)); //共享指针内部保存void型指针
share_ptr<int> point(static_cast<int *>(point.get())); //compile error，undefined pointer
static_pointer_cast<int *>(point);

atomic_is_lock_free(&point) //如果point的原子接口是没上锁的，那么返回true
atomic_load(&point) //返回point
atomic_store(&point1, point2) //使用point2对point进行赋值
atomic_exchange(&point1, point2) //交换point1和point2的值

void delFunc(string *p)
{    
    cout << "Func del " << *p << endl;
    delete p;
}
cout << "begin" << endl;
shared_ptr<string> pPoint;
{
    shared_ptr<string> pPoint1(new string("point1"),
                        [](string* p) {
                            cout << “ delete " << *p << endl;
                            delete p;
                        });
    pPoint1 = pPoint2;
    shared_ptr<string> pPoint2(new string("point2"), delFunc);
}
cout << "end" << endl;

void func1()
{
    ClassA* ptr = new ClassA; //Create an objects manually
    ... //Perform some operations
    //delete ptr; //Cleanup(Manually destroy objects)
}
void func2()
{
    ClassA* ptr = new ClassA; //Create an objects manually
    try {
        ... //Perform some operations
    } catch (...) { //Handle exception
        delete ptr; //Cleanup
        throw; //Rethrow the exception
    }
    delete ptr; //Clean up on normal exit
}

void func()
{
    //Create and initialize a unique_ptr pointer
    unique<ClassA> ptr(new ClassA);
    ... //Perform some operations
}

//创建唯一指针
unique_ptr<string> uq(new string("Point"));
(*uq)[0] = 'A'; //替换第一个字符
uq->append("one"); //追加字符串
cout << *uq << endl; //打印uq字符串

//空的唯一指针
unique_ptr<string> uq;
uq = nullptr;
uq.reset();

unique_ptr<string> uq(new string("Point"));
string* str = uq.release(); //uq释放，失去唯一性

//调用操作符bool()
if (uq) //如果uq不为空
{ 
    cout << *uq << endl;
}

//与nullptr进行比较
if (uq != nullptr) //如果uq不为空

//check unique_ptr中的原始指针是否为空
if (uq.get() != nullptr) //如果uq不为空

//形参uq获得对象的所有权
void sink(unique_ptr<ClassA> uq) 
{
    ...
}
unique_ptr<ClassA> uq(new ClassA);
sink(move(uq)); //uq失去关联对象的所有权

unique_ptr<ClassA> source()
{
    unique_ptr<ClassA> uq(new ClassA);
    ...
    return uq; //将uq关联对象的所有权转移给调用函数
}
uq = source();

unique_ptr<string[]> uq(new string[666]); 
cout << uq[0] << endl;

class ClassA {};

class ClassADeleter
{
public:
    void operator () (ClassA* obj) {
        cout << "call ClassA object's Deleter" << endl;
        delete obj;
    }
};

int main()
{
    unique_ptr<ClassA, ClassADeleter> up(new ClassA());
    return 0;
}

unique_ptr<int, void(*)(int*)> 
uq(new int[666],
	[](int* pointer) {
	...
	delete[] pointer;
	});

unique_ptr<int, function<void(int*)>> 
uq(new int[666],
	[](int* pointer) {
	...
	delete[] pointer;
	});

auto T = [](int* pointer) {
    ...
    delete[] p;
};
unique_ptr<int, decltype(l)>> uq(new int[666], T);