blocks|key|1171326|text|在我看来，学习使用智能指针是成为一名称职的C%2B%2B程序员最重要的步骤之一。正如您所知道的，每当您在某个时刻新建一个对象时，您都希望将其删除。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1171327|出现的一个问题是，在有异常的情况下，很难确保一个对象在所有可能的执行路径中总是只释放一次。|1171328|这就是RAII的原因：http://en.wikipedia.org/wiki/RAII|offset|length|1171329|创建一个帮助器类，目的是确保一个对象总是在所有执行路径中被删除一次。|1171330|这样的类的例子是:+std::auto_ptr|1171331|但有时您喜欢与其他人共享对象。只有当没有人再使用它时，它才应该被删除。|1171332|为了帮助实现这一点，已经开发了引用计数策略，但您仍然需要记住addref并手动释放ref。本质上，这与new/delete的问题是一样的。|1171333|这就是boost开发boost::shared_ptr的原因，它是引用计数智能指针，这样你就可以共享对象，而不会无意中泄漏内存。|1171334|随着C%2B%2B+tr1的添加，它现在也被添加到了c%2B%2B标准中，但它的名称是std::tr1::shared_ptr<>。|1171335|如果可能的话，我推荐使用标准的共享指针。ptr_dequeue和so是IIRC专门用于指针类型的容器。我暂时忽略它们。|1171336|因此，我们可以从您的示例开始：|1171337|std::vector<gate*>+G;+
G.push_back(new+ANDgate);++
G.push_back(new+ORgate);+
for(unsigned+i=0;i<G.size();%2B%2Bi)+
{+
++G[i]->Run();+
}+|code-block|syntax|javascript|1171338|现在的问题是，每当G离开作用域时，我们就会泄漏添加到G中的两个对象。让我们重写它以使用std::tr1::shared_ptr|1171339|//+Remember+to+include+<memory>+for+shared_ptr
//+First+do+an+alias+for+std::tr1::shared_ptr<gate>+so+we+don't+have+to+
//+type+that+in+every+place.+Call+it+gate_ptr.+This+is+what+typedef+does.
typedef+std::tr1::shared_ptr<gate>+gate_ptr;++++
//+gate_ptr+is+now+our+"smart"+pointer.+So+let's+make+a+vector+out+of+it.
std::vector<gate_ptr>+G;+
//+these+smart_ptrs+can't+be+implicitly+created+from+gate*+we+have+to+be+explicit+about+it
//+gate_ptr+(new+ANDgate),+it's+a+good+thing:
G.push_back(gate_ptr+(new+ANDgate));++
G.push_back(gate_ptr+(new+ORgate));+
for(unsigned+i=0;i<G.size();%2B%2Bi)+
{+
+++G[i]->Run();+
}+|1171340|当G超出作用域时，会自动回收内存。|1171341|作为一个练习，我让我团队中的新手们去写他们自己的智能指针类。然后在你完成后，立即丢弃这个类，并且永远不再使用它。希望您获得了有关智能指针如何在引擎盖下工作的关键知识。真的没有魔法。|1171342|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/RAII^0|0|0|B|X|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1K|8|@]|9|@$F|1L|G|1M|1|1N]]|A|$]]|$1|H|3|I|5|6|7|1O|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1P|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1R|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1S|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1T|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1U|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1V|8|@]|9|@]|A|$]]|$1|X|3|Y|5|Z|7|1W|8|@]|9|@]|A|$10|11]]|$1|12|3|13|5|6|7|1X|8|@]|9|@]|A|$]]|$1|14|3|15|5|Z|7|1Y|8|@]|9|@]|A|$10|11]]|$1|16|3|17|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|20|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|21|8|@]|9|@]|A|$]]]|1B|$1C|$5|1D|1E|1F|A|$1G|1H]]]]

Learning to use smart pointers is in my opinion one of the most important steps to become a competent C++ programmer. As you know whenever you new an object at some point you want to delete it. 

One issue that arise is that with exceptions it can be very hard to make sure a object is always released just once in all possible execution paths.

This is the reason for RAII: <a href="http://en.wikipedia.org/wiki/RAII" rel="noreferrer">http://en.wikipedia.org/wiki/RAII</a>

Making a helper class with purpose of making sure that an object always deleted once in all execution paths. 

Example of a class like this is: std::auto_ptr

But sometimes you like to share objects with other. It should only be deleted when none uses it anymore.

In order to help with that reference counting strategies have been developed but you still need to remember addref and release ref manually. In essence this is the same problem as new/delete.

That's why boost has developed boost::shared_ptr, it's reference counting smart pointer so you can share objects and not leak memory unintentionally.

With the addition of C++ tr1 this is now added to the c++ standard as well but its named std::tr1::shared_ptr&lt;>.

I recommend using the standard shared pointer if possible. ptr_list, ptr_dequeue and so are IIRC specialized containers for pointer types. I ignore them for now.

So we can start from your example:

<pre><code>std::vector&lt;gate*&gt; G; 
G.push_back(new ANDgate); 
G.push_back(new ORgate); 
for(unsigned i=0;i&lt;G.size();++i) 
{ 
 G[i]-&gt;Run(); 
} 
</code></pre>

The problem here is now that whenever G goes out scope we leak the 2 objects added to G. Let's rewrite it to use std::tr1::shared_ptr

<pre><code>// Remember to include &lt;memory&gt; for shared_ptr
// First do an alias for std::tr1::shared_ptr&lt;gate&gt; so we don't have to 
// type that in every place. Call it gate_ptr. This is what typedef does.
typedef std::tr1::shared_ptr&lt;gate&gt; gate_ptr; 
// gate_ptr is now our "smart" pointer. So let's make a vector out of it.
std::vector&lt;gate_ptr&gt; G; 
// these smart_ptrs can't be implicitly created from gate* we have to be explicit about it
// gate_ptr (new ANDgate), it's a good thing:
G.push_back(gate_ptr (new ANDgate)); 
G.push_back(gate_ptr (new ORgate)); 
for(unsigned i=0;i&lt;G.size();++i) 
{ 
 G[i]-&gt;Run(); 
} 
</code></pre>

When G goes out of scope the memory is automatically reclaimed.

As an exercise which I plagued newcomers in my team with is asking them to write their own smart pointer class. Then after you are done discard the class immedietly and never use it again. Hopefully you acquired crucial knowledge on how a smart pointer works under the hood. There's no magic really.

blocks|key|1171393|text|boost文档提供了一个很好的开始示例：shared_ptr+example+(实际上是关于智能指针的向量)或shared_ptr+doc以下答案很好地解释了boost智能指针：smart+pointers+explained|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1171394|ptr_vector背后的想法(用尽可能少的话)是，它为您处理存储的指针后面的内存释放:假设您有一个指针向量，如示例中所示。当退出应用程序或离开定义向量的作用域时，您必须自行清理(您已经动态分配了ANDgate和ORgate)，但仅清除向量是不会做到这一点的，因为向量存储的是指针而不是实际的对象(它不会销毁它包含的对象)。|1171395|+//+if+you+just+do
+G.clear()+//+will+clear+the+vector+but+you'll+be+left+with+2+memory+leaks
+...
//+to+properly+clean+the+vector+and+the+objects+behind+it
for+(std::vector<gate*>::iterator+it+=+G.begin();+it+!=+G.end();+it%2B%2B)
{
++delete+(*it);
}|code-block|syntax|javascript|1171396|boost::ptr_vector<>将为您处理上述操作-这意味着它将释放它存储的指针后面的内存。|1171397|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/example/shared_ptr_example.cpp|1|http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/shared_ptr.htm|2|https://stackoverflow.com/questions/569775/smart-pointers-boost-explained^0|K|I|0|1J|E|1|2H|O|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]|$A|12|B|13|1|14]|$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]]]

The boost documentation provides a pretty good start example:
<a href="http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/example/shared_ptr_example.cpp" rel="nofollow noreferrer">shared_ptr example</a> (it's actually about a vector of smart pointers) or 
<a href="http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/shared_ptr.htm" rel="nofollow noreferrer">shared_ptr doc</a>
The following answer by Johannes Schaub explains the boost smart pointers pretty well:
<a href="https://stackoverflow.com/questions/569775/smart-pointers-boost-explained">smart pointers explained</a>

The idea behind(in as few words as possible) ptr_vector is that it handles the deallocation of memory behind the stored pointers for you: let's say you have a vector of pointers as in your example. When quitting the application or leaving the scope in which the vector is defined you'll have to clean up after yourself(you've dynamically allocated ANDgate and ORgate) but just clearing the vector won't do it because the vector is storing the pointers and not the actual objects(it won't destroy but what it contains).

<pre><code> // if you just do
 G.clear() // will clear the vector but you'll be left with 2 memory leaks
 ...
// to properly clean the vector and the objects behind it
for (std::vector&lt;gate*&gt;::iterator it = G.begin(); it != G.end(); it++)
{
 delete (*it);
}
</code></pre>

boost::ptr_vector&lt;> will handle the above for you - meaning it will deallocate the memory behind the pointers it stores.

blocks|key|1171454|text|通过Boost，您可以做到这一点>|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1171455|std::vector<boost::any>+vecobj;
++++boost::shared_ptr<string>+sharedString1(new+string("abcdxyz!"));++++
++++boost::shared_ptr<int>+sharedint1(new+int(10));
++++vecobj.push_back(sharedString1);
++++vecobj.push_back(sharedint1);|code-block|syntax|javascript|1171456|用于在向量容器中插入不同类型的对象。虽然你必须使用与dynamic_cast类似的any_cast进行访问，但希望它能满足你的需要。|1171457|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Through Boost you can do it
>

<pre><code>std::vector&lt;boost::any&gt; vecobj;
 boost::shared_ptr&lt;string&gt; sharedString1(new string("abcdxyz!")); 
 boost::shared_ptr&lt;int&gt; sharedint1(new int(10));
 vecobj.push_back(sharedString1);
 vecobj.push_back(sharedint1);
</code></pre>

>
for inserting different object type in your vector container. while for accessing you have to use any_cast, which works like dynamic_cast, hopes it will work for your need.

blocks|key|957131|text|#include+<memory>
#include+<iostream>

class+SharedMemory+{
++++public:+
++++++++SharedMemory(int*+x):_capture(x){}
++++++++int*+get()+{+return+(_capture.get());+}
++++protected:
++++++++std::shared_ptr<int>+_capture;
};

int+main(int+,+char**){
++++SharedMemory+*_obj1=+new+SharedMemory(new+int(10));
++++SharedMemory+*_obj2+=+new+SharedMemory(*_obj1);
++++std::cout+<<+"+_obj1:+"+<<+*_obj1->get()+<<+"+_obj2:+"+<<+*_obj2->get()
++++<<+std::endl;
++++delete+_obj2;

++++std::cout+<<+"+_obj1:+"+<<+*_obj1->get()+<<+std::endl;
++++delete+_obj1;
++++std::cout+<<+"+done+"+<<+std::endl;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|957132|这是shared_ptr的实际应用示例。_obj2已删除，但指针仍然有效。输出为。/test+_obj1:+10+_obj2:+10+_obj2:+10+done|unstyled|957133|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>#include &lt;memory&gt;
#include &lt;iostream&gt;

class SharedMemory {
 public: 
 SharedMemory(int* x):_capture(x){}
 int* get() { return (_capture.get()); }
 protected:
 std::shared_ptr&lt;int&gt; _capture;
};

int main(int , char**){
 SharedMemory *_obj1= new SharedMemory(new int(10));
 SharedMemory *_obj2 = new SharedMemory(*_obj1);
 std::cout &lt;&lt; " _obj1: " &lt;&lt; *_obj1-&gt;get() &lt;&lt; " _obj2: " &lt;&lt; *_obj2-&gt;get()
 &lt;&lt; std::endl;
 delete _obj2;

 std::cout &lt;&lt; " _obj1: " &lt;&lt; *_obj1-&gt;get() &lt;&lt; std::endl;
 delete _obj1;
 std::cout &lt;&lt; " done " &lt;&lt; std::endl;
}
</code></pre>

This is an example of shared_ptr in action. _obj2 was deleted but pointer is still valid.
output is,
./test
 _obj1: 10 _obj2: 10
 _obj2: 10
 done

blocks|key|957186|text|将不同的对象添加到同一个容器中的最好方法是使用make_shared、向量和基于范围的循环，这样你就会有一个漂亮、干净和“可读”的代码！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|957187|typedef+std::shared_ptr<gate>+Ptr+++
vector<Ptr>+myConatiner;+
auto+andGate+=+std::make_shared<ANDgate>();
myConatiner.push_back(andGate+);
auto+orGate=+std::make_shared<ORgate>();
myConatiner.push_back(orGate);

for+(auto&+element+:+myConatiner)
++++element->run();|code-block|syntax|javascript|957188|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The best way to add different objects into same container is to use make_shared, vector, and range based loop and you will have a nice, clean and "readable" code!

<pre><code>typedef std::shared_ptr&lt;gate&gt; Ptr 
vector&lt;Ptr&gt; myConatiner; 
auto andGate = std::make_shared&lt;ANDgate&gt;();
myConatiner.push_back(andGate );
auto orGate= std::make_shared&lt;ORgate&gt;();
myConatiner.push_back(orGate);

for (auto&amp; element : myConatiner)
 element-&gt;run();
</code></pre>

Hi I asked a question today about <a href="https://stackoverflow.com/questions/3475030/different-types-of-objects-in-the-same-vector-array">How to insert different types of objects in the same vector array </a> and my code in that question was 

<pre><code> gate* G[1000];
G[0] = new ANDgate() ;
G[1] = new ORgate;
//gate is a class inherited by ANDgate and ORgate classes
class gate
{
 .....
 ......
 virtual void Run()
 { //A virtual function
 }
};
class ANDgate :public gate 
 {.....
 .......
 void Run()
 {
 //AND version of Run
 } 

};
 class ORgate :public gate 
 {.....
 .......
 void Run()
 {
 //OR version of Run
 } 

}; 
//Running the simulator using overloading concept
 for(...;...;..)
 {
 G[i]-&gt;Run() ; //will run perfectly the right Run for the right Gate type
 } 
</code></pre>

and I wanted to use vectors so someone wrote that I should do that :

<pre><code>std::vector&lt;gate*&gt; G;
G.push_back(new ANDgate); 
G.push_back(new ORgate);
for(unsigned i=0;i&lt;G.size();++i)
{
 G[i]-&gt;Run();
}
</code></pre>

but then he and many others suggested that I would better use <a href="http://www.boost.org/doc/libs/1_43_0/libs/ptr_container/doc/guidelines.html" rel="noreferrer">Boost pointer containers 
</a> or <code>shared_ptr</code>. I have spent the last 3 hours reading about this topic, but the documentation seems pretty advanced to me . ****Can anyone give me a small code example of <code>shared_ptr</code> usage and why they suggested using <code>shared_ptr</code>. Also are there other types like <code>ptr_vector</code>, <code>ptr_list</code> and <code>ptr_deque</code>** **

Edit1: I have read a code example too that included:

<pre><code>typedef boost::shared_ptr&lt;Foo&gt; FooPtr;
.......
int main()
{
 std::vector&lt;FooPtr&gt; foo_vector;
........
FooPtr foo_ptr( new Foo( 2 ) );
 foo_vector.push_back( foo_ptr );
...........
}
</code></pre>

And I don't understand the syntax!

Example to use shared_ptr?

容器

嗨，今天我问了一个关于的问题，我在这个问题中的代码是 gate* G[1000];G[0] = new ANDgate() ;G[1] = new ORgate;//gate is a class inherited by ANDgate and ORgate classesclass gate{ ..... .......

问使用shared_ptr的例子？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用shared_ptr的例子？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用shared_ptr的例子？
EN