在dlclose()之前析构的静态对象
在dlclose()之前析构的静态对象是指在程序运行期间通过动态链接库（shared library）加载的代码中，如果存在静态对象（static object），并且这些对象在动态链接库被关闭（使用dlclose()函数）之前就被析构（destroy），那么这些对象的析构函数将会被调用。
静态对象是在程序运行期间创建并且在整个程序生命周期中存在的对象。静态对象的构造发生在程序启动时，而析构发生在程序结束时。然而，在使用动态链接库时，由于动态链接库的加载和卸载是在程序运行时动态发生的，所以静态对象的析构可能会在动态链接库被关闭之前发生。
静态对象的析构函数通常用于释放对象所占用的资源、清理临时文件、关闭文件描述符等操作。如果静态对象的析构函数没有正确地执行，可能会导致资源泄漏或其他未定义的行为。
要正确处理在dlclose()之前析构的静态对象，可以考虑以下几点：
- 确保静态对象的析构函数正确地释放对象所占用的资源，并且不依赖于其他已被关闭的资源。
- 在动态链接库被关闭之前，尽量避免使用静态对象。
- 如果必须在动态链接库中使用静态对象，在程序设计中应该考虑到这一点，并确保在关闭动态链接库之前，程序的其他部分不会依赖于这些对象。
- 如果使用C++语言编写代码，可以使用RAII（资源获取即初始化）技术来管理资源的生命周期，以确保资源在不再需要时得到正确地释放。
对于腾讯云相关产品，针对静态对象析构的问题，没有直接相关的产品或服务。然而，腾讯云提供了一系列云计算产品和解决方案，以满足用户在各个领域的需求。可以通过腾讯云官方网站获取更多信息：https://cloud.tencent.com/
相关·内容
1回答
在主程序中，I dlopen和dlclose (分别为LoadLibrary和FreeLibrary )是一个共享库。共享库包含一个静态变量，该变量在dlopen上实例化，在dlclose上销毁。这种行为在MSVC 2008和2013年、GCC 3.4.6和Sunstudio 12.1上都是一致的。然而，GCC 4.9.1和GCC 5.2.1的破坏者不再在dlclose上被调用。相反，它是在程序退出之前调用的。
静态变量类的特殊性在于，在构造函数中，调用模板函数get (具有全局范围)返回本地静态变量。
我能够通过链接到共享库的以下一个cpp文件来再现这种行为：
#include <io
浏览 4提问于2016-07-21得票数 12
回答已采纳
3回答
例如，此代码段错误(请参阅main.cpp中的注释)。
hello.h
struct A { virtual ~A() {} };
hello.cpp
#include "hello.h"
extern "C" {
void hello(A*& a) {
a = new A;
}
}
main.cpp:
#include <cassert>
#include <dlfcn.h>
#include "hello.h"
int main() {
void* handle
浏览 6提问于2014-08-16得票数 4
回答已采纳
1回答
plugin1.cpp：
#include <iostream>
static class TestStatic {
public:
TestStatic() {
std::cout << "TestStatic create" << std::endl;
}
~TestStatic() {
std::cout << "TestStatic destroy" << std::endl;
}
} test_static;
host.cpp
#include <d
浏览 0提问于2010-09-28得票数 23
回答已采纳
我希望有自动调用来初始化和重新初始化我的共享库。
在我的共享库中，我需要一些C++对象的静态初始化，其中包括使用第三方代码(例如UnitTest++)。在执行init函数时，需要保证完成(所有链接转换单元的) C++对象的所有静态初始化(对于deinit，反之亦然)；因此，与C++程序中执行main()的条件相同。
我看到了许多关于linux共享库init/deinit的信息，例如：
但所提供的解决方案不能满足我的需要。在这两种方法(__attribute__((constructor))甚至-Wl,-init,<function name>)中，init
浏览 5提问于2013-10-24得票数 6
4回答
析构函数
、
对于这样一个简单的类：
class X {
public:
//...
private:
int *ptr;
};
X::~X() {
delete ptr;
}
我编写了一个析构函数来释放ptr指出的内存。现在，我想知道，如果我的析构函数保持这样，什么时候ptr真的被摧毁了？
谢谢
浏览 3提问于2013-11-23得票数 0
回答已采纳
在Android上使用动态加载API (<dlfcn.h>：dlopen()、dlclose()等)时，我遇到了一些问题。我使用NDK独立工具链(版本8)编译应用程序和库。Android版本是2.2.1Froyo。
以下是简单共享库的源代码。
#include <stdio.h>
int iii = 0;
int *ptr = NULL;
__attribute__((constructor))
static void init()
{
iii = 653;
}
__attribute__((destructor))
static void cleanup
浏览 8提问于2011-06-23得票数 9
1回答
#include <thread>
using namespace std;
struct A
{
A() {}
~A() {}
};
A g_a;
int main()
{
thread([]()
{
thread_local A tl_a;
exit(0);
}).detach();
}
在g_a tl_a 被销毁后，C++标准是否保证将被销毁？
浏览 1提问于2017-03-29得票数 1
回答已采纳
2回答
我想添加钩子函数，在卸载共享库时调用这个函数。图书馆是串通的。做这种事有可能吗？也许gcc有国旗吗？
我看到了在运行时加载库的类似解决方案，但它不符合我的期望。
浏览 2提问于2018-09-28得票数 4
3回答
我在一个类中声明了一个结构的向量。我的问题是，我是必须显式地释放由类析构函数中的向量分配的内存，还是在销毁实例时自动释放。同样，我是否必须在类析构函数中包含代码来释放向量的内存。
浏览 3提问于2013-06-24得票数 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
回答已采纳
我正在尝试实现单状态类，它管理一些std：：线程。线程正在运行，直到标志变为等于false为止。标志更改为假线程后停止。但是看起来我必须显式地调用回退方法。在析构函数中调用它会给我带来运行时错误(在GCC 4.8上测试ARM，GCC 4.9测试x86_64和MSVC 2017)。我说得对吗，这种行为是由于
“类的静态成员不与类的对象相关联:它们是独立的对象，具有静态存储持续时间或在命名空间范围中定义的常规函数，在程序中只定义一次。”
所以析构电话被省略了吗？
代码示例：
#include <iostream>
#include <chrono>
#include
浏览 1提问于2018-05-14得票数 0
回答已采纳
1回答
cppreference提到了：
函数可以与销毁具有静态存储持续时间的对象同时调用，并保持这样的保证:如果A的注册被排序--在B注册之前，对B的调用被排序--在调用A之前--同样适用于静态对象构造函数和atexit调用之间的排序
我理解这段话意味着，如果在静态初始化期间调用std::atexit，则在销毁静态对象之前调用注册函数，而静态对象上次初始化是在调用注册函数的std::atexit之前。我还将“可以同时调用”解释为“可以在静态对象破坏之间进行调用”，而不是对单词的多线程解释。
我想知道的是，在初始化开始或完成时，对象是否被视为初始化(在此顺序的上下文中)。我写了一个简短的测试来
浏览 2提问于2018-05-16得票数 7
回答已采纳
1回答
我还没有找到这个问题的答案，但我几乎百分之百肯定有什么地方可以找到。
我有一个普通的C++类，我使用的是第三方日志系统。不幸的是，我有两个要求和三个事实，我无法匹配：
要求：
destructorHandle中的日志程序终止(无崩溃)
事实：
pthread_mutex_lock.I 第三方日志系统在程序终止时崩溃，因为它不想改变这个日志系统----我也不想深入研究
以下是代码：
class myClass {
public:
myClass() {}
~myClass() {
LOG << "Destructor called!";
}
};
浏览 1提问于2020-07-20得票数 0
回答已采纳
2回答
我在multiply online编译器上尝试了这段代码，它工作得很好，但当我在我的系统上尝试它时，出现了一些问题(虽然不完全是错误，但它并没有像预期的那样工作)。 静态对象和gloabl对象都没有调用析构函数。如果我将函数create放在main后面，然后在它调用create中的对象的构造函数之后，它不会做任何事情，不会调用任何析构函数，甚至不会打印函数创建后的消息。 我正在使用Microsoft Visual Studio Community 2017版本15.9.17，如果它有用的话。 那么有没有解决这些问题的办法，或者我需要重新安装Visual Studio呢？ //期望 Objec
浏览 18提问于2021-02-05得票数 1
2回答
动态库和主程序中的静态类变量
、、、、
我正在做一个项目，它有一个包含静态stl容器类的类'A‘。这个类包含在我的主程序和一个.so文件中。该类使用默认的(隐式的，未声明的)构造函数/析构函数。主程序使用dlopen()加载.so文件，并在其析构函数中调用dlclose()。当glibc调用静态类成员变量的析构函数时，程序在main退出后崩溃。问题似乎是，当调用dlclose()时，静态变量的析构函数也会被调用，然后当main exits() glibc也调用析构函数时，会导致双重释放。
我有两个问题，分别是：
1)在这种特殊情况下，为什么没有静态变量的两个副本(是的，我知道这听起来有点可笑，但既然主程序和.so文件都有一个
浏览 1提问于2010-04-13得票数 4
回答已采纳
1回答
考虑一下在c++中如何存在这两个存储持续时间(除其他外)：。
接下来，考虑以下代码：
static MyClassA a;
thread_local static MyClassB b;
另外，假装"a“和"b”可能不在同一个编译单元中。我“相信”"b“的析构函数将在"a”之前被调用，因为线程存储持续时间将首先终止，只有在完成之后，静态存储持续时间才会终止并调用"a“的析构函数。我一直在寻找这方面的标准参考，但我一直找不到一个。有人能用权威的来源来具体地证实这一点吗？
浏览 8提问于2015-05-12得票数 3
回答已采纳
1回答
我目前正在探索Boost.Serialization中与单例相关的一个非常棘手的bug。对于上下文:Boost1.65更改了单例中断is_destructed通知的实现，这会导致程序退出或库卸载时出现分段错误。Boost 1.66“修复”了这个问题，但是会泄漏内存。
单例代码(与这个问题相关)归结为：
template<class T> struct singleton{
T& inst(){
static T t;
return t;
}
}
使用静态成员函数变量可以避免，但在销毁方面仍然存在相同的问题。
然而，展示了如何解
浏览 0提问于2018-04-27得票数 4
我正在尝试实现以下行为(简化)：
有一个对象基类，任何人都可以从中派生出来，其中将有几个实例。
来自任何地方的任何人都可以将实例指针添加到全局可访问的指向对象的指针集。
在销毁时，对象应该从该集合中移除自身(如果它在其中)。
我只需要它在一个线程和一个模块中工作(没有动态库加载等)。
在概念上是这样的：
class Object {
public:
//...
~Object() { reg.erase(this); }
static void register(Object* obj) { reg.insert(obj); }
static std::set&l
浏览 3提问于2014-03-18得票数 3
回答已采纳
2回答
我正在尝试正确地完成以下设置：
给定的应用程序(具有多个源文件、编译单元)具有在许多编译单元中定义的class A类型的全局变量。它们应该由引入class B的新成员“管理”(其中只有一个实例存在)，在创建时，它们在类B的实例上“注册”自己，在销毁时“注销”。
让构造器工作是相当简单的。可以使用：
types.h
class B {
static B& Instance() {
static B singleton;
return singleton;
}
void registerA( const A& a ) {
// whatever
浏览 0提问于2012-05-20得票数 5
回答已采纳
2回答
在“加速C++”的第11章中，作者提出了一个用数组模拟std：：向量行为的向量类。他们使用分配程序类来处理内存管理。uncreate函数的作用是销毁数组的每个元素并释放分配给数组的空间：
template <class T> void Vec<T>::uncreate() {
if (data) {
// destroy (in reverse order) the elements that were constructed
iterator it = avail;
while (it != data)
alloc.destroy(--it
浏览 7提问于2013-08-06得票数 9
回答已采纳
5回答
为什么我可以在免费存储上创建具有私有析构函数的类的对象，但不能在堆栈上创建？
例如，这是非法的：
class Foo
{
public:
explicit Foo( int );
static void delete_foo(Foo* foo ) { delete foo; }
private:
int x;
~Foo();
Foo( const Foo& );
Foo& operator=(const Foo& );
};
int main()
{
Foo * fooptr = new Foo(5); // legal
浏览 0提问于2011-02-07得票数 15
我正在使用Embarcadero XE7编译器创建一个XE7项目。在这个项目中，我有以下代码设计：
从TForm继承的主窗体，其中包含析构函数
一堂“福”课
类"foo“是静态成员的"bar”类。
现在，从主表单析构函数开始，我需要执行foo类中包含的函数。因此，在我的主表单析构函数中，我放置了如下代码：
__fastcall TForm1::~TForm1()
{
Bar::m_Foo.ExecuteSomething();
}
然而，我的应用程序此时崩溃了，在我的例子中，有一个名为“”的错误(这个错误当然取决于我的实现，我不会在这里输入详细信息)
浏览 2提问于2017-11-18得票数 2
3回答
我正在做一个项目，它应该能够在运行时通过dlopen加载动态链接库。
核心框架已经完成，它确实在工作，但我对如何正确管理由库分配到堆上的对象有一些疑问。该库的接口只有一个方法，该方法返回一个指向在库中静态分配的对象的指针，该对象是具有virtual方法的公共类的子类型
为了更好地解释它，我将提供我希望它如何工作的存根：
// header common to the core and to the libraries
class BaseSetting {
..
}
class DerivedSetting1 : public BaseSetting { .. }
class Deriv
浏览 0提问于2014-02-06得票数 1
3回答
我正在开发一个第三方c++应用程序。它在退出过程中崩溃了。如果我看一下堆栈，我得到的只是__static_initialization_and_destruction_0函数和许多问号。项目很大，不幸的是它有很多静态对象。有没有办法找出是哪一个崩溃了？
浏览 4提问于2009-12-28得票数 1
我试着理解在退出范围时析构函数调用的顺序。假设我有以下代码：
class Parent{
Parent(){cout<<"parent c called \n";}
~Parent(){cout<< "parent d called \n";}
};
class Child: public parent{
Child(){cout<< "child c called \n";}
~Child(){cout<<"child d called\n";}
};
现在，我知道子构造函数
浏览 3提问于2014-12-16得票数 2
回答已采纳
2回答
在通信main()之前初始化的对象时，我们通常将其称为“静态初始化”。是否有一个标准术语与之相反，比如“静态去初始化”？这指的是那些静态对象何时被销毁(在退出main()之后)。
浏览 0提问于2018-09-17得票数 1
回答已采纳
1回答
嗨，我在网上的一个教程里找到了这一行。
当您声明一个静态对象并且析构函数抛出和异常时会发生什么？
与静态构造函数异常一样，应用程序将崩溃。
我无法理解如果物体是静态的还是非静态的.
谢谢
浏览 3提问于2013-06-09得票数 7
回答已采纳
4回答
我们有一个静态(单例)类，它将在多线程环境中使用。我们在它的构造函数和其他内存函数中使用互斥。但是，析构函数没有互斥锁。析构函数做一些任务，比如清理其他成员对象，等等。我们需要在析构函数中加入互斥量吗？
浏览 1提问于2009-06-02得票数 3
我的程序使用dlopen加载共享对象，稍后使用dlclose卸载它。有时，这个共享对象会再次加载。我注意到静态变量没有重新初始化(这对我的程序至关重要)，所以我在dlopen之后添加了一个测试( RTLD_NOLOAD)，以查看库是否真的被卸载。果然，它还在记忆中。
然后，我尝试反复调用dlclose，直到真正卸载库为止，但我得到的是一个无限循环。这是我用来检查库是否已卸载的代码：
dlclose(handles[name]);
do {
void *handle = dlopen(filenames[name], RTLD_NOW | RTLD_NOLOAD);
if (!hand
浏览 40提问于2014-06-28得票数 24
1回答
考虑到以下代码：
struct Bar {
Bar() { }
~Bar() { }
};
struct FooBase {
// No virtual destructor
};
struct Foo : FooBase {
Foo() : bar{} { }
union {
Bar bar;
};
};
int main() {
FooBase *p = new Foo;
static_cast<Foo *>(p)->bar.~Bar();
delete p;
}
我希望将Fo
浏览 4提问于2017-02-23得票数 3
回答已采纳
我正在尝试理解在主线程上下文中初始化和销毁具有静态存储持续时间和线程本地存储持续时间的命名空间范围和块范围对象的排序规则。考虑这两类：
struct Foo {
Foo() { std::cout << "Foo\n"; }
~Foo() { std::cout << "~Foo\n"; }
static Foo &instance();
};
struct Bar {
Bar() { std::cout << "Bar\n"; }
~Bar() { std::c
浏览 1提问于2019-01-01得票数 7
回答已采纳
问题
在派生类的析构函数执行之后、基类的析构函数执行之前，C++标准如何保证对象的状态？(这是调用派生类的子对象的析构函数的时间。)
示例
#include <string>
struct Base;
struct Member {
Member(Base *b);
~Member();
Base *b_;
};
struct Base {
virtual void f() {}
virtual ~Base() {}
};
struct Derived : Base {
Derived() : m(this) {}
virtual ~Derived
浏览 1提问于2012-06-28得票数 6
回答已采纳
我有一个三层深的类层次结构，如下所示：
class A {
public:
virtual ~A() {}
}
class B : public A {
public:
virtual ~B() {}
void foo(E *e) {
e->remove(this);
}
}
class C : public B {
public:
~C() {}
}
class E {
public:
void remove(A *a) {
delete a;
}
}
我想知道的是，当我在C的对象上调用f
浏览 0提问于2013-01-06得票数 3
回答已采纳
4回答
我不明白这一点：
3.8/1“T类型的对象的生存期结束时：-如果T是具有非平凡析构函数(12.4)的类类型，则析构函数调用启动，或者-对象所占用的存储被重用或释放。”
如果在析构函数启动之前生命周期结束，这不意味着访问析构函数中的成员是未定义的行为吗？
我也看到了这句话：
对于具有非平凡析构函数的对象， 12.7“引用了在析构函数完成执行后对象的任何非静态成员或基类导致未定义的行为。
但这并不能说明在毁灭过程中允许什么。
浏览 6提问于2011-12-23得票数 13
回答已采纳
据我所知，一个程序(在Linux中使用C++编写)在退出主函数时调用__cxa_finalize。我创建一个共享库，并在主函数中使用这个库。我想在主程序加载/卸载这个库时采取一些操作。我发现在创建共享库时，函数__attribute__可以用于这个目的(这个函数应该在共享库代码中实现)
我加了一句：
void __attribute__ ((constructor)) my_load(void);
void __attribute__ ((destructor)) my_unload(void);
我实现了my_load和my_unload函数，如下所示：
问题是，当退出主函数？my_unl
浏览 8提问于2012-05-17得票数 4
我反汇编了一个用C++编写的简单程序，里面有两个函数名。我猜ctor的意思是构造函数，dtor的意思是析构函数，全局这个词可能意味着它们创建和销毁全局对象。我猜不出aux这个名字。这两个函数是做什么的？
浏览 0提问于2011-06-25得票数 10
回答已采纳
快速上下文:我看到了程序关闭方面的错误，这些错误源于全局成员之间的依赖(：：叹息：：，我知道，我知道)。一个全局变量的析构函数可能指另一个全局变量--如果这个变量已经被破坏了，事情就会变得糟糕。
但是，这里有一个特殊的例子，我只是不知道行为是否定义得很好：是一个函数中的静态变量，即使在程序关闭期间，也可以依赖这个函数吗？或者，静态成员是否可能被销毁，函数无论如何都会运行，而不创建新的函数？
下面是一个展示我感兴趣的玩具的例子：
class Logger
{
public:
enum class Severity { DEBUG, INFO, WARNING, ERROR };
浏览 1提问于2018-10-22得票数 9
回答已采纳
如果基类没有虚拟析构函数(例如，为了避免vtable条目)，而且派生类只有基本属性，那么当删除基类的指针时，它是否释放了new分配的所有内存？我知道派生类的析构函数不会被调用，但是我想知道整个对象分配的内存是否会被释放？我还假设对派生指针调用delete将释放整个内存空间。
另外，如果它没有释放内存的派生类部分，那么在相同的情况下如何工作，但是如何使用基类中的虚拟析构函数，来知道有多少内存可以释放
示例：
class Base {
public:
int a;
int b;
Base() {}
~Base() {}
};
class Derived : publ
浏览 7提问于2010-11-27得票数 5
回答已采纳
1回答
我最近读过Alexandrescu的“现代C++设计”。读完第六章后，我开始担心我们公司的单身人士。因为我们有经验的团队领导写核心助手库，比如单身汉.。我问他，他处理独生子女的方式是否解决了死掉的引用问题？如果他使用的是C核心语言给出的at_exit函数调用？
他告诉我，C++11有单例支持，并将连续执行CTORs和DTOR，它们不会成为任何死引用问题。用户将不必处理同步问题。
即使这听起来很棒，但我在网上找不到证实他的任何信息。所以，请告诉我，如果C++11处理单身人士的死亡参考问题，如果是的话，请解释一下背后是什么黑暗魔法？
浏览 3提问于2014-05-24得票数 1
回答已采纳
2回答
可能重复：
他的一生是什么？
全球MyClass myclass;
全球static MyClass myclass;
全球const MyClass myclass;
全球static const MyClass myclass;
函数本地static MyClass myclass;，当它的初始化实际发生时
全局static constexpr MyClass myclass; in C++11
尤其是，它们是否会在常规程序端上被销毁(也就是说，main没有出错)？标准是怎么写的呢？
我注意到私有析构函数阻止了所有这些变量的创建。但是如果我没记错的
浏览 1提问于2012-10-04得票数 1
回答已采纳
1回答
单例破坏的出口:失效案例
、、、、
来自：
有一点是肯定的:如果单例析构函数相互依赖，则不能使用多个驱逐舰。另一种选择是完全避开驱逐舰，而是依赖于草案-标准的atexit()函数，正如Tim向我建议的那样:我认为atexit()是一个很好的方法来清理C++中的单个实例，如果您真的想要具有程序生存期且不需要替换的单个实例。
标准草案承诺了很多:函数atexit() from可以用来指定要在exit处调用的函数。如果要调用atexit()，则在调用atexit()调用中指定的函数之前，实现不应销毁在atexit()调用之前初始化的对象。
我看到这个失败的唯一方法是，如果一个静态初始化对象的析构函数依赖于一个Singleton实例，
浏览 0提问于2016-01-13得票数 0
回答已采纳
我知道派生类的类型与指向其基类的指针是兼容的。在给定的示例代码中，new bar对象构造先调用foo::foo()，然后调用bar::bar()。在各自的构造函数中，我将资源分配给类成员foo::int *a和bar::int *b。
现在我正在将这样构造的对象初始化为基类类型。使用obj，我可以调用基类析构函数，但不能调用派生类析构函数。那么，在这种情况下，我如何释放派生类资源呢？这不是内存泄漏吗？
#include <iostream>
class foo
{
int *a;
public:
foo()
{
a = new int[5];
浏览 0提问于2011-01-06得票数 1
回答已采纳
3回答
请考虑以下代码：
class A {
public:
void fun() {}
};
class B : public A {
public:
void fun() {}
};
int main()
{
A *p = new B;
delete p;
}
类A和B不是多态的，也没有类声明析构函数。如果我用g++ -Wall编译这段代码，GCC编译器会很高兴地编译这些代码。
但是如果我在A中将virtual添加到void fun()中，编译器会发出这样的警告：“删除具有非虚拟析构函数的多态类类型‘A’的对象可能会导致未定义的行为”。
我很清楚使用非
浏览 4提问于2014-04-05得票数 2
回答已采纳
1回答
我有以下情况：
我有一个包含来自类B的堆栈成员对象的类A：
Class A{
B b;
}
我正在使用B对象重新定义A的初始化和销毁行为。
Class B{
B(){cout<<"taken care of some specific context initialization"<<endl;}
~B(){cout<<"cleaning the context initialization done before"<<endl;}
}
到目前为止，这是有效的，因为当b被销毁时，~B()被调
浏览 0提问于2012-11-08得票数 3
回答已采纳
我的一位同事声称，一旦对象的析构函数调用开始，由线程(即对象本身的成员)完成的对对象成员的所有访问都是UB。
这意味着，如果线程正在访问对象的任何其他成员，则在对象的析构函数期间调用std::thread::join是UB。
我简要地查看了最新的标准草案，在“对象生命周期”(Object)下，但找不到给我一个决定性答案的东西。
behavior：下面的代码 是否介绍了未定义的？标准的哪些部分澄清了这种交互？
struct A
{
atomic<bool> x{true};
thread t;
// Capturing 'this' is par
浏览 1提问于2016-11-03得票数 4
回答已采纳
是否定义了可以从其析构函数内的指针访问已销毁对象的行为？是否保证该对象仍位于指针位置并可访问？例如，在下面的代码中，我销毁了a1，在它的析构函数中，我从指向a1的a2访问a1。
#include <iostream>
class A
{
public:
A(int* i) : m_i(i) {}
~A();
int* m_i;
};
A* a1;
A* a2;
int x = 0;
A::~A()
{
*a2->m_i = 1;
}
int main()
{
a1 = new A(&x);
a2 = a1;
浏览 3提问于2019-10-18得票数 2
回答已采纳
我有一个非常基本的反射实现，它包括一个Type类，它为它描述的类执行对象实例化。除去相关的部分，它看起来如下：
类型：
class Plugin; // forward declaration
typedef std::unique_ptr<Plugin> PluginPtr;
namespace Reflection {
class Type {
public:
explicit Type(PluginPtr(*)());
PluginPtr CreateInstance();
private:
Plu
浏览 7提问于2014-01-14得票数 1
回答已采纳
3回答
中断：--我不认为这是同一个问题--实际上，另一个问题是关于手动调用析构函数的一般问题。这是在创建过程中，在类本身内。仍然想知道当你这样做时会发生什么，如下面的问题所述。
一开始，我认为这很糟糕，真的很糟糕。只需分析构造函数的这段代码(请参阅下面)，这是由两个人编写的，需要将其转换为Delphi对象Pascal。它的行为必须和C版本一样。我不喜欢这种风格，很丑，但没关系。
另一件事是，在代码的两个阶段，它在失败时调用析构函数(我想关闭连接，但是删除时自动调用析构函数，为什么要这样做？)我认为这不是做这件事的方法，或者是在这里错过了什么？
另外，在调用析构函数之后，他们希望抛出一个异常(嗯？
浏览 0提问于2018-06-30得票数 6
回答已采纳
2回答
当t被放到全局范围时，它会尝试删除它存储的指针吗？
错误
kk(70137,0x1000d65c0) malloc: *** error for object 0x100b20940: pointer being freed was not allocated
kk(70137,0x1000d65c0) malloc: *** set a breakpoint in malloc_error_break to debug
#include <set>
struct A {
int k = 0;
};
class Test {
public:
static std::
浏览 1提问于2019-05-09得票数 1
回答已采纳
3回答
我有一个使用multiset作为容器的类：
multiset<string, SortFunction> elements;
在析构函数中，我应该如何擦除multiset？我是应该删除它，还是应该删除其中的所有元素？
浏览 1提问于2015-08-15得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
云直播
对象存储活动推荐
腾讯云开发者
