#include <memory>
#include <iostream>
using
namespace
std
;
struct
Test
{
int
a
;
};
class
Demo
{
public:
Demo
()
{
b
=
new
Test
();
std
::
cout
<<
"Demo ()"
<<
std
::
endl
;
}
~
Demo
()
{
std
::
cout
<<
"~Demo ()"
<<
std
::
endl
;
}
void
Say
()
{
std
::
cout
<<
"Dem::Say()==>"
<<
b
->
a
<<
std
::
endl
;
}
public:
Test
*
b
;
};
int
main
()
{
std
::
cout
<<
"////////////////unique_ptr///////////////////////"
<<
std
::
endl
;
////////////////unique_ptr///////////////////////
unique_ptr
<
Demo
>
unique_ptr_demo1
(
new
Demo
);
unique_ptr_demo1
->
Say
();
// unique_ptr<Demo> unique_ptr_demo2 = unique_ptr_demo1; //无法通过编译
Demo
demo2
=
*
unique_ptr_demo1
;
unique_ptr
<
Demo
>
unique_ptr_demo3
=
move
(
unique_ptr_demo1
);
unique_ptr_demo3
->
Say
();
// Demo demo5 = *unique_ptr_demo1; //运行时错误
//
////////////////shared_ptr///////////////////////
std
::
cout
<<
"////////////////shared_ptr///////////////////////"
<<
std
::
endl
;
shared_ptr
<
Demo
>
shared_ptr_demo1
(
new
Demo
());
shared_ptr_demo1
->
Say
();
// shared_ptr_demo1.reset();
shared_ptr
<
Demo
>
shared_ptr_demo2
=
shared_ptr_demo1
;
shared_ptr_demo1
.
reset
();
// shared_ptr_demo2.reset(); //运行时错误2
shared_ptr_demo2
->
Say
();
return
0
;
}
这里我们可以看到不用我们手动释放指针指向的内存，编译器会帮我们释放该内存，对于析构函数的三次调用，分别对应unique_ptr_demo3,demo2和shared_ptr_demo1.
我们主要看unique_ptr和shared_ptr的区别，unique_ptr跟所指对象的内存紧紧的绑定在一起，不和其他的指针共享其指向的内存（例子中：无法通过编译的注释），也就是说unique_ptr不能赋值给别的unique_ptr，更深的讲，实际上unique_ptr的拷贝构造函数被删除，所以我们不能赋值。但是我们可以通过move语义来窃取unique_ptr的内存，但是要注意注释：运行时错误，我们窃取了内存后，该指针就不能在使用了，因为他指向的内存已经被偷走了，特别是当它的成员变量中有指针时，会造成程序崩溃。
shared_ptr可以赋值，允许多个shared_ptr共享一块内存，它采用了引用计数的内存管理方式，因此当它放弃了所有权时并不会释放内存，不回影响其他引用这块内存的指针，只有当引用计数变为0时才会释放内存。我们可以看到例子中 shared_ptr_demo1.reset();并没有影响shared_ptr_demo2（注：shared_ptr_demo1.reset的注释此处会彻底释放内存，shared_ptr_demo2会成为一个空指针）所以当我们通过reset显示的来销毁指针时，当引用计数没有为0时只是把指针设置成nullptr而已。因此既然编辑器会帮我们管理内存，如果不是特殊需求，就不要去显示的调用reset函数来释放销毁指针。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40 |
#include <memory>
#include <iostream>
using
namespace
std
;
class
Demo
{
public:
void
Say
()
{
std
::
cout
<<
"Demo"
<<
std
::
endl
;
}
};
template
<
class
T
>
void
CheckPtrIsValid
(
weak_ptr
<
T
>&
temp
)
{
shared_ptr
<
T
>
demo
=
temp
.
lock
();
if
(
demo
!=
nullptr
)
{
std
::
cout
<<
"ptr is good"
<<
std
::
endl
;
}
else
{
std
::
cout
<<
"ptr is null"
<<
std
::
endl
;
}
}
int
main
()
{
shared_ptr
<
Demo
>
shared_ptr_demo1
(
new
Demo
());
shared_ptr
<
Demo
>
shared_ptr_demo2
=
shared_ptr_demo1
;
weak_ptr
<
Demo
>
weak_ptr_demo1
=
shared_ptr_demo1
;
CheckPtrIsValid
(
weak_ptr_demo1
);
shared_ptr_demo1
->
Say
();
shared_ptr_demo2
->
Say
();
shared_ptr_demo1
.
reset
();
CheckPtrIsValid
(
weak_ptr_demo1
);
shared_ptr_demo2
.
reset
();
CheckPtrIsValid
(
weak_ptr_demo1
);
return
0
;
}
最后说道weak_ptr,它的作用不同于以上两种，官方说法是它可以指向shared_ptr指向的内存，但不拥有该内存，当调用lock时可以返回指向内存的shared_ptr，上面的例子中有一个检查指针是否有效的函数，我们可以看到当我们两次调用reset释放指针使得内存引用计数变为0，释放内存。这里是2次，而不是三次就非常明确的证明了，weak_ptr并没有增加引用计数，也就是说并没有拥有该内存。
说到这里，我们也应该感觉到我们使用最多的应该是shared_ptr了，只有在我们需要一个指针独占一块内存是才会用到unique _ptr,而weak_ptr在必要的时候可以用来监测shared_ptr指向的内存是否有效，这是一个非常重要且有意义的用法。
|
