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


当前回答

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

它适用于:

对象必须分配新的,但您希望与堆栈中的对象具有相同的生存期。如果对象被分配给智能指针,那么当程序退出该函数/块时,它们将被删除。类的数据成员,因此当对象被删除时,所有拥有的数据也会被删除,而析构函数中没有任何特殊代码(您需要确保析构函数是虚拟的,这几乎总是一件好事)。

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

…指针实际上不应该拥有数据。。。即,当您只是在使用数据,但希望它在引用它的函数中生存时。…智能指针本身不会在某个时刻被破坏。您不希望它位于永远不会被破坏的内存中(例如动态分配但不会显式删除的对象中)。…两个智能指针可能指向相同的数据。(然而,还有更聪明的指针可以处理这一点……这就是所谓的引用计数。)

另请参见:

垃圾收集。关于数据所有权的堆栈溢出问题

其他回答

让T成为本教程中的一个班级C++中的指针可以分为3种类型:

1) 原始指针:

T a;  
T * _ptr = &a; 

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

具有常量数据或地址的指针{向后读取}

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

指向作为常量的数据类型T的指针。这意味着不能使用指针更改数据类型。ie*ptr1=19;不会起作用。但是你可以移动指针。即ptr1++、ptr1--;等等都会起作用。向后读取:指向类型T(常量)的指针

  T * const ptr2 ;

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

const T * const ptr3 ; 

指向常量数据类型T的常量指针。这意味着您既不能移动指针,也不能将数据类型指针更改为指针。即。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指向的对象,请使用移动语义

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 

参考文献:它们本质上可以被认为是常量指针,即常量指针,不能用更好的语法移动。

参见: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 感谢安德烈指出了这个问题。

更新

这个答案相当陈旧,因此描述了当时的“好”,这是Boost库提供的智能指针。自C++11以来,标准库提供了足够的智能指针类型,因此您应该倾向于使用std::unique_ptr、std::shared_ptr和std::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_ptr或std::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实例。这可以防止指针被多次删除(错误地)。但是,您可以将对它的引用传递给您调用的其他函数。

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

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

什么是智能指针。

长版本,原则上:

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

对于非空指针的原始指针,请改用引用。

not use T*
use T&  

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

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.

以下是类似答案的链接: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

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