c++ unique_ptrs

#include <iostream>
#include <memory>

using namespace std;



//构造函数  
void unique_ptrConstructor(void);

//返回所存储的指针
void unique_ptr_get(void);

//获取存储的删除
void unique_ptr_get_deleter(void);

//释放指针
void unique_ptr_release(void);

//指针复位
void unique_ptr_reset(void);

//内容交换
void unique_ptr_swap(void);

int main()
{
	//unique_ptrConstructor();
	//unique_ptr_get();
	//unique_ptr_get_deleter();
	//unique_ptr_release();
	//unique_ptr_reset();
	unique_ptr_swap();
	return 0;
}

//构造函数  
void unique_ptrConstructor(void)
{
	std::default_delete<int> d;
	std::unique_ptr<int> u1;
	std::unique_ptr<int> u2(nullptr);
	std::unique_ptr<int> u3(new int);
	std::unique_ptr<int> u4(new int, d);
	std::unique_ptr<int> u5(new int, std::default_delete<int>());
	std::unique_ptr<int> u6(std::move(u5));
	std::unique_ptr<int> u7(std::move(u6));
	std::unique_ptr<int> u8(std::auto_ptr<int>(new int));

	std::cout << "u1: " << (u1 ? "not null" : "null") << '\n';
	std::cout << "u2: " << (u2 ? "not null" : "null") << '\n';
	std::cout << "u3: " << (u3 ? "not null" : "null") << '\n';
	std::cout << "u4: " << (u4 ? "not null" : "null") << '\n';
	std::cout << "u5: " << (u5 ? "not null" : "null") << '\n';
	std::cout << "u6: " << (u6 ? "not null" : "null") << '\n';
	std::cout << "u7: " << (u7 ? "not null" : "null") << '\n';
	std::cout << "u8: " << (u8 ? "not null" : "null") << '\n';
	return;
	/*
	u1: null
	u2: null
	u3: not null
	u4: not null
	u5: null
	u6: null
	u7: not null
	u8: not null
	请按任意键继续. . .
	*/
}

//返回所存储的指针
void unique_ptr_get(void)
{
	std::unique_ptr<int> foo;                // null
	std::unique_ptr<int> bar;                // null  null
	int* p = nullptr;                        // null  null  null

	foo = std::unique_ptr<int>(new int(10)); // (10)  null  null
	bar = std::move(foo);                    // null  (10)  null
	p = bar.get();                           // null  (10)  (10)
	*p = 20;                                 // null  (20)  (20)
	p = nullptr;                             // null  (20)  null

	foo = std::unique_ptr<int>(new int(30)); // (30)  (20)  null
	p = foo.release();                       // null  (20)  (30)
	*p = 40;                                 // null  (20)  (40)

	std::cout << "foo: ";
	if (foo) std::cout << *foo << '\n'; else std::cout << "(null)\n";

	std::cout << "bar: ";
	if (bar) std::cout << *bar << '\n'; else std::cout << "(null)\n";

	std::cout << "p: ";
	if (p) std::cout << *p << '\n'; else std::cout << "(null)\n";
	std::cout << '\n';

	delete p;   // the program is now responsible of deleting the object pointed to by p
	// bar deletes its managed object automatically
	return;
	/*
	foo: (null)
	bar: 20
	p: 40

	请按任意键继续. . .
	*/
}


class state_deleter {  // a deleter class with state
	int count_;
public:
	state_deleter() : count_(0) {}
	template <class T>
	void operator()(T* p) {
		std::cout << "[deleted #" << ++count_ << "]\n";
		delete p;
	}
};
//获取存储的删除
void unique_ptr_get_deleter(void)
{
	state_deleter del;

	std::unique_ptr<int> p;   // uses default deleter

	// alpha and beta use independent copies of the deleter:
	std::unique_ptr<int, state_deleter> alpha(new int);
	std::unique_ptr<int, state_deleter> beta(new int, alpha.get_deleter());

	// gamma and delta share the deleter "del" (deleter type is a reference!):
	std::unique_ptr<int, state_deleter&> gamma(new int, del);
	std::unique_ptr<int, state_deleter&> delta(new int, gamma.get_deleter());

	std::cout << "resetting alpha..."; alpha.reset(new int);
	std::cout << "resetting beta..."; beta.reset(new int);
	std::cout << "resetting gamma..."; gamma.reset(new int);
	std::cout << "resetting delta..."; delta.reset(new int);

	std::cout << "calling gamma/delta deleter...";
	gamma.get_deleter()(new int);

	alpha.get_deleter() = state_deleter();  // a brand new deleter for alpha

	// additional deletions when unique_ptr objects reach out of scope
	// (in inverse order of declaration)

	return;
	/*
	resetting alpha...[deleted #1]
	resetting beta...[deleted #1]
	resetting gamma...[deleted #1]
	resetting delta...[deleted #2]
	calling gamma/delta deleter...[deleted #3]
	[deleted #4]
	[deleted #5]
	[deleted #2]
	[deleted #1]
	请按任意键继续. . .
	*/
}

//释放指针
void unique_ptr_release(void)
{
	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';

	delete manual_pointer;
	return;
	/*
	manual_pointer points to 10
	请按任意键继续. . .
	*/
}

//指针复位
void unique_ptr_reset(void)
{
	std::unique_ptr<int> up;  // empty

	up.reset(new int);       // takes ownership of pointer
	*up = 5;
	std::cout << *up << '\n';

	up.reset(new int);       // deletes managed object, acquires new pointer
	*up = 10;
	std::cout << *up << '\n';

	up.reset();               // deletes managed object
	return;
	/*
	5
	10
	请按任意键继续. . .
	*/
}

//内容交换
void unique_ptr_swap(void)
{
	std::unique_ptr<int> foo(new int(10));
	std::unique_ptr<int> bar(new int(20));

	foo.swap(bar);

	std::cout << "foo: " << *foo << '\n';
	std::cout << "bar: " << *bar << '\n';
	return;
	/*
	foo: 20
	bar: 10
	请按任意键继续. . .
	*/
}