析构函数是程序的终结点吗？
析构函数是程序的终结点之一，它在对象生命周期结束时被调用，用于释放对象所占用的资源。但是，程序的终结点不仅仅是析构函数，还包括其他一些操作，如关闭文件、释放内存等。
析构函数是在对象销毁时自动调用的特殊成员函数，用于执行清理工作。它的作用是释放对象所分配的资源，如关闭文件、释放内存、断开网络连接等。析构函数的命名规则为在类名前加上波浪线（~），例如~ClassName。
析构函数的分类有两种：显式析构函数和隐式析构函数。显式析构函数由程序员自行定义，用于释放对象的资源；而隐式析构函数由编译器自动生成，用于释放对象的非动态分配资源。
析构函数的优势在于可以确保对象在销毁时资源得到正确释放，避免内存泄漏和资源浪费。它在以下场景中特别有用：
- 动态分配内存：当对象中包含动态分配的内存（如new操作符分配的内存）时，析构函数可以在对象销毁时释放这些内存，避免内存泄漏。
- 文件操作：当对象涉及文件操作时，析构函数可以在对象销毁时关闭文件，确保文件资源得到正确释放。
- 网络连接：当对象涉及网络连接时，析构函数可以在对象销毁时断开网络连接，避免资源占用和连接泄漏。
对于腾讯云相关产品和产品介绍链接地址，由于要求不能提及具体品牌商，无法给出具体链接。但腾讯云作为一家知名的云计算服务提供商，提供了丰富的云计算产品和解决方案，可以根据具体需求选择适合的产品。
相关·内容
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
回答已采纳
2回答
下面的代码会产生UB吗？
#include <iostream>
#include <climits>
struct A
{
~A(){ std::cout << "Non-trivial" << std::endl; }
};
int main()
{
A a;
new (&a) A;
} //UB?
标准N3797::3.8/8 [basic.life]
如果程序以静态(3.7.1)、线程(3.7.2)或自动(3.7.3)存储持续时间结束T类型对象的生存期，如果T具有一个非平凡的析
浏览 4提问于2014-10-22得票数 1
回答已采纳
1回答
这个问题实际上是关于SWIG的，而不是缺少分号的基本C++。
在类中(在头文件中)有以下方法：
class BarClass
{
// ... more code goes here
unsigned int foo(unsigned int val) throw(std::invalid_argument) override;
// ... more code goes here
};
我在表单中有一个SWIG接口声明：
%include "stdint.i"
%include "std_except.i"
%include "
浏览 1提问于2018-03-14得票数 2
回答已采纳
3回答
我在下面的程序中调用析构函数中的exit()。当我在main()内部创建一个类型为sample的对象时，只调用一次析构函数，程序就会正常退出。但是当我创建一个类型为sample的全局对象时，"Destructing..“无限地打印出来。有谁能解释一下是怎么做到的吗？
#include "iostream"
#include "conio.h"
using namespace std;
class sample
{
public:
~sample() {
cout <<"
浏览 2提问于2012-04-30得票数 4
回答已采纳
在我对C++内存模型的理解中，只有当对象数组由new[]创建并被'delete []删除时，才使用标量构造函数/析构函数，编译器生成一个内部for循环来迭代每个元素位置。
int main()
{
B obj;
B* pb = new B;//no scalar constructor
delete pb;//scalar deleting destructor
}
但我发现，当我使用“new”delete来操作一个元素时，没有使用'[]'，VC仍然会生成用于调试版本的“标量删除下降器”的代码。
所以我的问题是：
标量构造函数/析构函数不必成
浏览 2提问于2016-09-02得票数 1
回答已采纳
3回答
如果程序的每个实例都使用new动态分配了内存，那么在析构函数中释放它们将是一个好主意。
#include <iostream>
using namespace std;
class c{
public:
c(){cout << "Created Object";}
~c(){
delete this;
cout << "Deleted object";
}
};
int main(){
c* ptr = new (not
浏览 0提问于2020-06-20得票数 0
在PHP5中，是否保证为每个对象实例调用__destruct()方法？程序中的异常能阻止这种情况的发生吗？
浏览 3提问于2008-09-30得票数 43
回答已采纳
在Bjarne第17.6节(生成默认操作)的“C++编程语言(第4版)”中，它提到了以下内容：
如果程序员为类声明副本操作、移动操作或析构函数，则不会为该类生成复制操作、移动操作或析构函数。
因此，我不明白为什么在这个程序中调用SubObj析构函数：
#include <iostream>
using namespace std;
class SubObj {
public:
~SubObj() {
cout << "SubObj Destructor called" << endl;
浏览 1提问于2019-04-23得票数 5
回答已采纳
我有下面的代码只是为了测试，模板函数是两次使用，第一次它是好的。在第二种情况下，我创建一个指针，并将指针作为引用传递到模板函数中。我预期行"obj.~T()“编译时失败。但实际上，代码编译并运行良好。当我通过函数进行调试时，程序简单地跳过obj.~T()；我使用的是VC10。
我的问题是：
这是一种预期的行为吗？如果它是基于c++标准中的哪个部分的？
对于这种行为有什么正反两面吗？在我的例子中，这是好的，因为没有编译错误，也没有运行时错误。但可能有一些情况，我不知道，但确实破坏了代码。
谢谢
template<typename T>
void ptrDest
浏览 3提问于2014-03-13得票数 5
回答已采纳
3回答
我在C++常见问题解答中看不到答案：
我如何定义一个基类，这样继承它的每个类都需要定义一个析构函数？
我试着运行这个程序
struct VDtor { virtual ~VDtor()=0; };
struct Test:VDtor { virtual ~Test(){} };
int main() { delete new Test; return 0; }
出现错误的
In function `Test::~Test()':
t.cpp:(.gnu.linkonce.t._ZN4TestD0Ev+0x1e): undefined reference to `VDtor::~VD
浏览 1提问于2010-09-13得票数 16
回答已采纳
例如，如果我创建一个类对象的“新”实例，然后“删除”该实例，是否会清除(如释放)该实例使用的所有内存？如果实例创建了其他对象的“新”实例怎么办？他们也会受到影响吗？
“delete”到底是如何工作的呢？关于如何删除有什么安全的规则/提示吗？如果我真的想保留某些内容，而删除该实例中的其他所有内容，该怎么办？
编辑:关于“智能指针”，如果我需要在特定时刻删除它，我还可以这样做吗？如果是这样，那么这和“新”有什么区别呢？(除非智能指针在应用程序意外关闭时删除？)
浏览 1提问于2013-04-11得票数 1
让我们假设有Bar对象，它使用Foo对象。所有权是独占的，因此Bar在其构造函数中将Foo作为std::unique_ptr获取。我想用Google测试Bar，所以我编写了以下代码：
using namespace testing;
class Foo
{
public:
virtual int F() = 0;
};
class Bar
{
public:
Bar(std::unique_ptr<Foo>&& foo) : m_foo(std::move(foo))
{
}
int B()
{
浏览 1提问于2018-05-23得票数 8
回答已采纳
我有一个非常简单的程序。不知道为什么static_assert(is_destructible<_Value_type>::value会失败。
<source>:16:12: required from here
/opt/compiler-explorer/gcc-8.1.0/include/c++/8.1.0/bits/stl_construct.h:133:21: error: static assertion failed: value type is destructible
static_assert(is_destructible<
浏览 6提问于2021-06-13得票数 1
回答已采纳
3回答
我正在阅读Stroustrup的C++编程书中的一段代码。
class Vector_container : public Container {
Vector v;
public:
// Vector_container implements Container
Vector_container(int s) : v(s) { } // Vector of s elements
~Vector_container() {}
double& operator[](int i) { return v[i]; }
int size(
浏览 0提问于2019-07-10得票数 2
回答已采纳
3回答
我想知道通过析构函数方法可以删除一个对象吗？
构造函数和析构函数：
class cal
{
public:
cal()
{
days = 0;
day = 1;
month = 1;
year = 1300;
leap = true;
};
~cal()
{
delete this;
}
}*calendar = new cal;
如何通过类删除此指
浏览 5提问于2012-07-12得票数 7
回答已采纳
{使用2010，Win7 }
class Base
{
public:
Base() : terminateCondition(false)
{
//spawn new thread and set entry point to newThreadFunc()
}
virtual ~Base() // edited to say it's virtual.
{
terminateCondition=true;
//wait f
浏览 3提问于2012-10-03得票数 1
回答已采纳
1回答
如果我有这样的东西
class Foo { ... }
class UsesFoo {
private:
Foo foo;
public:
UsesFoo() : foo(1, 2, 3) { }
}
然后，正如我所理解的那样，当我构造一个UsesFoo (无论是UsesFoo *myMan = new UsesFoo();还是UsesFoo myMan;)时，它会创建一个Foo对象，就像调用Foo(1, 2, 3)一样。当UsesFoo被销毁时(无论是被delete myMan;破坏还是超出范围)，内部的Foo也将被销毁。
如果我提供了下面的析构函数，Foo还会被销毁吗？
浏览 5提问于2014-04-04得票数 2
回答已采纳
当一个类的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
回答已采纳
我读到析构函数不能共享，这是真的吗？
我有一个带有几个子类的基类，这些子类的析构函数不会改变。这将导致一些重复的代码。
可以共享析构函数吗？如果没有，我该如何避免这些析构函数中的重复代码呢？
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
回答已采纳
来自维基百科。
void WriteToFile(const std::string& message) {
// |mutex| is to protect access to |file| (which is shared across threads).
static std::mutex mutex;
// Lock |mutex| before accessing |file|.
std::lock_guard<std::mutex> lock(mutex);
// Try to open file.
std::ofstream fil
浏览 3提问于2020-07-07得票数 2
回答已采纳
5回答
我知道如果不使用delete/free释放已分配的内存，最终会导致内存泄漏。我的问题是:如果我的程序被终止，即使我没有释放内存，操作系统也会为我释放内存吗？
浏览 0提问于2013-02-06得票数 2
回答已采纳
我编写了我的第一个MVVM应用程序。当我关闭应用程序时，我经常会得到ObjectDisposedException造成的崩溃原因。在应用程序窗口消失后，当应用程序死亡时，崩溃就会出现。
获得堆栈跟踪是很困难的()，但最终我做到了，并发现我的堆栈跟踪完全包含在C#库中(kernel32!BaseThreadStart、mscorwks、线程、mscorwks、WKS等等)。
此外，这种崩溃是不一致的。在我最后一次结账和重建之后，一切都停止了.一时半刻。然后它又回来了。一旦它开始发生，它就一直在发生，即使我“清洁”并重建了，也是如此。但结帐有时会让它停一段时间。
我认为正在发生的事情：
我认为Ga
浏览 3提问于2011-10-19得票数 2
回答已采纳
2回答
我正在阅读教科书，它似乎表明，当您有一个成员变量，即指针，您必须将代码在析构函数中，以删除内存。
这有点不清楚，但看起来代码必须如下所示：
private:
double *aPtr;
public:
~NumberArray(){ delete [ ] aPtr;}
但是，这不是因为析构函数已经在删除数组中的第一个元素而导致了2个delete命令吗？另外，析构函数是否会自动完成其默认工作，即使您的程序中有1行或更多行用于默认析构函数？程序是先执行您的代码，还是执行代码--析构函数的“自动”部分？
出于某种原因，我认为delete命令只是用于动态分配内存。我想我错了？
浏览 5提问于2017-11-22得票数 0
回答已采纳
5回答
我目前正在编写一个具有以下多态层次结构的程序: Base: Multinumber。派生:对，复数，有理。Multinumber是一个虚拟类，从不实例化。
在我的程序过程中，我经常动态地管理基类，所以我需要一个析构函数。我的问题是:如何使析构函数成为虚拟的？在我的Multinumber.h文件中，我现在有：
virtual ~Multinumber();
在我的Multinumber.cpp中：
Multinumber::~Multinumber()
{
}
在我所有的派生类中，我都有：
Rational::~Rational()
{
}
我的任何派生.h文件中都没有任何内容。不幸的是，这
浏览 2提问于2010-12-04得票数 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
回答已采纳
我为一个小项目创建了一个简单的类，并决定只为一个快速驱动程序添加一个析构函数，而不是使用IDisposable，每当有一个带有访问修饰符的析构函数时，我就会遇到一个编译器错误。
public class MyClass
{
public ~MyClass()
{
// clean resources
}
}
我尝试过公共的、私人的、受保护的和内部的。它在没有访问修饰符的情况下工作得很好。由于认为~析构函数本质上是一个受保护的终结函数的语法糖，所以我觉得奇怪的是，至少不能在析构函数上使用保护。这篇文章确实说：“不能调用析构函数，它们是自动调用的。”这种行为
浏览 12提问于2010-03-05得票数 5
回答已采纳
3回答
我的问题很简单，但我在任何地方都找不到问题。
如果我有一个这样的类
class A {
vector<int> data;
}
当A的实例被销毁时，data也会被销毁吗?或者我应该为A编写一个析构函数来调用data的析构函数吗?基本上我担心当A的实例被销毁时，向量的动态内存是否不会被释放。我怀疑答案是data被正确地释放了，但我不想以一种艰难的方式发现我错了。
此外，如果A是一个结构，当data的本地实例超出作用域时，会调用A的析构函数吗？
浏览 3提问于2012-02-29得票数 15
回答已采纳
8回答
几个小时前，我正在摆弄一个内存泄漏问题，结果发现我真的搞错了一些关于虚拟析构函数的基本东西！让我来解释一下我的类设计。
class Base
{
virtual push_elements()
{}
};
class Derived:public Base
{
vector<int> x;
public:
void push_elements(){
for(int i=0;i <5;i++)
x.push_back(i);
}
};
void main()
{
Base* b = new Derived();
浏览 5提问于2010-04-27得票数 6
回答已采纳
1回答
我正在阅读教科书"C++ Primer Plus，Prata“
第10章中有一段引起了我的注意，使我感到困惑。
Ch.10对象和类：
上面写着
如果不提供one，编译器将隐式声明默认的构造函数，
我觉得应该是
如果不提供析构函数，编译器将隐式声明默认的析构函数，
这段是对的吗？
我该如何正确解释呢？
谢谢
浏览 4提问于2016-02-16得票数 1
回答已采纳
2回答
C++内置析构函数编译警告
、、、、
我在代码中使用了一个内置析构函数，类似于这段被剥离的代码：
#include <new>
#include <stdlib.h>
struct Node {
};
int main(int, char**) {
Node* a = reinterpret_cast<Node*>(malloc(sizeof(Node)));
new(a) Node;
Node* b = a;
b->~Node();
free(a);
}
不幸的是，这给了我在Visual 2015中的一个警告，无论是在调试还是发布中：
浏览 2提问于2017-01-03得票数 7
回答已采纳
1回答
class D
{
public:
~D() { throw std::exception(); }
};
int main()
{
try
{
try
{
D d;
}
catch (...)
{
cout << "1";
}
}
catch (std::exception& e)
{
cout << "2";
}
浏览 0提问于2019-08-13得票数 1
1回答
隐式声明析构函数
、、、
如果我是正确的，默认析构函数总是隐式声明的，除非用户声明它。根据
通过指向基的指针删除对象会调用未定义的行为，除非基类中的析构函数是虚拟的。
现在，考虑下面的示例：
struct B {};
struct D : B {};
隐式声明的析构函数B::~B()是虚拟的吗？如果没有，那么在使用继承时，应该始终声明一个虚拟析构函数吗？
浏览 2提问于2021-09-28得票数 1
回答已采纳
我相信我找到了一个针对现有代码的bug，但它实际上是有效的。你能帮我核实一下我的理解是否正确吗？
它是关于一个父类，其中包含一个指向其子类的数据对象的对象指针。在其(父)析构函数中，它使用对象指针进行函数访问。我相信，当父析构函数被调用时，子元素已经被解构，因此父指针指向的对象不再有效。我举一个例子如下：
我对下面代码的问题是，如果父析构函数是正确的？
#include <iostream>
#include <string>
using namespace std;
class object {
public:
object(string na):name
浏览 2提问于2015-10-19得票数 0
回答已采纳
在析构函数的最后一行中，我有一个诊断类型消息，它采用printf-like表单：
"object destroyed at %p", this
不过，我担心在这种情况下this的定义会有多好。
我应该有这样的预约吗？这种行为是明确的吗？
浏览 11提问于2014-09-03得票数 8
回答已采纳
众所周知，我们可以使用纯虚拟析构函数，如下所示：
struct A {
virtual ~A() = 0;
};
A::~A() {}
struct B : A {};
因为标准在10.4 [class.abstract] p2里说
只有在调用时才需要定义纯虚函数.(12.4 class.dtor)
后来在12.4 [class.dtor] p9里
析构函数可以声明为虚拟(10.3)或纯虚拟(10.4)；如果在程序中创建了该类的任何对象或任何派生类，则应定义析构函数。
这意味着上面的代码是完全有效的-- A::~A可能是纯虚拟的，它是定义的，B::~B隐式地调用A::
浏览 6提问于2014-06-15得票数 1
出于好奇，我试着做一些类似下面的例子，看看编译器是否给了我一个警告，而不是调用一个无穷无尽的循环，最终导致堆栈溢出。我想也许有一种不同的行为，而不仅仅是调用普通的函数或方法。但事实并非如此。有什么特别的解释吗?或者它只是作为普通的函数调用来处理，因为我是使用this操作符显式地调用基类析构函数？
示例：
class A {
virtual ~A();
};
class B : A {
virtual ~B() { this->~A(); }
};
浏览 5提问于2017-02-22得票数 0
回答已采纳
下面是我的程序中的new/delete操作符的模式。Valgrind说，记忆“肯定是丢失了”。我不太清楚泄漏在哪里。我的new/delete操作符的用法有问题吗？
class Generic
{
GenericInterface *gInterface; //GenericInterface is abstract class
public:
Generic ()
{
gInterface = NULL;
}
~Generic ()
浏览 2提问于2011-01-29得票数 1
回答已采纳
2回答
析构与巨蟒
、、、
我在c++上有一些c++课程。我使用boost::python将其导出到python中。但是虚拟破坏者呢？任何基类都应该有虚拟析构函数，以避免错误的内存释放，对吗？我忘记了这一点，写了Base而没有析构函数。一切正常，但有大量的内存泄漏。
现在我补充说：
class Base
{
public:
virtual ~Base();
// Other members...
};
在python中导入我的模块之后，我得到了一个错误：
ImportError: Base.so:未定义符号：_ZTI6Base
我做错什么了？而且，据我所知，错误是由于py-模块缺少析构函
浏览 0提问于2011-04-11得票数 1
回答已采纳
2回答
考虑以下代码(最低版本)：
#include <iostream>
struct Base
{
virtual ~Base() {}
virtual void test() const { std::cout << "base"; }
};
struct Derived : public Base
{
void test() const { std::cout << "derived"; }
};
struct Composite
{
const Derived &ref;
浏览 0提问于2013-05-02得票数 2
回答已采纳
下面的代码是用Visual 2019编译的，而不是用gcc和clang编译的。定义变量b会导致后两个编译器出现错误。
#include <iostream>
class base
{
public:
constexpr base(int i) : m_i(i) {}
constexpr int i() const { return m_i; }
protected:
~base() = default; // Forbid polymorphic deletion
private:
const int m_i;
};
class derive
浏览 2提问于2021-11-09得票数 4
回答已采纳
2回答
我写了下面的程序
#include <iostream>
#include <stdexcept>
class Myclass
{
public:
~Myclass()
{
//throw std::runtime_error("second (in destructor)");
throw 1;
}
};
void fun()
{
Myclass obj;
}
int main()
{
try
{
fun();
}
浏览 1提问于2017-04-18得票数 7
回答已采纳
我寻找这个问题的答案，却找不到答案。考虑以下代码：
struct Foo
{
int *bar;
Foo(int barValue) : bar(new int(barValue)) {}
~Foo() { do_this(); }
void do_this() { delete bar; bar = nullptr; }
};
int main()
{
const Foo foo(7);
}
不能在do_this()对象上调用const，所以我不能执行类似foo.do_this()的操作。在某些情况下，在析构函数之外调用do_this()也是有意义的
浏览 0提问于2018-03-06得票数 16
回答已采纳
有人能解释一下这个代码摘录是做什么的吗？我的第一个猜测是d()调用了自身的析构函数，但后来我想知道为什么不能自己调用T的析构函数。
class T
{
void d()
{
this -> ~T();
}
}
提前谢谢你。
浏览 1提问于2012-02-14得票数 3
回答已采纳
2回答
如果一个向量被放入栈中，它将在其自动变量作用域的末尾被自动析构。
如果我把一个向量放在一个类中呢？
class A
{
vector<B> bs; // B is POD struct.
};
需要手动清理吗？如果是这样，我应该怎么做？
浏览 4提问于2011-03-26得票数 1
回答已采纳
我有一个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
回答已采纳
我有这样的情况：
#include <iostream>
struct B { virtual void f() { std::cout << "base"; } };
struct A {
~A() {
b->f();
}
B *b;
};
struct Bd : B {
Bd():a{this}{ }
~Bd() { }
virtual void f() { std::cout << "derived"; }
A a;
};
int main() {
Bd
浏览 3提问于2016-04-25得票数 2
回答已采纳
假设我们有三门课:父母，孩子和其他。
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
回答已采纳
1回答
我是C++的新手，我一直在学习如何执行程序。我正在编写以下代码：
#include <iostream>
#include <string>
using namespace std;
void sayHello() {
cout << "Hello world!" << endl;
}
void greet(string name) {
cout << "Hello " << name << ", how are you?" <<
浏览 3提问于2016-11-16得票数 0
回答已采纳
4回答
可能的重复：
编译器不强制Child class在其Base具有纯virtual析构函数时实现析构函数。
struct Base
{
virtual void foo () = 0;
virtual ~Base() = 0;
};
Base::~Base() {} // necessary
struct Child : Base
{
void foo() {}
//ok! no destructor needed to create objects of 'Child'
};
有趣的是，编译器宁愿强迫Base定义析构函数体。。(供参考)
那么，在类
浏览 4提问于2011-07-28得票数 20
回答已采纳
3回答
假设我有两个A类和B类，定义如下：
class A {
public:
virtual void pureVirtual() = 0;
}
class B : public A {
public:
virtual void pureVirtual();
}
当然，我还有其他方法，但这只是举个例子而已。现在，在我的cpp代码中，我有这样的var：
B *myB = new B;
A *myA = myB;
通过调用myA上的delete (如：delete myA; )可以删除delete myA;对象吗？我需要做些特别的事情才能做到吗？OOP思想和编程风格是可以接受的，还是
浏览 1提问于2011-12-01得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
