什么是一个明智的指针和时应使用一个吗？

StackOverflow https://stackoverflow.com/questions/106508

题

什么是一个明智的指针和时应使用一个吗？

有帮助吗？

解决方案

<强>更新

这个答案相当陈旧，因此描述了当时的“好”，这是Boost库提供的智能指针。从C ++ 11开始，标准库提供了足够的智能指针类型，因此您应该支持使用 std::unique_ptr ， std::shared_ptr 和 std::weak_ptr 。

还有 std::auto_ptr 。它非常像一个范围指针，除了它还有<！> quot; special <！> quot;危险的复制能力<！>＃8212;这也意外地转移了所有权！ 在最新标准中已弃用，因此您不应使用它。请改用 boost::scoped_ptr 。 

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.

OLD ANSWER

智能指针是一个包装“原始”（或“裸”）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::shared_ptr 或 weak_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.
}

请注意，shared_ptr实例无法复制。这可以防止指针被多次删除（不正确）。但是，您可以将对它的引用传递给您调用的其他函数。

当您想要将对象的生命周期与特定的代码块联系起来，或者将其作为成员数据嵌入到另一个对象（另一个对象的生命周期）中时，

<=> s非常有用。该对象一直存在，直到退出包含的代码块，或者直到包含的对象本身被销毁为止。

更复杂的智能指针策略涉及引用计数指针。这确实允许复制指针。当最后一个<！>引用<！>时;对象被销毁，对象被删除。此政策由 <=> 和< a href =“http://en.cppreference.com/w/cpp/memory/shared_ptr”rel =“nofollow noreferrer”> <=> 。

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.

当对象的生命周期复杂得多时，引用计数指针非常有用，并且不直接与特定的代码段或另一个对象绑定。

引用计数指针有一个缺点<！>＃8212;创建悬空参考的可能性：

// 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都定义了一个<=>来定义对<=>的弱（不计数）引用。

其他提示

这里有一个简单的答案，这些天的现代C++:

  • 什么是一个明智的指针？
    这一类型，其价值可以使用类似的指针，但其提供的额外特征的自动存管理：当一个聪明的指的是不再使用、存储它指向释放(见 更详细的定义在维基百科).
  • 当我应该用一个吗？
    在代码，其中涉及跟踪所有权的一张存储、分配或分配;聪明的指针往往可以节省你需要做这些事情明确。
  • 但是，其明智的指我应该在哪些情况？
    • 使用 std::unique_ptr 当你不打算举行多次引用相同的对象。例如，它用于指存储器被分配在进入一些范围和分配在退出的范围。
    • 使用 std::shared_ptr 当你想要引您的目的是从多个地方和不想要你的对象，被分配到所有这些参考文献自己走了。
    • 使用 std::weak_ptr 当你想要引您的目的是从多个地方-对于那些参考文献，它是确定忽视和释放(所以他们只会注意的对象是离去时，你试图引用).
    • 不用的 boost:: 聪明的指针或 std::auto_ptr 除了在特殊情况下，你可以读了如果你必须的。
  • 嘿，我没有要求使用哪一个!
    啊，但是你真正想要的，承认这一点。
  • 所以当我应该经常使用的指针，然后呢？
    主要是在代码，无视存储的所有权。这通常是在职能得到一个指从别的地方并不分配也不de分配，并不存储的副本指针，其用处执行。

聪明的指针 是指针喜欢的类型有一些额外的功能，例如自动存释放、参数等等。

小型介绍可在网页 聪明的指示-什么，为什么，哪个？.

一个简单的明智指类型 std::auto_ptr (章20.4.5C++的标准)，从而可以释放记忆时自动的范围和更强大的要比简单的指针的使用时的例外情况引发的，虽然不那么灵活。

另一个方便的类型 boost::shared_ptr 它实现了基准计算和自动释放存在没有引用对象仍然存在。这有助于避免存储器泄漏和易于使用，以实现 RAII.

问题是复盖的深入的书 "C++的模板：完整的指南"，由大卫*Vandevoorde，M。Josuttis, 一章第20章。聪明的指针。一些主题包括：

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

一个聪明的指针是喜欢一个规则(类型)的指针，如"char*"，除非当指本身的范围，那么它指的是删除。你可以用它像你一个经常指针，通过使用"->"，但不是如果你需要一个实际的指针指向的数据。为此，可使用"&*ptr".

它是有用的：

  • 对象，必须分配与新的，但是，你想有同一辈子的东西在那堆。如果对象是分配给一个聪明的指针，然后他们将被删除时的程序退出功能。

  • 数据类的成员，因此当的目的是删除所有拥有数据的被删除，以及，没有任何特别代码析构(你会需要确保析构是虚拟的，这几乎是始终是一个好的事情要做)。

你可以 不 想要使用一个聪明的指针：

  • ...指针不应该实际上自己的数据...即时你只是使用的数据，但是你想要的生存的功能，你在哪里引用它。
  • ...聪明的指针本身不是将被销毁。你不想坐在记忆，永远不会被摧毁(如在一个目的，是动态分配，但不会明确地删除)。
  • ...两个聪明的指针可能指向同样的数据。(但是，有的甚至更明智的指针，将处理这...这就是所谓 参考计数.)

参见：

大多数种类的智能指针的处理处置的指针到对象。这是非常方便，因为你不认为关于处置的对象手了。

最常用的明智的指针 std::tr1::shared_ptr (或 boost::shared_ptr)，并且，不常见的， std::auto_ptr.我建议经常使用的 shared_ptr.

shared_ptr 是非常灵活，并涉及大量的各种处置方案，其中包括的情况下对象的需要"通过跨DLL边界"(公共场噩梦情况下，如果不同 libcs用你的代码和Dll)。

一个聪明的指针是一个目的，就像一个指针，但另外提供了控制在建筑、破坏、复制、移动并取消引用.

一个可以实现一个自己的聪明的指针，但许多图书馆也提供明智的指针的实现每个具有不同的优点和缺点。

例如， 提高 提供了以下明智的指针的实现：

  • 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.

这些都只是一种线性描述的每一个可用作每一需要，进一步细节和实例之一可以查看文件的提升。

此外，C++标准图书馆提供了三个聪明的指针； std::unique_ptr 为唯一的所有权， std::shared_ptr 共享所有权和 std::weak_ptr. std::auto_ptr 存在C++03但是现在已经过时了。

以下是类似答案的链接： http：//sickprogrammersarea.blogspot 。在/ 2014/03 /技术面试疑问的上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数据或地址的指针{Read backwardwards} 

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

指向数据类型T的指针，它是一个const。这意味着您无法使用指针更改数据类型。即*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 semantics 

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指出这个问题。

智能指针是一个类，是普通指针的包装器。与普通指针不同，智能点<！>＃8217;生命周期基于引用计数（智能指针对象分配的时间）。因此，每当智能指针被分配给另一个时，内部引用计数加上加号。每当对象超出范围时，引用计数减去负数。

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

智能指针是指您无需担心内存分配，资源共享和传输的问题。

您可以使用与Java中的任何分配类似的方式使用这些指针。在Java中，垃圾收集器可以解决问题，而在Smart Pointers中，诀窍是由Destructors完成的。

现有的答案是好的，但不涵盖要做什么，当一个聪明的指针不是(完成)回答问题你都在试图解决。

除其他事项(解释以及在其他答复)采用明智的指针是一个可能的解决方案 我们如何使用一个抽象的类作为一个功能返回的类型？ 这已被标记为重复的这个问题。然而，第一个问题要问，如果想要指定一个抽象(或事实上，任何)的基类作为回报类型在C++是"做你真正的意思吗".有一个良好的讨论(进一步的引用)的惯用面向对象的C++编程(和如何这是不同于其他语言)，在该文档的 提高指容器库.在摘要，C++你必须要考虑有关所有权。其明智的指针，帮助你，但不是唯一的解决办法，或者始终是一个完整的解决方案(他们不会给你多形态复制)，并不总是一个解决方案，你想要让你接口(和功能返回的声音很像一个接口)。这可能是足够返回一个参考，例如。但在所有这些情况下(智能指针，指容器或简单地返回的参考)你已经改变回从 值 以某种形式的 参考.如果你真的需要复制则可能需要添加更多的样板文件"的成语"或者移动超出了习惯用语(或者)面向对象用C++以更通用的多使用图书馆喜欢 Adobe聚 或 提升。TypeErasure.

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top