什么是智能指针,什么时候应该使用?
当前回答
Chris、Sergdev和Llyod提供的定义是正确的。我更喜欢一个更简单的定义,只是为了让我的生活简单:智能指针只是一个重载->和*运算符的类。这意味着你的对象在语义上看起来像一个指针,但你可以让它做一些更酷的事情,包括引用计数、自动销毁等。sharedptr和autoptr在大多数情况下都是足够的,但它们也有自己的一些小特点。
其他回答
什么是智能指针。
长版本,原则上:
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);
智能指针是一种类似指针的对象,但它还提供了对构造、销毁、复制、移动和取消引用的控制。
人们可以实现自己的智能指针,但许多库也提供智能指针实现,每个实现都有不同的优点和缺点。
例如,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_ptr表示共享所有权。std::auto_ptr在C++03中存在,但现在已弃用。
智能指针是那些你不必担心内存取消分配、资源共享和传输的地方。
您可以很好地使用这些指针,其方式与Java中的任何分配方式类似。在java垃圾收集器中完成了这一任务,而在智能指针中,这一任务由Destructor完成。
Chris、Sergdev和Llyod提供的定义是正确的。我更喜欢一个更简单的定义,只是为了让我的生活简单:智能指针只是一个重载->和*运算符的类。这意味着你的对象在语义上看起来像一个指针,但你可以让它做一些更酷的事情,包括引用计数、自动销毁等。sharedptr和autoptr在大多数情况下都是足够的,但它们也有自己的一些小特点。