什么是智能指针,何时应该使用智能指针?

What is a smart pointer and when should I use one?

提问人:Alex Reynolds 提问时间:9/20/2008 最后编辑:user2357112Alex Reynolds 更新时间:9/8/2022 访问量:722327

问:

什么是智能指针,何时应该使用智能指针?

C ++11 智能指针 C++-FAQ

评论

32赞 Lazer 6/26/2010
关于该主题的两篇优秀文章: - 智能指针 - 什么,为什么,哪个? - 本周大师 #25
1赞 metal 3/20/2013
以下是 Alexandrescu 关于创建不同风格的智能指针的细节的(免费)章节: informit.com/articles/article.aspx?p=31529 在他的实现中,他使用模板参数作为“策略”来指定他想要的属性(例如,引用计数),而标准库使用单独的类。请注意,他也是在右值引用可用之前编写的,以使 std::unique_ptr 之类的东西成为可能。
2赞 Richard 9/21/2008
请注意,Visual Studio 2005 中 std::auto_ptr 的实现非常糟糕。<br>http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=98871<br> http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=101842 改用升压器。
0赞 suresh m 2/7/2018
我想对上面的问题再补充一点,智能指针 std::shared_ptr 没有下标运算符,也不支持 ponter 算术,我们可以使用 get() 来获取内置指针。
0赞 HolyBlackCat 2/7/2018
它是在 C++17 中添加的,但不能保证只适用于普通数组。

答:

8赞 Jorge Ferreira 9/20/2008 #1

http://en.wikipedia.org/wiki/Smart_pointer

在计算机科学中,智能指针 是一种抽象数据类型, 模拟指针,同时提供 其他功能,例如自动 垃圾回收或边界检查。 这些附加功能旨在 减少因误用 指针,同时保持效率。 智能指针通常会跟踪 指向它们的对象 内存管理的目的。这 滥用指针是一个主要来源 的 bug:常量分配, 必须取消分配和引用 由编写的程序执行 使用指针使它很有可能 会发生一些内存泄漏。 智能指针尝试阻止内存 通过使资源泄漏 自动释放:当 指向对象的指针(或最后一个 指针系列)被销毁,因为 例如,因为它超出了范围, 尖锐的物体也会被破坏。

34赞 markets 9/20/2008 #2

智能指针类似于常规(类型化)指针,例如“char*”,除非指针本身超出范围,否则它所指向的内容也会被删除。通过使用“->”,您可以像使用常规指针一样使用它,但如果您需要指向数据的实际指针,则不可以。为此,您可以使用“&*ptr”。

它适用于:

  • 必须使用 new 分配的对象,但您希望与该堆栈上的某些对象具有相同的生存期。如果将对象分配给智能指针,则当程序退出该函数/块时,它们将被删除。

  • 类的数据成员,因此当对象被删除时,所有拥有的数据也会被删除,而析构函数中没有任何特殊代码(您需要确保析构函数是虚拟的,这几乎总是一件好事)。

在以下情况下,您可能不想使用智能指针:

  • ...指针实际上不应该拥有数据...也就是说,当你只是使用数据,但你希望它在你引用它的函数中幸存下来时。
  • ...智能指针本身不会在某个时候被销毁。您不希望它位于永远不会被销毁的内存中(例如,在动态分配但不会显式删除的对象中)。
  • ...两个智能指针可能指向相同的数据。(然而,还有更聪明的指针可以处理这个问题......这称为引用计数

另请参阅:

20赞 C. K. Young 9/20/2008 #3

大多数类型的智能指针都会为您处理指向对象的指针的释放。它非常方便,因为您不必再考虑手动处理对象了。

最常用的智能指针是 (或 ),以及不太常见的 。我建议经常使用 .std::tr1::shared_ptrboost::shared_ptrstd::auto_ptrshared_ptr

shared_ptr用途广泛,可以处理各种处置方案,包括需要“跨 DLL 边界传递对象”的情况(如果在代码和 DLL 之间使用不同的 s,则常见的噩梦情况)。libc

121赞 sergtk 9/20/2008 #4

更新:

关于过去使用的 C++ 类型,这个答案已经过时了。
在新标准中已弃用和删除。
应该使用标准的一部分 std::shared_ptr 而不是 std::。
std::auto_ptrboost::shared_ptr

与智能指针基本原理背后的概念的链接仍然主要相关。

现代 C++ 具有以下智能指针类型,并且不需要提升智能指针

答案中还提到了这本书的第二版:C++模板:完整指南第二版,作者:David Vandevoorde Nicolai,M. Josuttis,Douglas Gregor


旧答案:

智能指针是一种类似指针的类型,具有一些附加功能,例如自动内存释放、引用计数等。

Smart Pointers - What, Why, Which?(智能指针 - 什么、为什么、哪个?)页面上有一个简短的介绍。

其中一种简单的智能指针类型是 std::auto_ptr(C++标准的第 20.4.5 章),它允许在内存超出范围时自动释放内存,并且在抛出异常时比简单的指针使用更可靠,尽管不太灵活。

另一个方便的类型是 boost::shared_ptr它实现引用计数,并在没有对对象的引用时自动释放内存。这有助于避免内存泄漏,并且易于使用来实现 RAII

David Vandevoorde、Nicolai M. Josuttis的《C++ Templates: The Complete Guide》一书第20章深入介绍了该主题。智能指针。 涵盖的一些主题:

  • 防范异常
  • 持有者,(注意,std::auto_ptr 是此类智能指针的实现)
  • 资源获取是初始化(这通常用于 C++ 中的异常安全资源管理)
  • 持有人限制
  • 引用计数
  • 并发计数器访问
  • 销毁和分配

评论

6赞 ninMonkey 6/12/2019
警告已弃用,强烈建议不要使用,因为您可能会意外转移所有权。-- C++11 消除了 Boost、use: 和std::auto_ptrstd::unique_ptrstd::shared_ptrstd::weak_ptr
2051赞 Lloyd 9/20/2008 #5

更新

这个答案相当古老,因此描述了当时的“好”,这是 Boost 库提供的智能指针。自 C++11 以来,标准库提供了足够的智能指针类型,因此您应该优先使用 std::unique_ptr、std::shared_ptrstd:weak_ptr

还有 std::auto_ptr。它非常像一个有作用域的指针,只不过它还具有被复制的“特殊”危险能力——这也意外地转移了所有权。
它在 C++11 中已弃用,在 C++17 中已删除,因此不应使用它。

std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                 // p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.

旧答案

智能指针是一个包装“原始”(或“裸”)C++ 指针的类,用于管理所指向对象的生存期。没有单一的智能指针类型,但它们都尝试以实用的方式抽象原始指针。

智能指针应优先于原始指针。如果你觉得你需要使用指针(首先考虑你是否真的这样做),你通常会希望使用智能指针,因为这可以缓解原始指针的许多问题,主要是忘记删除对象和泄漏内存。

使用原始指针,程序员必须在对象不再有用时显式销毁该对象。

// Need to create the object to achieve some goal
MyObject* ptr = new MyObject(); 
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?

相比之下,智能指针定义了有关何时销毁对象的策略。您仍然需要创建对象,但您不再需要担心销毁它。

SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.

// Destruction of the object happens, depending 
// on the policy the smart pointer class uses.

// Destruction would happen even if DoSomething() 
// raises an exception

使用中最简单的策略涉及智能指针包装器对象的范围,例如由 boost::scoped_ptrstd::unique_ptr 实现。

void f()
{
    {
       std::unique_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}

请注意,实例无法复制。这样可以防止指针被多次(错误地)删除。但是,您可以将对它的引用传递给您调用的其他函数。std::unique_ptr

std::unique_ptr当您希望将对象的生存期绑定到特定的代码块时,或者如果将其作为成员数据嵌入到另一个对象中,则该另一个对象的生存期非常有用。该对象一直存在,直到包含代码块退出,或者直到包含对象本身被销毁。

更复杂的智能指针策略涉及对指针进行引用计数。这确实允许复制指针。当对对象的最后一个“引用”被销毁时,该对象将被删除。此政策由 boost::shared_ptr 和 std::shared_ptr 实施。

void f()
{
    typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
    MyObjectPtr p1; // Empty

    {
        MyObjectPtr p2(new MyObject());
        // There is now one "reference" to the created object
        p1 = p2; // Copy the pointer.
        // There are now two references to the object.
    } // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero. 
  // The object is deleted.

当对象的生存期要复杂得多,并且不直接绑定到代码的特定部分或其他对象时,引用计数指针非常有用。

引用计数指针有一个缺点,即创建悬空引用的可能性:

// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!

另一种可能性是创建循环引用:

struct Owner {
   std::shared_ptr<Owner> other;
};

std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1

// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!

为了解决这个问题,Boost 和 C++11 都定义了 a 来定义对 .weak_ptrshared_ptr

评论

7赞 Mateen Ulhaq 7/17/2011
你的意思是代替?std::auto_ptr<MyObject> p1 (new MyObject());std::auto_ptr<MyObject> p1 (new Owner());
42赞 SaulBack 9/12/2012
很棒的答案。如果它针对 c++11 进行更新,那就太好了。我找到了这个答案,寻找有关新 11 标准的信息,如果未来的访问者能找到更新的信息,那就太好了。我知道auto_ptr已被弃用。我相信shated_ptr和weak_ptr如所描述的那样存在,我认为scoped_ptr现在在标准中unique_ptr。如果这是真的,请更新这个答案吗?
24赞 Michael Francis 8/14/2014
如果说创建悬空引用的可能性是引用计数指针的缺点,这绝对是疯狂的。可能的悬空引用是任何 C++ 指针的缺点。事实上,智能指针旨在缓解的正是这个缺点
27赞 Michael Francis 8/14/2014
如果声明指向智能指针的指针(如示例中所示),则故意放弃智能指针的所有好处。这不是一个缺点或设计缺陷,它是可以想象到的最愚蠢的用法。
3赞 Toby Speight 9/17/2015
如果您坚持使用 C++03,则 A 可以安全使用。我经常用它来制作疙瘩模式,直到我接触到 C++11。const std::auto_ptr
46赞 Sridhar Iyer 9/20/2008 #6

Chris、Sergdev 和 Llyod 提供的定义是正确的。不过,我更喜欢一个更简单的定义,只是为了让我的生活变得简单: 智能指针只是一个重载 and 运算符的类。这意味着你的对象在语义上看起来像一个指针,但你可以让它做一些更酷的事情,包括引用计数、自动销毁等。 在大多数情况下就足够了,但伴随着他们自己的一套小特质。->*shared_ptrauto_ptr

21赞 Saqlain 3/12/2013 #7

智能指针是一个类似于指针的对象,但另外还提供对构造、销毁、复制、移动和取消引用的控制。

人们可以实现自己的智能指针,但许多库也提供智能指针实现,每个实现都有不同的优点和缺点。

例如,Boost 提供以下智能指针实现:

  • shared_ptr<T>是指向使用引用计数来确定何时不再需要对象的指针。T
  • scoped_ptr<T>是超出范围时自动删除的指针。无法进行转让。
  • intrusive_ptr<T>是另一个引用计数指针。它提供了比 更好的性能,但要求类型提供自己的引用计数机制。shared_ptrT
  • weak_ptr<T>是一个弱指针,与避免循环引用结合使用。shared_ptr
  • shared_array<T>就像 ,但对于 的数组。shared_ptrT
  • scoped_array<T>就像 ,但对于 的数组。scoped_ptrT

这些只是每个描述的一个线性描述,可以根据需要使用,有关更多详细信息和示例,可以查看 Boost 的文档。

此外,C++ 标准库提供了三个智能指针; 对于唯一所有权、共享所有权和 . 存在于 C++03 中,但现在已弃用。std::unique_ptrstd::shared_ptrstd::weak_ptrstd::auto_ptr

评论

0赞 einpoklum 12/30/2015
请解释为什么不像本地声明的 - 在退出范围时也会被删除。scoped_ptrconst unique_ptr
13赞 Santosh 3/7/2014 #8

以下是类似答案的链接:http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html

智能指针是一种对象,其行为、外观和感觉都与普通指针类似,但提供更多功能。在 C++ 中,智能指针作为模板类实现,这些类封装指针并重写标准指针运算符。与常规指针相比,它们具有许多优点。保证它们被初始化为 null 指针或指向堆对象的指针。选中通过空指针的间接。无需删除。当指向对象的最后一个指针消失时,将自动释放对象。这些智能指针的一个重要问题是,与常规指针不同,它们不尊重继承。智能指针对于多态代码没有吸引力。下面给出的是实现智能指针的示例。

例:

template <class X>
class smart_pointer
{
          public:
               smart_pointer();                          // makes a null pointer
               smart_pointer(const X& x)            // makes pointer to copy of x

               X& operator *( );
               const X& operator*( ) const;
               X* operator->() const;

               smart_pointer(const smart_pointer <X> &);
               const smart_pointer <X> & operator =(const smart_pointer<X>&);
               ~smart_pointer();
          private:
               //...
};

此类实现指向 X 类型对象的智能指针。对象本身位于堆上。以下是如何使用它:

smart_pointer <employee> p= employee("Harris",1333);

像其他重载运算符一样,p 的行为类似于常规指针,

cout<<*p;
p->raise_salary(0.5);
420赞 einpoklum 5/10/2015 #9

以下是现代 C++(C++11 及更高版本)的简单答案:

  • “什么是智能指针?”
    它是一种类型,其值可以像指针一样使用,但它提供了自动内存管理的附加功能:当智能指针不再使用时,它指向的内存将被解除分配(另请参阅维基百科上的更详细定义)。
  • “我什么时候应该使用?”
    在涉及跟踪内存的所有权、分配或取消分配的代码中;智能指针通常使您无需显式执行这些操作。
  • “但是,在哪种情况下,我应该使用哪种智能指针?”
    • 如果希望对象与对它的单个拥有引用一样长,请使用 std::unique_ptr。例如,将其用作指向内存的指针,该内存在进入某个作用域时分配,在退出作用域时取消分配。
    • 当您确实想从多个位置引用您的对象时,请使用 std::shared_ptr - 并且不希望您的对象在所有这些引用本身消失之前被取消分配。
    • 当您确实想从多个位置引用您的对象时,请使用 std::weak_ptr - 对于那些可以忽略和取消分配的引用(因此,当您尝试取消引用时,它们只会注意到该对象已消失)。
    • 有人建议在 C++26 中添加危险指针,但现在您还没有它们。
    • 不要使用智能指针,除非在特殊情况下,如果有必要,您可以阅读这些指针。boost::std::auto_ptr
  • “嘿,我没问用哪一个!”
    啊,但你真的想,承认吧。
  • “那我什么时候应该使用常规指针呢?”
    主要是在忽略内存所有权的代码中。这通常存在于从其他地方获取指针的函数中,并且不分配或取消分配,并且不存储比其执行更持久的指针副本。

评论

14赞 wiktor.wandachowicz 11/14/2016
值得注意的是,虽然智能(拥有)指针有助于正确的内存管理,但原始(非拥有)指针对于数据结构中的其他组织目的仍然有用。Herb Sutter在CppCon 2016上就此事做了一个很好的演讲,你可以在YouTube上看到:C++中的泄漏自由...默认情况下。
1赞 Caleth 9/17/2019
@wiktor.wandachowicz 是 to what is toT*std::unique_ptr<T>std::weak_ptr<T>std::shared_ptr<T>
3赞 einpoklum 9/17/2019
@Caleth:不,我不会这么说。
0赞 François Andrieux 3/22/2022
@Caleth 这不准确。 是 对 什么 是 .在这两种情况下,如果想要指向托管对象的非所有权指针,则应使用原始指针。 不太适合这个目的。T*std::unique_ptr<T>T*std::shared_ptr<T>weak_ptr
10赞 nnrales 3/3/2016 #10

在本教程中,设 T 为一个类 C++中的指针可以分为3种类型:

1) 原始指针

T a;  
T * _ptr = &a; 

它们将内存地址保存到内存中的某个位置。请谨慎使用,因为程序变得复杂,难以跟踪。

带有 const 数据或地址的指针 { 向后读取 }

T a ; 
const T * ptr1 = &a ; 
T const * ptr1 = &a ;

指向数据类型 T 的指针,该数据类型是 const。这意味着您不能使用指针更改数据类型。即 ;行不通。但您可以移动指针。即 ;等等会起作用。 向后读取:指向类型 T 的指针,该类型是 const*ptr1 = 19ptr1++ , ptr1--

  T * const ptr2 ;

指向数据类型 T 的常量指针。这意味着您不能移动指针,但可以更改指针指向的值。IE 会起作用,但 etc 不起作用。向后读取:指向 T 型的 const 指针*ptr2 = 19ptr2++ ; ptr2--

const T * const ptr3 ; 

指向 const 数据类型 T 的 const 指针。这意味着您既不能移动指针,也不能将数据类型指针更改为指针。即. 行不通ptr3-- ; ptr3++ ; *ptr3 = 19;

3) 智能指针 : {#include <memory> }

共享指针

  T a ; 
     //shared_ptr<T> shptr(new T) ; not recommended but works 
     shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe

     std::cout << shptr.use_count() ; // 1 //  gives the number of " 
things " pointing to it. 
     T * temp = shptr.get(); // gives a pointer to object

     // shared_pointer used like a regular pointer to call member functions
      shptr->memFn();
     (*shptr).memFn(); 

    //
     shptr.reset() ; // frees the object pointed to be the ptr 
     shptr = nullptr ; // frees the object 
     shptr = make_shared<T>() ; // frees the original object and points to new object

使用引用计数来实现,以跟踪有多少“事物”指向指针所指向的对象。当此计数为 0 时,对象将被自动删除,即当指向该对象的所有share_ptr都超出范围时,将删除 objected。 这样就摆脱了必须删除使用 new 分配的对象的麻烦。

弱指针:帮助处理使用共享指针时出现的循环引用 如果有两个由两个共享指针指向的对象,并且有一个内部共享指针指向彼此的共享指针,则将有一个循环引用,并且当共享指针超出范围时,不会删除该对象。为了解决这个问题,将内部成员从shared_ptr改为weak_ptr。注意:要访问弱指针指向的元素,请使用 lock() ,这将返回一个weak_ptr。

T a ; 
shared_ptr<T> shr = make_shared<T>() ; 
weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr 
wk.lock()->memFn() ; // use lock to get a shared_ptr 
//   ^^^ Can lead to exception if the shared ptr has gone out of scope
if(!wk.expired()) wk.lock()->memFn() ;
// Check if shared ptr has gone out of scope before access

请参阅:std::weak_ptr何时有用?

唯一指针:具有独家所有权的轻量级智能指针。当指针指向唯一对象而不在指针之间共享对象时使用。

unique_ptr<T> uptr(new T);
uptr->memFn(); 

//T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr
uptr.reset() ; // deletes the object pointed to by uptr 

要更改唯一 ptr 指向的对象,请使用 move 语义

unique_ptr<T> uptr1(new T);
unique_ptr<T> uptr2(new T);
uptr2 = std::move(uptr1); 
// object pointed by uptr2 is deleted and 
// object pointed by uptr1 is pointed to by uptr2
// uptr1 becomes null 

引用: 它们本质上可以作为 const 指针,即 const 指针,不能用更好的语法移动。

请参阅:C++ 中的指针变量和引用变量有什么区别?

r-value reference : reference to a temporary object   
l-value reference : reference to an object whose address can be obtained
const reference : reference to a data type which is const and cannot be modified 

参考资料 : https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ 感谢 Andre 指出这个问题。

2赞 Daksh Gupta 11/7/2016 #11

智能指针是那些您不必担心内存取消分配、资源共享和传输的指针。

您可以很好地使用这些指针,就像在 Java 中进行任何分配一样。在 java 中,垃圾收集器可以解决问题,而在 Smart Pointers 中,问题由析构函数完成。

5赞 Trombe 6/13/2017 #12

智能指针是一个类,是普通指针的包装器。与普通指针不同,智能指针的生命周期基于引用计数(智能指针对象被分配的次数)。因此,每当将一个智能指针分配给另一个指针时,内部引用计数都会加加。每当对象超出范围时,引用计数减去减去。

自动指针虽然看起来很相似,但与智能指针完全不同。它是一个方便的类,每当自动指针对象超出变量范围时,它就会释放资源。在某种程度上,它使指针(动态分配的内存)的工作方式类似于堆栈变量(在编译时静态分配)。

2赞 da77a 1/26/2018 #13

现有的答案很好,但没有涵盖当智能指针不是您尝试解决的问题的(完整)答案时该怎么做。

除其他外(在其他答案中解释得很好),使用智能指针是解决以下问题的可能解决方案:如何使用抽象类作为函数返回类型? 已被标记为此问题的重复项。但是,如果想在 C++ 中将抽象(或实际上任何)基类指定为返回类型,首先要问的问题是“您的真正含义是什么?在 boost 指针容器库的文档中,对 C++ 中的惯用面向对象编程(以及它与其他语言有何不同)进行了很好的讨论(并有进一步的参考)。总之,在 C++ 中,您必须考虑所有权。哪些智能指针可以帮助你,但不是唯一的解决方案,或者总是一个完整的解决方案(它们不会给你多态副本),并且并不总是你想在接口中公开的解决方案(函数返回听起来很像接口)。例如,返回引用可能就足够了。但是在所有这些情况下(智能指针、指针容器或只是返回引用),您都已将返回更改为某种形式的引用。如果你真的需要复制,你可能需要添加更多的样板“惯用语”,或者使用Adobe PolyBoost.TypeErasure等库从C++中的惯用(或其他)OOP转移到更通用的多态性。

4赞 andrewchan2022 8/9/2020 #14

什么是智能指针。

加长版,原则上:

https://web.stanford.edu/class/archive/cs/cs106l/cs106l.1192/lectures/lecture15/15_RAII.pdf

现代 C++ 习语:

RAII: Resource Acquisition Is Initialization.

● When you initialize an object, it should already have 
  acquired any resources it needs (in the constructor).


● When an object goes out of scope, it should release every 
  resource it is using (using the destructor).

眼:

● There should never be a half-ready or half-dead object.
● When an object is created, it should be in a ready state.
● When an object goes out of scope, it should release its resources. 
● The user shouldn’t have to do anything more. 

原始指针违反 RAII:当指针超出范围时,需要用户手动删除。

RAII的解决方案是:

Have a smart pointer class:
● Allocates the memory when initialized
● Frees the memory when destructor is called
● Allows access to underlying pointer

对于需要复制和共享的智能指针,请使用shared_ptr:

● use another memory to store Reference counting and shared.
● increment when copy, decrement when destructor.
● delete memory when Reference counting is 0. 
  also delete memory that store Reference counting.

对于智能指针不拥有原始指针,请使用weak_ptr:

● not change Reference counting.

shared_ptr用法:

correct way:
std::shared_ptr<T> t1 = std::make_shared<T>(TArgs);
std::shared_ptr<T> t2 = std::shared_ptr<T>(new T(Targs));

wrong way:
T* pt = new T(TArgs); // never exposure the raw pointer
shared_ptr<T> t1 = shared_ptr<T>(pt);
shared_ptr<T> t2 = shared_ptr<T>(pt);

始终避免使用原始指针。

对于必须使用原始指针的方案:

https://stackoverflow.com/a/19432062/2482283

对于非 nullptr 的原始指针,请改用 reference。

not use T*
use T&  

对于可能是 nullptr 的可选引用,请使用原始指针,这意味着:

T* pt; is optional reference and maybe nullptr.
Not own the raw pointer, 
Raw pointer is managed by some one else.
I only know that the caller is sure it is not released now.