blocks|key|2564965|text|智能点是通用的；你基本上可以在其中粘贴任何你想要的东西。但是你应该根据你想要实现的目标来决定合适的工具。智能指针有相当具体的用例。另一方面，指向指针的指针有几种不同的用例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2564966|2564967|指针数组的指针数组，用于实现2D数组。如果这就是你想要实现的，如果你知道你的数组总是有一个指针的MxN.|unordered-list-item|offset|length|style|CODE|2564968|pointer大小，那么考虑使用std::vector<std::vector<T>>或者std::array<std::array<T,+N>,+M>，就像用来修改函数的另一个指针一样。在这种情况下，您应该考虑通过引用传递。如果代码中确实需要指针，可以通过将指向T的指针的引用作为T*&传递来进行修改。但是，根据您表示的内容，您也可以像传递std::vector<T>&一样传递数据。|2564969|2564970|智能指针的存在是为了自动管理对象的生命周期，这取决于您希望如何使用这些对象。它们不是纯粹作为一种间接的方式存在的，它对许多不同的用法都是开放的，比如原始指针。关于使用哪种工具，我的建议如下：|2564971|如果你需要一个简单的可调整大小的数组，使用std::vector<T>.|2564972|If你需要一个可调整大小的二维数组，使用std::vector<std::vector<T>>.|2564973|
|2564974|If你知道你的数组中总是有N元素，考虑使用std::array<T,+N>.|2564975|2564976|If你需要更多的结构，例如严格的排序或关系，考虑使用std::set，std::map，std::multimap，std::queue，D31，等等H232F233|2564977|2564978|关于智能指针：|2564979|如果你需要一个轻量级的对象来传递，但只有一个所有者，或者如果你需要封装一个在一个地方使用的多态对象，考虑std::unique_ptr<T>|2564980|If你需要一个对象在代码中被多个地方使用，它没有一个合理的所有权位置，而是需要具有分布式所有权，使用std::shared_ptr<T>|2564981|2564982|If你想从一个函数内部修改一个对象，以便该对象在函数需要的持续时间内一直存在，|2564983|。只需通过引用传递:要读取但不修改函数中对象，且该对象在函数需要的持续时间内处于活动状态的T&|2564984|If，通过引用传递给const：const+T&|2564985|2564986|2564987|编辑：|2564988|在看到你的作业不允许使用std::vector之后，我意识到我并没有真正回答你更新的问题。但我仍然希望给你(和未来的读者)一些关于智能指针是用来做什么，它们不是用来做什么的一些洞察力。|2564989|如果你的讲师正在教授C%2B%2B，但不允许你使用vector，我会批评他们说，vector是现代C%2B%2B开发人员的一个极其重要的工具，它的使用比许多过时的课程中仍然作为C%2B%2B教授的C风格的替代品简单得多，也更安全。其他工具和技术也是如此，比如避免使用指针，避免使用new和delete，以及很好地利用标准库的容器和算法，所有这些都可以帮助您编写更干净、更正确和高效的代码。|2564990|entityMap^0|0|0|1C|1|1E|1|0|G|R|19|V|3O|1|3X|3|4R|F|0|0|0|L|E|0|K|R|0|0|D|1|L|G|0|0|Q|8|Z|8|18|D|1M|A|0|0|0|1G|I|0|1E|I|0|0|0|19|2|0|G|8|0|0|0|0|C|B|0|L|6|10|6|3K|3|3O|6|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1P|8|@$F|1Q|G|1R|H|I]|$F|1S|G|1T|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|1U|8|@$F|1V|G|1W|H|I]|$F|1X|G|1Y|H|I]|$F|1Z|G|20|H|I]|$F|21|G|22|H|I]|$F|23|G|24|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|25|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|26|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|27|8|@$F|28|G|29|H|I]]|9|@]|A|$]]|$1|Q|3|R|5|E|7|2A|8|@$F|2B|G|2C|H|I]]|9|@]|A|$]]|$1|S|3|T|5|6|7|2D|8|@]|9|@]|A|$]]|$1|U|3|V|5|E|7|2E|8|@$F|2F|G|2G|H|I]|$F|2H|G|2I|H|I]]|9|@]|A|$]]|$1|W|3|T|5|6|7|2J|8|@]|9|@]|A|$]]|$1|X|3|Y|5|E|7|2K|8|@$F|2L|G|2M|H|I]|$F|2N|G|2O|H|I]|$F|2P|G|2Q|H|I]|$F|2R|G|2S|H|I]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|2T|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2U|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2V|8|@$F|2W|G|2X|H|I]]|9|@]|A|$]]|$1|14|3|15|5|E|7|2Y|8|@$F|2Z|G|30|H|I]]|9|@]|A|$]]|$1|16|3|T|5|6|7|31|8|@]|9|@]|A|$]]|$1|17|3|18|5|E|7|32|8|@]|9|@]|A|$]]|$1|19|3|1A|5|E|7|33|8|@$F|34|G|35|H|I]]|9|@]|A|$]]|$1|1B|3|1C|5|E|7|36|8|@$F|37|G|38|H|I]]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|39|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|3A|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|3B|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|3C|8|@$F|3D|G|3E|H|I]]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|3F|8|@$F|3G|G|3H|H|I]|$F|3I|G|3J|H|I]|$F|3K|G|3L|H|I]|$F|3M|G|3N|H|I]]|9|@]|A|$]]|$1|1L|3|-4|5|6|7|3O|8|@]|9|@]|A|$]]]|1M|$]]

Smart points are generic; you can stick basically anything you want inside one. But you should decide the right tool for the job based on what it is you're trying to achieve. Smart pointers have fairly specific use cases. Pointers to pointers, on the other hand, have a couple different use cases:

<ul>
<li>pointer arrays of pointer arrays, for implementing 2D arrays. If this is what you're trying to achieve, consider using <code>std::vector&lt;std::vector&lt;T&gt;&gt;</code> or <code>std::array&lt;std::array&lt;T, N&gt;, M&gt;</code> if you know your array will always have size <code>M</code>x<code>N</code>.</li>
<li>pointer to a pointer, as used for modifying another pointer from a function. In this case, you should consider passing by reference. If you really need pointers in your code, you could modify one by passing as <code>T*&amp;</code>, a reference to a pointer to <code>T</code>. But depending on what you're representing, you could just as well pass your data as <code>std::vector&lt;T&gt;&amp;</code>, for example.</li>
</ul>

Smart pointers exist to automatically manage the lifetime of objects depending on how you want those objects to be used. They don't exist purely as a means of indirection that is open to many different usages, like raw pointers. My advice on which tool to use would be as follows:

<ul>
<li>If you need a simple resizable array of <code>T</code>, use <code>std::vector&lt;T&gt;</code>.</li>
<li>If you need a 2D resizable array of <code>T</code>, use <code>std::vector&lt;std::vector&lt;T&gt;&gt;</code>.</li>
<li>If you know you will always have <code>N</code> elements in your array, consider using <code>std::array&lt;T, N&gt;</code>.</li>
<li>If you need more structure, such as strict ordering or relationships, consider using <code>std::set</code>, <code>std::map</code>, <code>std::multimap</code>, <code>std::queue</code>, <code>std::stack</code>, etc</li>
</ul>

About smart pointers:

<ul>
<li>If you need an object that is light-weight to pass around but only ever has a single owner, or if you need to encapsulate a polymorphic object that is used in a single place, consider <code>std::unique_ptr&lt;T&gt;</code></li>
<li>If you need an object to be used by multiple places in code which does not have a single sensible place of ownership and instead needs to have distributed ownership, use <code>std::shared_ptr&lt;T&gt;</code></li>
<li>If you want to modify an object from inside a function such that the object will live for the duration of the function's needs, just pass by reference: <code>T&amp;</code></li>
<li>If you want to read from but not modify an object in a function where that object will be alive for the duration of the function's needs, pass by reference to const: <code>const T&amp;</code></li>
</ul>

EDIT:

After seeing that you are not allowed to use <code>std::vector</code> for your assignment, I realize I'm not really answering your updated question. But I still hope to give you (and future readers) some insight as to what smart pointers are for and what they're not for.

If your instructor is teaching C++ but not allowing you to use <code>vector</code>s, I would criticize them by saying that <code>vector</code> is an immensely important tool on the belt of the modern C++ developer, and its usage is far simpler and safer than the C-style alternatives that are still taught as being C++ in many outdated curriculums. The same goes other tools and techniques such as generally avoiding pointers, avoiding <code>new</code> and <code>delete</code>, and making good use of the containers and algorithms of the standard library, all of which helps you write cleaner, correcter, and efficient code.

I am brand new to C++ (and Stack Overflow!) so I apologize if this question has already been answered in some capacity, I just wasn't able to find exactly what I was looking for.

In a recent project, I created pointers to pointers (example: Tiger **tigerArray;) and wound up having memory leaks in my program, but I was never able to figure out why. I had a thought that maybe if I had done smart pointers instead of just pointers, that may have solved the problem?

So I'm curious, if I can create a pointer to a pointer, can I create a smart pointer to a smart pointer? 

**Sorry I should update, I wasn't allowed to use vectors for this assignment, we had to use arrays

Can I make a smart pointer to a smart pointer?

容器

我是一个全新的C++ (和堆栈溢出！)因此，如果这个问题已经在某种程度上得到了回答，我很抱歉，我只是无法找到我正在寻找的东西。在最近的一个项目中，我创建了指向指针的指针(例如: Tiger **tigerArray;)，结果在我的程序中出现了内存泄漏，但我始终无法找出原因。我有一个想法，如果我做的是智能指针，而不仅仅是...

问我可以让智能指针指向智能指针吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我可以让智能指针指向智能指针吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我可以让智能指针指向智能指针吗？
EN