VB6类是否有析构函数？
是的，VB6类有析构函数。
析构函数是一个在对象销毁时调用的特殊方法，用于清理对象内存，回收资源，并完成其他清理工作。在VB6中，每个对象都有一个析构函数，即使对象被声明为私有或静态私有。
以下是一个简单的VB6析构函数示例：
Private Sub Class_Terminate()
' 调用清理方法
CleanUp
End Sub在这个示例中，Class_Terminate 方法是一个析构函数，它调用了 CleanUp 方法来执行清理操作。在应用程序关闭时，会自动调用 Class_Terminate 方法，从而触发 CleanUp 方法的执行。
需要注意的是，析构函数只能在对象销毁时调用，因此无法在程序运行期间使用它。此外，析构函数不能直接调用任何形式的资源回收操作。在清理资源时，应该使用其他方法，例如 Set 语句来释放对象引用，或者直接将对象设置为 Nothing 来让垃圾回收器处理它。
相关·内容
1回答
我在VB6的一个类中创建了一个构造函数，但是看起来New关键字是一个问题，编译器不允许我使用它，我确信它是一个保留字，但是为什么不是构造函数。
Public Sub New(ByVal Name As String)
'Statements
End Sub
我收到指向'New‘关键字的错误。有没有解决这个问题的办法，或者VB6的参考资料？
浏览 8提问于2017-01-17得票数 2
回答已采纳
考虑一个简单的接口/实现设计：
class Base
{
public:
virtual ~Base()
{
// Virtual empty destructor
}
};
class Derived : public Base
{
public:
virtual ~Derived()
{
// Lots of clean up code here
// ...
}
};
使用此设计，我理解以下代码是安全和有效的：
Base* base = new Derived();
delete bas
浏览 0提问于2013-01-11得票数 3
回答已采纳
3回答
请考虑以下几点
class base{
base();
~base();
}:
class derived : public base{
};
当派生对象被析构并且派生类没有定义析构函数时，是否会自动调用基类析构函数？
否则，如果我在派生类中也有析构函数，我是否也需要显式调用基类析构函数？
class base{
base();
~base();
}:
class derived : public base{
derived();
~derived
base::~base(); //do I need this?
浏览 2提问于2011-04-05得票数 8
回答已采纳
我有一个问题，我看到在一些代码中，派生类中的虚拟析构函数是空的，那么为什么我们需要它，因为它什么也不做？它是否用于调用基类中的析构函数，如果没有它，则不能调用析构函数？或者仅仅是一个符号，告诉代码阅读器这个析构函数是虚拟的，这使得代码更容易阅读？谢谢!
浏览 4提问于2014-10-25得票数 4
回答已采纳
出于好奇，我试着做一些类似下面的例子，看看编译器是否给了我一个警告，而不是调用一个无穷无尽的循环，最终导致堆栈溢出。我想也许有一种不同的行为，而不仅仅是调用普通的函数或方法。但事实并非如此。有什么特别的解释吗?或者它只是作为普通的函数调用来处理，因为我是使用this操作符显式地调用基类析构函数？
示例：
class A {
virtual ~A();
};
class B : A {
virtual ~B() { this->~A(); }
};
浏览 5提问于2017-02-22得票数 0
回答已采纳
我有一个struct O，用第三方代码定义。因为它是C代码，所以它不定义virtual destructor。(在我的例子中，它是来自OVERLAPPED struct的win32 appi)。
我正在修改的客户代码有一个class S，它来自class A，来自struct O。
struct O{};
class A : public O{};
class S : public A{};
他们中没有人将其析构函数声明为virtual。
如果在指向delete的指针上调用O，则会出现泄漏。好的。
但是，如果我曾经在指向S的指针上调用delete，那么delete标准会指出什么呢？它是否会自动
浏览 8提问于2015-02-02得票数 1
回答已采纳
6回答
基于我发现的和堆栈溢出上的其他链接，如果我们计划以多形性方式使用它，那么我们应该始终在基类中定义一个虚拟析构函数。我想知道这条规则是否有例外。
我已经看到了不为纯抽象基类定义虚拟析构函数的生产代码，在cppcon 2014视频中，大约10:06定义的BoolExp结构是一个纯抽象类，没有虚拟析构函数。
所以对于这样定义的纯抽象类
class Base {
public:
virtual foo() = 0;
virtual bar() = 0;
}
我的问题是，我们必须为“基类”定义一个虚拟析构函数，即使它有任何数据成员？虚拟析构规
浏览 1提问于2019-07-30得票数 5
回答已采纳
3回答
我有Y型的类层次结构: C类继承A和B，D类继承C，A和B有虚拟析构函数，C的析构函数不是虚拟的。我知道，如果没有双重继承(比方说没有B)，那么C()将是虚拟的。我的问题是双重继承会影响它吗？
class A { virtual ~A(); ...};
class B { virtual ~B(); ...};
class C : public A, public B { ~C(); ...};
class D : public C { virtual ~D(); ... };
我必须通过指向C的指针删除D类的实例。
C* c = new D;
delete c;
我怀疑有一些角落的情况下，~
浏览 0提问于2019-01-18得票数 0
回答已采纳
3回答
我在一个类中声明了一个结构的向量。我的问题是，我是必须显式地释放由类析构函数中的向量分配的内存，还是在销毁实例时自动释放。同样，我是否必须在类析构函数中包含代码来释放向量的内存。
浏览 3提问于2013-06-24得票数 0
回答已采纳
我有一个抽象基类，它的目的是允许创建指向基类的指针数组。(适用于“许多事物”)
我的抽象基类不包含任何成员函数。因此，没有纯粹的虚拟方法，因此我认为它在技术上并不抽象。
但是，我不希望能够创建这个类的实例。
是否可以创建一个无成员的抽象基类？如果没有，是否有另一个解决方案来阻止创建我的“抽象基础”的实例？使构造函数protected满足吗？
有人向我指出，实际上，如果该类的目的是允许创建指向基类的向量或指针数组，则不需要抽象基类--您可以简单地不使用基类并将继承层次结构顶部的类用作基类。或者，您可以复制和粘贴该顶级类，并将实现的方法转换为没有实现的纯虚拟函数，但是这在逻辑上似乎与抽象基指针的思
浏览 1提问于2015-08-03得票数 1
回答已采纳
假设我们有三门课:父母，孩子和其他。
class Parent: {
public:
Parent(std::string title): m_title(title) { }
void setTitle (std::string title);
private:
std::string m_title;
};
class Child: public Parent {
public:
Child(std::string title) { setTitle(title); }
private:
Other object;
};
class Other
浏览 6提问于2013-09-05得票数 1
回答已采纳
2回答
当派生类不是立即派生，而是从已经派生的类派生时，我对重写函数感到困惑。
#include <iostream>
struct Base
{
virtual ~Base() { std::cout << "Base destructor called\n"; }
};
struct Derived : Base
{
Derived() {}
// Implicitly supplied destructor, I'm guessing. Which is also virtual?
};
struct MostDer
浏览 0提问于2018-01-26得票数 3
回答已采纳
当一个类的dtor为空时，当它自己的dtor从联合中显式调用时，它会调用成员的dtor吗？
这是一种困难的文字，希望伪代码是更直接的。在本例中，Texture::~Texture()是否会隐式调用source.bitmap.pixels.~vector()？
struct Bitmap{
~Bitmap(){} // empty dtor
// members
std::vector<uint8> pixels; // <-- will this dealloc when ~Bitmap() is called manually?
};
stru
浏览 27提问于2019-11-04得票数 0
回答已采纳
3回答
是否可以删除抽象类而不是子类？是否所有分配都会因此而被释放？
请考虑以下情况作为示例，但请不要将您的答案限制在这种情况下：
struct A {
virtual void fun() = 0;
};
struct B : public A {
void fun() { /* actually doing something here. */ }
};
struct C {
A *a;
void OneTask() {
// (...)
a = new B();
}
void AnotherTask() { /* u
浏览 0提问于2013-04-11得票数 1
1回答
从模板列表中删除对象
、、、、
我有一个模板列表，
List<SuperClass*>* mList;
for(int i = 0;i < mList->ElementsCount();i++)
mList->DeleteElementAtIndex(i);
在mList中添加了子类的对象。
从列表中删除对象时，是否需要将对象转换为相应的子类并调用delete方法？
浏览 3提问于2010-09-22得票数 1
回答已采纳
2回答
假设我们有：
class A {
protected:
int* iArr;
float *fArr;
public:
A(int* iArr,float *fArr);
~A();
}
class B : public A {
private:
double *dArr;
public:
B(int* iArr,float *fArr,double *dArr);
~B();
}
我的直觉是，它只会调用B的析构函数，但是当我在VisualC++上运行它时，我看到在销毁B的实例时，它同时调用A和B析构函数。
那么，在派生类中编写析构函数
浏览 5提问于2012-06-10得票数 3
回答已采纳
可能重复：
可能重复
我想知道是否有人能帮我理解虚拟析构函数的需求。
我已经用一个主对话框编写了一个应用程序，从这个主对话框中将生成其他派生对话框。
因此，所有这些派生对话框是否都需要一个虚拟析构函数？或者仅仅是主对话框？
提前谢谢你
浏览 1提问于2013-02-01得票数 1
假设我们有下一个代码：
class ISampleInterface
{
public:
virtual ~ISampleInterface() {} ;
virtual void Method1() = 0;
virtual void Method2() = 0;
};
class SampleClass : public ISampleInterface
{
public:
SampleClass() { };
~SampleClass() override { };
void Method1() { };
void Method2
浏览 3提问于2015-11-20得票数 2
我有一个场景，我正在编写一些深层的面向对象的代码，具有多层抽象基类，我想知道是否必须为每个抽象基类显式声明一个析构函数。
编译器是否会生成一个已经是虚拟的缺省值，或者我必须告诉它？
浏览 0提问于2011-04-10得票数 21
回答已采纳
堆栈溢出上有，它提倡Scott规则，即只有在该类中有虚拟函数时才使析构函数变为虚拟的。
我在一家拥有大型框架的公司工作，在编写代码时还不清楚您的类将来是否会被扩展。此时，也不可能更改该类(因为它是已发布包的一部分)。
现在设想以下场景：
class A {
public:
A();
virtual ~A();
virtual m();
};
class B : public A {
public:
B();
~B();
};
class C : public B {
public:
C();
virtual ~C();
virtual m();
};
因此，
浏览 2提问于2015-05-22得票数 3
回答已采纳
1回答
抽象类、继承和虚拟析构函数
、、、、
即使B的析构函数不是virtual，我仍然可以通过B指针调用C的析构函数。
这是否意味着只有最外层的抽象类需要有一个virtual析构函数？
如果是的话，它为什么会这样工作呢？
是因为B继承了A的析构函数吗？
#include <iostream>
struct A {
virtual ~A() {
std::cout << "~A\n";
}
virtual void
function_a() = 0;
};
struct B : A {
/*
virtual ~B() {
浏览 1提问于2020-03-06得票数 1
回答已采纳
4回答
重写析构函数C++
、、、、
来自C++常见问题解答：
11.4我可以为我的班级超载这个析构函数吗？不是的。
我意识到这意味着您不能更改返回类型、参数类型和参数数量。我可能会在单词的语法上大发雷霆，但是否有可能覆盖父级的析构函数？
class Child : public Parent {
public:
virtual Parent::~Parent() {
// New definition
}
};
就这件事来说，它是递归的吗？
class Grandchild : public Child {
public:
Child::Parent::~Parent() {
浏览 6提问于2013-06-13得票数 11
回答已采纳
1回答
C++标准对具有异常规范的虚拟函数声明如下：
如果一个虚拟函数具有异常规范，则任何函数在任何派生类中覆盖该虚拟函数的所有声明，包括定义，都只能允许基类虚拟函数的异常规范允许的异常(C++03§15.4/3)。
因此，以下内容是不正确的：
struct B {
virtual void f() throw() { } // allows no exceptions
};
struct D : B {
virtual void f() { } // allows all exceptions
};
(1)这条规则是否适用于析构函数？也就是说，下面的内容是否有
浏览 2提问于2010-07-12得票数 14
回答已采纳
3回答
我的问题很简单，但我在任何地方都找不到问题。
如果我有一个这样的类
class A {
vector<int> data;
}
当A的实例被销毁时，data也会被销毁吗?或者我应该为A编写一个析构函数来调用data的析构函数吗?基本上我担心当A的实例被销毁时，向量的动态内存是否不会被释放。我怀疑答案是data被正确地释放了，但我不想以一种艰难的方式发现我错了。
此外，如果A是一个结构，当data的本地实例超出作用域时，会调用A的析构函数吗？
浏览 3提问于2012-02-29得票数 15
回答已采纳
2回答
假设我有两个类似于非虚拟析构函数的简单类：
struct A
{
~A() { std::cout << "A destructor" << std::endl; }
}
struct B : A
{
~B() { std::cout << "B destructor" << std::endl; }
}
当B的一个实例被解构时，也会调用A的析构函数。当我通过一个类型为B的指针来解构A*实例时，B的析构函数将不会被调用。这是否也包括以同样调用普通成员函数的方式显式调用析构函数？
struct A
{
浏览 5提问于2015-09-13得票数 0
回答已采纳
我有一个名为MyBase的类，它有一个构造函数和一个析构函数：
class MyBase
{
public:
MyBase(void);
~MyBase(void);
};
我有一个名为Banana的类，它像这样扩展MyBase：
class Banana:public MyBase
{
public:
Banana(void);
~Banana(void);
};
香蕉中新的构造函数和析构函数的实现是否覆盖了MyBase的构造函数和析构函数，或者它们仍然存在，并在香蕉的构造函数/析构函数执行之前或之后被调用？
谢谢，如果我的问题看起来很愚蠢，我很抱歉。
浏览 0提问于2009-10-29得票数 15
回答已采纳
1回答
我知道类对象的终结顺序如下：
析构器的执行体
销毁对象(即释放用于数据成员的内存)
现在有人问我关于派生类对象的终结顺序。我认为它完全相同，但是在执行上述步骤之后，基类对象的析构函数是否也被调用了呢？
我不这么认为，但想确定考试的结果。
(谢谢你的帮助:)
浏览 5提问于2015-01-05得票数 0
回答已采纳
3回答
我发现几乎每个虚拟析构函数的代码片段都将其作为公共成员函数，如下所示：
class Base
{
public:
virtual ~Base()
{
cout << "~Base()" << endl;
}
};
class Derived : public Base
{
public:
~Derived()
{
cout << "~Derived()" << endl;
}
};
虚拟析构函数是否必须是公共的，或者是否存在非公共虚拟
浏览 25提问于2013-03-20得票数 17
回答已采纳
是否需要将C++析构函数定义为虚拟的？如果是的话，为什么？我已经读过，当您将基类指针转换为派生类时，它们需要确保进行适当的清理。
浏览 4提问于2014-02-18得票数 2
回答已采纳
我的一位同事声称，一旦对象的析构函数调用开始，由线程(即对象本身的成员)完成的对对象成员的所有访问都是UB。
这意味着，如果线程正在访问对象的任何其他成员，则在对象的析构函数期间调用std::thread::join是UB。
我简要地查看了最新的标准草案，在“对象生命周期”(Object)下，但找不到给我一个决定性答案的东西。
behavior：下面的代码 是否介绍了未定义的？标准的哪些部分澄清了这种交互？
struct A
{
atomic<bool> x{true};
thread t;
// Capturing 'this' is par
浏览 1提问于2016-11-03得票数 4
回答已采纳
我们不能使抽象类的对象，那么为什么需要一个析构的抽象类？对于抽象类来说，是否有必要使析构成为纯虚拟的？
class Base()
{
public:
virtual ~Base() = 0;
};
Base :: ~Base()
{
}
class Derived :: public Base
{
public:
~Derived();
};
浏览 0提问于2018-01-24得票数 1
回答已采纳
1回答
我正在构建一个循环链表，我想知道do_remove方法是否定义得很好。当我运行这个程序时，它向我展示了它是，然而，我仍然有点困惑，为什么我不需要一个虚拟的destrutor在这种情况下。
是否只有当我想通过派生类的基本指针销毁派生类时才需要虚拟析构函数？
这是否意味着，通过将基类降为派生类，然后调用派生类析构函数，它将始终调用基类析构函数？
do_remove方法中是否存在可能的漏洞？
PS:我需要两个步骤来创建和销毁对象--分配/调用构造函数/调用析构函数/去分配；这就是我目前使用::operator new的原因。
下面是我正在编写的代码的一个独立的示例：
#include <ios
浏览 1提问于2017-12-17得票数 0
回答已采纳
我正在尝试确定以下代码是否安全，或者它是否是UB，并且只在本例中运行良好(运行它为)：
#include <iostream>
#include <mutex>
struct Foo
{
std::mutex mutex;
~Foo()
{
std::lock_guard<std::mutex> lock(mutex);
}
};
int main()
{
{
Foo foo;
}
std::cout << "everything seems to work fine...?" &
浏览 1提问于2019-05-01得票数 6
回答已采纳
我有一个带有虚拟析构函数的基类A。A的后代B和C使用默认析构函数。通过指向C的指针删除A的对象安全吗？
更具体地说，请考虑以下示例代码：
class A {
public:
A(){};
virtual ~A() {/* code here */};
};
class B: public A {
B() {/* code....*/};
/* NO DESTRUCTOR SPECIFIED */
};
class C: public B {/*same as above, no destructor */};
class D: p
浏览 0提问于2018-01-20得票数 9
回答已采纳
1回答
为什么调用派生类的析构函数？
、、、、
我有一个简单的程序：
struct B
{
virtual ~B() {}
};
struct D : public B
{
~D() {}
};
所以，当我打电话
B* b = new D;
b->~B();
为什么调用派生类的析构函数？它是虚拟的，但是我们按名称调用析构函数，或者是否有一个对所有类都相同的析构函数的隐藏名称？
浏览 1提问于2015-07-01得票数 5
回答已采纳
1回答
我有一个抽象的类，它定义了具体类的常见行为。因此，将没有需要清理的内存，因为无法实例化类。但是，我知道，如果派生析构函数的静态类型是基类，则需要一个虚拟析构函数。
这是否意味着我应该始终为抽象类声明一个虚拟析构函数，而只是将实现保留为空？
浏览 0提问于2013-09-29得票数 0
回答已采纳
是否有一种方法可以使类的析构函数不调用某个类成员的析构函数和/或不调用其基类的析构函数？
如果这是不可能的，是否手动创建具有新位置和析构(/不-析构)的类成员是可能的解决办法？谢谢!
编辑:我需要这样做的原因:C类拥有对象M有一个非平凡的析构函数。C是M的朋友，以一种不需要调用M的析构函数的方式来管理M。调用它是可以的，但它意味着性能开销。(在这种情况下是个问题。)我在考虑从M生成一个派生类，它有一个不做任何事情的析构函数，但是它仍然会调用基的析构函数。
浏览 0提问于2017-05-30得票数 0
回答已采纳
我读到析构函数不能共享，这是真的吗？
我有一个带有几个子类的基类，这些子类的析构函数不会改变。这将导致一些重复的代码。
可以共享析构函数吗？如果没有，我该如何避免这些析构函数中的重复代码呢？
Class A{
public:
~A() {
//do something
}
};
class B: public A{
};
class C: public A{
};
class D: public A{
};
现在，我希望B、C和D具有与A相同的析构函数。
浏览 5提问于2013-05-08得票数 0
回答已采纳
我相信我找到了一个针对现有代码的bug，但它实际上是有效的。你能帮我核实一下我的理解是否正确吗？
它是关于一个父类，其中包含一个指向其子类的数据对象的对象指针。在其(父)析构函数中，它使用对象指针进行函数访问。我相信，当父析构函数被调用时，子元素已经被解构，因此父指针指向的对象不再有效。我举一个例子如下：
我对下面代码的问题是，如果父析构函数是正确的？
#include <iostream>
#include <string>
using namespace std;
class object {
public:
object(string na):name
浏览 2提问于2015-10-19得票数 0
回答已采纳
7回答
隐式析构函数不能处理哪些潜在的内存泄漏？我知道如果你有任何东西存储在堆上，它不会处理它，如果你有一个到文件或数据库的连接，那就需要手动处理。还有别的事吗？比方说，像向量这样的非基数据类型呢？
另外，在显式析构函数中，是否需要销毁原本会被隐式销毁的非堆变量，或者自动处理这些变量？
谢谢
浏览 2提问于2010-05-14得票数 3
回答已采纳
假设我有：
class Base {
public:
virtual ~Base() = 0;
}
class Derived: public Base {
public:
~Derived();
}
在我的代码中，我需要通过一个Derived指针删除Base类，如下所示：
delete[] pt_base;
但是，在已实现的析构函数中，我实际上没有任何要销毁的东西。但我仍然需要他们通过基类删除？
在不浪费大量代码和空析构函数的情况下，实现我想要的东西的最佳方法是什么？
浏览 11提问于2014-12-01得票数 0
回答已采纳
3回答
如果我有一个基类和一个派生类，并且我删除了父虚类中的析构函数，但实例化了一个子类类型的对象，当它被销毁时，它会调用父析构函数吗(因为是虚的)？如果我还在派生类中声明了析构函数，它是否会同时调用析构函数(基类和派生类)。提前感谢:-)。
我问题的第二部分是关于第一部分。为什么基类析构函数需要声明为virtual。不要让构造器在hiearchy中循环。它们的名字并不相同，所以有什么必要这样做呢？它不应该对析构函数起同样的作用，或者默认情况下只调用一个吗？同样，通过后期绑定，它是否能够检测到所有的类和对象是由什么组成的？
编辑:我的问题不仅仅是关于虚拟析构函数，而且为什么需要声明为虚拟的，因为它们都
浏览 2提问于2011-04-26得票数 3
回答已采纳
当在类中使用STL列表作为属性时，我们是否需要在构造函数中初始化链接列表，以及如何使用析构函数将内存释放回系统？我知道STL列表有一个自动删除链接列表的下降器。然而，我的老师要求我们在课堂上加入析构函数。因此，我正在研究如何处理list属性。
因此，我有一个列类，它包含char的链接列表作为它的属性。到目前为止，我已经：
class Column
{
private:
list<char> chars;
list<char>::const_iterator itr;
public:
Column()
{
}
~
浏览 0提问于2014-04-28得票数 0
回答已采纳
2回答
结构对象析构函数
、、、、
如果我要像这样定义一个结构：
struct info{
std::string name;
}
并通过以下方法在堆上创建上述结构的新实例：
info* i = new info();
在调用info上的delete时，是否自动调用字符串的析构函数，从而释放由name对象分配的任何内部内存？这种行为在C++中应该避免吗？
谢谢
浏览 1提问于2015-11-09得票数 1
回答已采纳
4回答
Base是基类，Derived是派生类。
Base* p = new Derived;
delete p;
让我们假设基析构函数不是虚拟的。这是否会导致内存泄漏，如果是，为什么？解决这个问题的办法是什么？
浏览 0提问于2015-04-04得票数 0
1回答
使类抽象是通过使其成员函数之一成为纯虚拟函数。
使类抽象要求类的子类实现基纯虚函数。
我们甚至可以将基类析构函数变为纯类，这足以成为抽象类。
问题是：
为什么我们没有义务在派生类中实现纯虚拟基的析构函数？
这是否意味着只要C++在默认情况下向我们添加四个成员函数:构造函数、复制构造函数、赋值函数和析构函数，我们就不需要在派生类中实现它？
例：
#include <iostream>
using namespace std;
class Base
{
public:
Base(){cout << "Base Ctor
浏览 0提问于2016-11-14得票数 1
回答已采纳
4回答
继承和编译器生成的函数
、、、
当我有继承时，我通常得到的编译器生成的函数(构造函数、析构函数、赋值操作符和复制构造函数)是否仍然为我的类生成？
假设我有这样的继承:一个基类，一个继承A ( public )的B和C，它继承了B。我的A类没有内存分配，或者任何需要由我实现析构函数的东西，而且我没有在那里实现析构函数，当我编译我的程序时，它还会创建空的A::~A(){}吗？
B和C也一样。谢谢!
浏览 4提问于2015-06-25得票数 1
回答已采纳
#include <iostream>
#include <vector>
using namespace std;
#define l(x) cout << (#x) << " : " << x << endl;
#define forf(x, fromY, Step, toZ) for(double x = fromY; x <= toZ; x+=Step)
class Particle {
public:
Particle() {
totalYield = winRat
浏览 1提问于2018-09-03得票数 0
回答已采纳
是否有任何方法从子类中从调用父类的默认析构函数，从而使父类的任何成员都保持子类的特定实例的活动？
在本例中，没有为父类定义析构函数。如果父类有许多成员变量，这可能会被使用。然后，这个方法将比对每个成员变量使用unset()更有用。
有什么解决办法吗？
浏览 7提问于2013-09-10得票数 0
我在理解虚函数时遇到了问题。当我重载一个虚函数时，新的派生函数是否只被调用？或者同时使用派生函数和基函数？因为我注意到当调用虚拟析构函数时，基析构函数和派生类析构函数也会被调用。
浏览 0提问于2013-02-18得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
