blocks|key|205124|text|不，这不是因为TA是私有的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|205125|此外，正如注释中所建议的，基类的析构函数应该是虚拟的。这通常是一个很好的实践，因为您不能保证您的类的实例将只与共享指针一起使用。|205126|要使其正常工作，您至少必须修改以下行：|205127|class+TA+{++};
class+TB+:+TA+{++};|code-block|syntax|javascript|205128|如下所示：|205129|class+TA+{+virtual+~TA()+{+}+};
class+TB+:+public+TA+{++};|205130|这些都很好，因为下面的示例很好|205131|class+TA+{+virtual+~TA()+{+}+};
class+TB+:+public+TA+{++};

TA+*spta+=+nullptr;
spta+=+new+TB;|205132|这主要取决于对你来说什么是好的。至少这是合法的。|205133|entityMap^0|7|2|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|14|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|15|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|16|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|17|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|18|8|@]|D|@]|E|$]]|$1|U|3|V|5|L|7|19|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|Z|$]]

No, it is not for <code>TA</code> is private.

Moreover, as suggested in the comments, the destructor of the base class ought to be virtual. It is usually a good practice, for you cannot guarantee that instances of your classes will be used only with shared pointers.

To have it working, you must at least modify these lines:

<pre><code>class TA { };
class TB : TA { };
</code></pre>

As it follows:

<pre><code>class TA { virtual ~TA() { } };
class TB : public TA { };
</code></pre>

Those ones are good as the following example is good:

<pre><code>class TA { virtual ~TA() { } };
class TB : public TA { };

TA *spta = nullptr;
spta = new TB;
</code></pre>

It mainly depends on what good means for you. It's legal, at least.

blocks|key|209184|text|这里显示的代码有一个问题，TB必须公开继承自TA。您有一个shared_ptr<TA>，所以您想要存储在其中的指针必须可以转换为TA，但是使用private继承时，基是不可访问的，因此您的代码将无法编译。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|209185|class+TA+++++++++++++{++};
class+TB+:+public+TA+{++};|code-block|syntax|javascript|209186|除此之外，代码没有错误并且行为良好。通常，当您通过基类指针执行派生类实例的多态删除时，需要基类的析构函数为virtual，以便调用派生类析构函数，但对于shared_ptr，这不是必需的。shared_ptr::reset是一个函数模板，它可以接受任何可转换为托管指针类型的Y*。shared_ptr的constructor+template也是如此。|209187|话虽如此，您应该更喜欢将基类的析构函数设为virtual，特别是当涉及的类具有其他virtual函数时。|209188|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/memory/shared_ptr/reset|1|http://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr^0|D|2|M|2|T|E|1S|2|1Z|7|0|0|1H|7|24|A|2M|H|3T|2|3W|A|2M|H|0|47|K|1|0|L|7|15|7|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@$9|1L|A|1M|1|1N]|$9|1O|A|1P|1|1Q]]|E|$]]|$1|M|3|N|5|6|7|1R|8|@$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

There's one problem with the code shown, <code>TB</code> must inherit publicly from <code>TA</code>. You have a <code>shared_ptr&lt;TA&gt;</code>, so the pointer you want to store in it must be convertible to <code>TA</code>, but with <code>private</code> inheritance, the base is inaccessible so your code will not compile.

<pre><code>class TA { };
class TB : public TA { };
</code></pre>

Beyond this, the code has no errors and is well-behaved. Typically, when you perform polymorphic deletion of a derived class instance through a base class pointer, you need the base class' destructor to be <code>virtual</code> so the derived class destructor is called, but in case of <code>shared_ptr</code> this is not necessary. <a href="http://en.cppreference.com/w/cpp/memory/shared_ptr/reset" rel="nofollow"><code>shared_ptr::reset</code></a> is a function template that'll accept any <code>Y*</code> that is convertible to the managed pointer type. The same is true for <code>shared_ptr</code>'s <a href="http://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr" rel="nofollow">constructor template</a>.

That being said, you should prefer making the base class' destructor <code>virtual</code>, especially if the classes involved have other <code>virtual</code> functions.

blocks|key|212101|text|这并不是对这个问题的回答，而是试图澄清关于shared_ptr的看似神奇的能力的任何混淆，以避免使用虚拟析构函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|212102|这是一个小的演示程序：|212103|#include+<iostream>
#include+<memory>

struct+A+{
++++~A()+{+std::cout+<<+__func__+<<+std::endl;+}

++++void+foo()+{+do_foo();+}

protected:
++++virtual+void+do_foo()+{
++++++++std::cout+<<+"A::"+<<+__func__+<<+std::endl;
++++}
};

struct+B+:+A+{
++++~B()+{+std::cout+<<+__func__+<<+std::endl;+}

++++virtual+void+do_foo()+override+{
++++++++std::cout+<<+"B::"+<<+__func__+<<+"+";
++++++++A::do_foo();
++++}
};

using+namespace+std;

auto+main()+->+int
{
++++std::shared_ptr<A>+p+=+std::make_shared<A>();
++++p->foo();
++++p+=+std::make_unique();
++++p->foo();

++++cout+<<+"deleting+B:"+<<+endl;
++++return+0;
}|code-block|syntax|javascript|212104|预期输出：|212105|A::do_foo
~A
B::do_foo+A::do_foo
deleting+B:
~B
~A|212106|请注意，当在main()的末尾销毁B时，调用了正确的析构函数。|212107|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This is not an answer to the question, it is an attempt to clear up any confusion about shared_ptr's seemingly magical ability to avoid the use of a virtual destructor.

Here's a little demo program:

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

struct A {
 ~A() { std::cout &lt;&lt; __func__ &lt;&lt; std::endl; }

 void foo() { do_foo(); }

protected:
 virtual void do_foo() {
 std::cout &lt;&lt; "A::" &lt;&lt; __func__ &lt;&lt; std::endl;
 }
};

struct B : A {
 ~B() { std::cout &lt;&lt; __func__ &lt;&lt; std::endl; }

 virtual void do_foo() override {
 std::cout &lt;&lt; "B::" &lt;&lt; __func__ &lt;&lt; " ";
 A::do_foo();
 }
};

using namespace std;

auto main() -&gt; int
{
 std::shared_ptr&lt;A&gt; p = std::make_shared&lt;A&gt;();
 p-&gt;foo();
 p = std::make_unique&lt;B&gt;();
 p-&gt;foo();

 cout &lt;&lt; "deleting B:" &lt;&lt; endl;
 return 0;
}
</code></pre>

expected output:

<pre><code>A::do_foo
~A
B::do_foo A::do_foo
deleting B:
~B
~A
</code></pre>

Notice that the correct destructor was called when the B was destroyed at the end of main().

Is the following approach good?

<pre><code>class TA { };
class TB : TA { };

std::shared_ptr&lt;TA&gt; spta;
spta.reset(new TB);
</code></pre>

Usage of Derived class with the std::shared_ptr of Base class

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

下面的方法好吗？class TA { };class TB : TA { };std::shared_ptr<TA> spta;spta.reset(new TB);

问通过基类的std::shared_ptr使用派生类
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问通过基类的std::shared_ptr使用派生类EN