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

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

答案

更新

这个答案很旧,因此描述了当时的 “好”,这是 Boost 库提供的智能指针。从 C ++ 11 开始,标准库提供了足够的智能指针类型,因此您应该赞成使用std::unique_ptrstd::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_ptrstd::unique_ptr很有用。该对象将一直存在,直到退出包含代码的块,或者直到包含对象本身被销毁为止。

更复杂的智能指针策略涉及对指针进行引用计数。这确实允许复制指针。当该对象的最后一个 “引用” 被销毁时,该对象将被删除。该策略由boost::shared_ptrstd::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 都定义了weak_ptr来定义对shared_ptr的弱(未计数)引用。

对于当今的现代 C ++,这是一个简单的答案:

  • 什么是智能指针?
    这种类型的值可以像指针一样使用,但是提供了自动内存管理的附加功能:当不再使用智能指针时,它所指向的内存将被释放(另请参阅Wikipedia 上的更详细的定义 )。
  • 我什么时候应该使用?
    在涉及跟踪内存所有权,分配或取消分配的代码中;智能指针通常可以节省您显式执行这些操作的需要。
  • 但是在那些情况下,我应该使用哪个智能指针?
    • 当您不想保留对同一对象的多个引用时,请使用std::unique_ptr 。例如,将其用作指向内存的指针,该内存在进入某些范围时被分配,而在退出范围时被取消分配。
    • 当您确实想从多个位置引用对象时,请使用std::shared_ptr ,并且在所有这些引用本身都消失之前,不希望对象被取消分配。
    • 当您确实想从多个位置引用对象时,请使用std::weak_ptr对于可以忽略和取消分配的引用(可以在尝试取消引用时注意对象已消失)。
    • 除非在特殊情况下可以使用,否则请不要使用boost::智能指针或std::auto_ptr
  • 嘿,我没问要用哪一个!
    啊,但是你真的想承认。
  • 那么,什么时候应该使用常规指针呢?
    大多数情况下,代码会忽略内存所有权。这通常是在从其他地方获取指针,不分配也不取消分配,不存储指针的副本的函数中,这些指针的执行使它们的执行时间更长。

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

智能指针 - 什么,为什么,哪个页面上提供了小型介绍

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

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

David Vandevoorde 的《 C ++ 模板:完整指南》一书在Nicolai M. Josuttis 的第 20 章 “智能指针” 中进行了详细介绍。涵盖了一些主题:

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

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

它对以下有用:

  • 必须分配给 new 的对象,但您希望拥有与该堆栈上的对象相同的生存期。如果将对象分配给智能指针,则在程序退出该功能 / 块时将删除它们。

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

你可能希望使用智能指针时:

  • ... 指针实际上不应该拥有数据...,即,当您仅使用数据时,但是您希望它在引用它的函数中存活下来。
  • ... 智能指针本身不会在某个时候被破坏。您不希望它位于永不被破坏的内存中(例如,在动态分配但不会被明确删除的对象中)。
  • ... 两个智能指针可能指向同一数据。 (但是,还有更聪明的指针可以处理此问题…… 这称为引用计数 。)

也可以看看:

智能指针是一个对象,其作用类似于指针,但还提供了对构造,破坏,复制,移动和取消引用的控制。

一个人可以实现自己的智能指针,但是许多库还提供了智能指针实现,每种实现都有其优缺点。

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

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

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

另外,C ++ 标准库提供了三个智能指针。 std::unique_ptr表示唯一所有权, std::shared_ptr表示共享所有权, std::weak_ptrstd::auto_ptr存在于 C ++ 03 中,但现在已弃用。

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

最常用的智能指针是std::tr1::shared_ptr (或boost::shared_ptr ),以及std::auto_ptr 。我建议定期使用shared_ptr

shared_ptr是非常通用的,并且处理各种各样的处理方案,包括需要 “跨越 DLL 边界传递对象” 的情况(如果在代码和 DLL 之间使用不同的libc则通常是噩梦)。

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

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

例:

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);

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

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

让 T 作为本教程的类 C ++ 中的指针可以分为 3 种类型:

1) 原始指针

T a;  
T * _ptr = &a;

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

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

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

指向作为常量的数据类型 T 的指针。意味着您不能使用指针更改数据类型。即*ptr1 = 19 ; 不管用。但是您可以移动指针。即ptr1++ , ptr1-- ; 等会工作。向后读:指向类型 T 的指针,它是 const

T * const ptr2 ;

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

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 超出范围时,删除对象。这消除了必须删除使用 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 指出了这个问题。