blocks|key|4915548|text|删除实例时，即使没有析构函数，所有类成员也会被删除。在处理指针时，会发生内存泄漏：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4915549|class+A
{
private:
+++B*+b;
};|code-block|syntax|javascript|4915550|在这种情况下，当A实例被删除时，b本身将被销毁，但它指向的内存不会被销毁。|offset|length|style|CODE|4915551|class+A
{
private:
+++SmartPtr+b;
};|4915552|在智能指针的情况下，通常在析构函数中有一些引用计数和内存清理，它所指向的内存将被其析构函数显式销毁，并且当包含类的实例被销毁时，智能指针的析构函数将被隐式调用。|4915553|entityMap^0|0|0|8|1|G|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

All class members are deleted even if you don't have a destructor when the instance is deleted. Memory leaks occur when you deal with pointers:

<pre><code>class A
{
private:
 B* b;
};
</code></pre>

In this case, <code>b</code> itself will be destroyed when the instance of <code>A</code> is deleted, but the memory it points to will not. 

<pre><code>class A
{
private:
 SmartPtr&lt;B&gt; b;
};
</code></pre>

In the case of smart pointers, which usually have some reference counting and memory cleanup in the destructor, the memory it points to will be explicitly destroyed by its destructor, and the destructor of the smart pointer will be implicitly called when the instance of the containing class is destroyed.

blocks|key|878609|text|是。这就是智能指针的用途。http://www.boost.org/doc/libs/1_48_0/libs/smart_ptr/smart_ptr.htm|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|878610|http://en.wikipedia.org/wiki/Smart_pointer|878611|What+is+a+smart+pointer+and+when+should+I+use+one?|878612|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_48_0/libs/smart_ptr/smart_ptr.htm|1|2|https://stackoverflow.com/q/106508/1155650^0|D|1T|0|0|0|16|1|0|0|1E|2|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|H|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|E]]|Q|$5|K|L|M|C|$N|R]]]]

yes. that s what smart pointers are used for. 
<a href="http://www.boost.org/doc/libs/1_48_0/libs/smart_ptr/smart_ptr.htm" rel="nofollow noreferrer">http://www.boost.org/doc/libs/1_48_0/libs/smart_ptr/smart_ptr.htm</a>

<a href="http://en.wikipedia.org/wiki/Smart_pointer" rel="nofollow noreferrer">http://en.wikipedia.org/wiki/Smart_pointer</a>

<a href="https://stackoverflow.com/q/106508/1155650">What is a smart pointer and when should I use one?</a>

blocks|key|878499|text|是的，无论类是否有析构函数，智能指针都会删除对象。请注意，智能指针与堆上分配的对象一起使用(使用new)，并且这些对象在超出作用域时不会释放内存，您需要显式地delete它们。智能指针将删除这个显式删除它们的过程。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|878500|entityMap^0|1C|3|27|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Yes, smart pointer deletes the object irrespective of whether class has destructor or not. Note that smart pointers are used with objects allocated on heap (using <code>new</code>) and these object won't release memory when they go out of scope, you need to explicitly <code>delete</code> them. Smart pointers will remove this process of explicitly deleting them.

blocks|key|4915495|text|指向对象本身的指针将被删除。但是，如果类中有任何动态分配的数据，它将不会被释放。拥有析构函数的想法是能够对类对象进行后处理，并主要释放所占用的任何资源。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4915496|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The pointer to the object itself will be deleted. However if there is any dynamically allocated data in the class it will not get freed. The idea of having a destructor is to be able to post-process the class object and mainly - free any resources taken.

blocks|key|1692049|text|new和delete做两件事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692050|new分配内存，并获取一个对象以在该内存空间中构建自身。delete首先让对象自毁，然后释放内存。|offset|length|style|CODE|1692051|请注意，一些智能指针可以被赋予一个自定义的deleter，它不会调用对象上的delete，而是您要求它执行的任何操作。在某些情况下，您可能希望将其设置为no-op。|1692052|entityMap^0|0|0|3|S|6|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

new and delete do two things.

<code>new</code> allocates memory and gets an object to construct itself in that memory space.
<code>delete</code> first gets the object to destruct itself then releases the memory.

Note that some smart pointers can be given a custom deleter which doesn't call delete on the object but whatever you ask it to do. There may be occasions when you wish to pass it a no-op.

blocks|key|4915672|text|您的观点得到了很好的理解；在C%2B%2B中，智能指针的用法并不多，因为在大多数情况下，它们可能是相关的，您最好使用值语义并进行复制。在scoped_ptr的情况下，最常见的用法是当实际对象是多态的时候：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4915673|scoped_ptr<Base>+pObj+=+condition+
++++++++++++++++++++++++?+static_cast<Base*>(+new+Derived1+)
++++++++++++++++++++++++:+static_cast<Base*>(+new+Derived2+);|code-block|syntax|javascript|4915674|(遗憾的是，至少有一个static_cast是必需的。)|4915675|如果您正在处理多态对象的容器，则需要使用shared_ptr；如果您要返回多态对象，或者以其他方式传递它，那么如果可以保证其可用性，则使用unique_ptr，否则使用auto_ptr+-在某些情况下，传递它时，shared_ptr可能更合适。|4915676|在返回或传递对象的情况下，即使对象不是多态的，复制它的成本也可能是使用智能指针的动机。在这种情况下，我仍然会使用值语义(即复制和赋值对象本身)，除非我有性能问题。|4915677|请注意，智能指针不仅用于内存管理。我经常在线程之间的队列接口中使用auto_ptr：一旦对象被插入到队列中，它就不再属于发送线程；auto_ptr准确地表达了这些语义，发送线程中的auto_ptr变得无效。或者一个可修改的单例(这应该是非常非常罕见的)可能会在其instance函数中获得一个锁，并返回一个释放其最终析构函数中的锁的shared_ptr。我还在一两种情况下使用了智能指针来确保事务性语义:例如，在一种情况下，对象位于许多不同的集合中(当然，这些集合包含指向它们的指针)，并根据不同的标准进行排序。要修改一个对象，您需要获取一个指向该对象的共享指针；返回该共享指针的函数还从集合中删除了对象，以便您也可以安全地修改键值，并且最终的析构函数根据新的键将它们重新插入到集合中。依此类推--智能指针有许多与内存管理或对象生存期无关的用途。|4915678|entityMap^0|1S|A|0|0|B|B|0|K|A|1X|A|2C|8|2Y|A|0|0|X|8|1T|8|2I|8|3N|8|4M|A|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|T|$]]

Your point is well taken; there aren't that many uses for smart pointers
in C++, since most of the time where they might be relevant, you'd be
better off using value semantics, and copying. In the case of
<code>scoped_ptr</code>, the most frequent use is when the actual object is
polymorphic:

<pre><code>scoped_ptr&lt;Base&gt; pObj = condition 
 ? static_cast&lt;Base*&gt;( new Derived1 )
 : static_cast&lt;Base*&gt;( new Derived2 );
</code></pre>

(Regretfully, at least one of the <code>static_cast</code> is necessary.)

If you are dealing with a container of polymorphic objects, you'll need
<code>shared_ptr</code> instead, and if you're returning a polymorphic object, or
otherwise passing it around, you will use <code>unique_ptr</code> if you can
guarantee its availability, and <code>auto_ptr</code> otherwise&mdash;in some cases
where you're passing it around, <code>shared_ptr</code> might be more appropriate.

In the case of returning an object or passing it around, the cost of
copying it might also be a motive for using a smart pointer, even if the
object isn't polymorphic. In such cases, I'd still use value semantics
(i.e. copying and assigning the object itself) unless I had a
performance problem.

Note that smart pointers aren't only used for memory management. I
regularly use <code>auto_ptr</code> in the interface of queues between threads:
once the object has been inserted into the queue, it no longer belongs
to the sending thread; <code>auto_ptr</code> expresses these semantics exactly,
with the <code>auto_ptr</code> in the sending thread becoming invalid. Or a
modifiable singleton (something which should be very, very rare) might
acquire a lock in its <code>instance</code> function, and return a <code>shared_ptr</code>
which frees the lock in its final destructor. I've also used smart
pointers in one or two cases to ensure transactional semantics: in one
case, for example, the objects were in a number of different sets (which
held pointers to them, of course), ordered according to different
criteria. To modify an object, you acquired a shared pointer to it; the
function which returned this shared pointer also removed the objects
from the sets, so that you could safely modify the key values as well,
and the final destructor reinserted them into the sets according to the
new keys. And so on&mdash;there are any number of uses for smart
pointers that have nothing to do with memory management or object
lifetime.

Will the smart pointer or scoped pointers delete an object when the class has no destructor
If not, why not just leave the scope and let the object be deleted by itself?

Will the smart pointer or scoped pointers delete an object when the class has no destructor

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

当类没有析构函数时，智能指针或作用域指针会删除对象吗?如果没有，为什么不离开作用域，让对象自己删除呢？

问当类没有析构函数时，智能指针或作用域指针是否会删除对象
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当类没有析构函数时，智能指针或作用域指针是否会删除对象EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当类没有析构函数时，智能指针或作用域指针是否会删除对象
EN