在将对象添加到std :: list时,析构函数调用了对象
在将对象添加到std::list时，析构函数不会被调用。std::list是一种双向链表，它使用指针来存储对象的位置，并在内存中动态地分配对象。当对象被添加到std::list中时，它们的内存位置被记录在链表中，并且不会被立即删除。
当std::list被销毁时，它会自动调用对象的析构函数，并释放对象所占用的内存。因此，在将对象添加到std::list时，析构函数不会被调用，但是当std::list被销毁时，对象的析构函数会被调用。
总之，当对象被添加到std::list中时，析构函数不会被调用，而是在std::list被销毁时被调用。
相关·内容
1回答
我正在构建一个循环链表，我想知道do_remove方法是否定义得很好。当我运行这个程序时，它向我展示了它是，然而，我仍然有点困惑，为什么我不需要一个虚拟的destrutor在这种情况下。
是否只有当我想通过派生类的基本指针销毁派生类时才需要虚拟析构函数？
这是否意味着，通过将基类降为派生类，然后调用派生类析构函数，它将始终调用基类析构函数？
do_remove方法中是否存在可能的漏洞？
PS:我需要两个步骤来创建和销毁对象--分配/调用构造函数/调用析构函数/去分配；这就是我目前使用::operator new的原因。
下面是我正在编写的代码的一个独立的示例：
#include <ios
浏览 1提问于2017-12-17得票数 0
回答已采纳
1回答
我有以下程序：
#include <initializer_list>
#include <iostream>
class A;
class nih {
public:
virtual void apply(A & a) const { std::cout << "generic" << std::endl; };
};
union niit;
class A {
public:
int s; char kau;
A() : s(1), kau('-') { }
A(std::ini
浏览 0提问于2012-01-12得票数 1
回答已采纳
3回答
我是C++的新手(我使用的是Visual Studio2010旗舰版)，我有一个问题，要用一个std::list销毁一个类，我的代码是：
#include "p_list.h"
int main(){
p_list uno;
uno.~p_list();
return 0;
}
p_list类是：
#pragma once
#ifndef LISTADO_H
#define LISTADO_H
#include <list>
using namespace std;
class p_list
{
public:
list<in
浏览 2提问于2012-09-11得票数 0
1回答
下面是两个示例类以及类Foo的析构函数的实现。为什么m_barvec1是以析构函数中的方式实现的？vector<Bar *> m_barvec1是什么意思？
class Bar {
public:
Bar() : m_arr(new int[100]) {}
~Bar();
int m_x;
std::list<int> m_list;
int* m_arr;
};
class Foo {
public:
Foo() : m_barvec3(new std::vector<Bar>()) {}
浏览 13提问于2022-05-05得票数 1
1回答
在下面的代码中，a的析构函数被调用了两次，第一次调用似乎被忽略了：
struct A1
{
int A;
A1(int a=0) : A(a) { std::cout << "ctor: " << A << "\n"; std::cout.flush(); }
~A1() { std::cout << "dtor: " << A << "\n"; std::cout.flush(); }
};
int main()
{
A1
浏览 2提问于2014-07-26得票数 2
2回答
嘿，为什么基析构函数在这个程序结束时被调用了两次？
#include <iostream>
using namespace std;
class B{
public:
B(){
cout << "BC" << endl; x = 0;
}
virtual ~B(){
cout << "BD" << endl;
}
void f(){
cout << "BF" << endl;
}
virtual void g(
浏览 1提问于2010-06-05得票数 1
回答已采纳
8回答
类中的析构函数
、、
我开设了一堂课，根据安德鲁·科尼格和芭芭拉·E·莫的教科书“加速C++”，
析构函数的工作是在对象消失时执行任何应该进行的清理。通常，这种清理涉及释放构造函数已分配的资源，如内存。
我正试图写一个析构函数，我被所有的代码弄糊涂了。有时像这样的一个简单的解构函数被使用~MyIntArray() {}，有时{}之间也有一些东西。
把东西放在花括号之间的规则是什么？仅仅是容器--例如列表、数组、向量、指针--需要放在花括号之间(这就是我在代码示例中看到的)。
编辑:这是我的课，如果需要的话
class msgInfo
{
public:
msgInfo();
msgInfo(
浏览 2提问于2013-03-27得票数 0
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
回答已采纳
我试图使用shared_ptr而不是原始指针来实现链接列表。守则：
#include <memory>
class NodeTest
{
private:
int v;
std::shared_ptr<NodeTest> next;
public:
NodeTest() { v = 0; };
NodeTest(unsigned int i) { v = i; }
~NodeTest() {};
void setNext(std::shared_ptr<NodeTest> & toSet) { next
浏览 1提问于2019-02-21得票数 1
回答已采纳
为什么在下面的例子中都调用了析构函数，~D()，~C()，~B()，~A()？
只有一个虚拟析构函数：A的那个。
代码如下：
#include<iostream>
using namespace std;
class A
{
public:
virtual ~A()
{
cout<<"destruct A\n";
}
};
class B:public A
{
public:
~B()
{
cout<<"destruct B\n";
}
};
class C:public B
{
pu
浏览 0提问于2012-10-17得票数 6
回答已采纳
我有一个地图声明为
std::map< std::string, std::map<int,std::list<pointers*> > myMap; // in c++.
我想知道要删除此映射中的条目，调用myMap.erase(entryToBeDeleted)是否足够？或者，我是否应该遍历该子映射，首先删除所有内容，然后再删除条目？
此外，内部映射是一个以int为键、以指针列表为值的映射
浏览 2提问于2013-01-23得票数 0
回答已采纳
2回答
我听说空析构函数什么也不做，调用它也不会删除对象。但在守则中：
#include <iostream>
#include <set>
class a
{
public:
~a()
{}
std::set <int> myset;
};
int main()
{
a object;
object.myset.insert(55);
object.~a();
object.myset.insert(20);
std::cout << object.myset.size();
}
我得到："* glibc检测到* /.a
浏览 0提问于2013-02-06得票数 5
回答已采纳
6回答
下面是两个代码片段(准备编译)。在第一个片段中，我只对结构使用了前向声明，而从Guest类的基类dtor中删除指向此结构的指针时并未调用。
在第二个片段中，我使用了这个Guest类的完整定义，在Base works中使用了delete，而不是转发声明。
为什么？为什么会有不同呢？正向声明不应该仅仅是编译器的一个注解，说明这个类/结构的定义在其他地方吗？
我非常惊讶它不能直观地工作。
//First just forward dclr
#include "stdafx.h"
#include <iostream>
using std::cout;
struct
浏览 2提问于2010-10-26得票数 6
回答已采纳
5回答
假设我有两个容器存储指向相同对象的指针：
std::list<Foo*> fooList;
std::vector<Foo*> fooVec;
假设我通过一个if方法从这些容器中删除了一个对象：
std::vector<Foo*>::iterator itr =
std::find( fooVec.begin(), fooVec.end(), pToObj );
fooVec.erase( itr );
CppReference说这会调用对象的析构函数。这是否意味着指向fooList中的对象的指针是一个悬空指针？
我不喜欢使用引用计数指针。如何处理这个
浏览 1提问于2010-07-25得票数 3
回答已采纳
我有一个Foo对象和一个std::list，其中包含它的实例。我的问题是，当我向列表中添加一个新实例时，它首先调用ctor，然后再调用dtor。然后是另一个实例上的dtor (根据this指针)。
将单个实例添加到列表中，但由于调用了它的dtor (以及其父对象)，因此无法按预期使用该对象。
下面是一些简化的代码来说明这个问题：
#include <iostream>
#include <list>
class Foo
{
public:
Foo()
{
int breakpoint = 0;
}
~Foo()
浏览 0提问于2009-02-05得票数 9
回答已采纳
2回答
我正在尝试编写一个函数make_foo，它将“解包装”一个std::optional< foo >，返回包含的值。该函数假定使用了可选项，因此不对optional执行任何运行时检查。
以下是我的实现，以及编译后的程序集供参考。关于编译器输出，我有几个问题：
为什么这会导致分支代码？optional::operator*允许对包含的值进行未经检查的访问，因此我不希望看到任何分支。
为什么调用foo的析构函数?注意程序集中对on_destroy()的调用。如何在不调用析构函数的情况下将包含的值移出可选值？
C++17源
#include <optiona
浏览 4提问于2021-03-22得票数 5
回答已采纳
2回答
关于析构函数调用的混淆
、、、
是在销毁对象之前还是在对象被销毁之后调用析构函数？我认为它是在对象被销毁之前调用的，因为在一个对象被销毁后，我们无法访问该内存来释放其中的任何资源，但是如果我错了，请纠正我，以便我能够很好地理解它。
#include <iostream>
#include <cassert>
#include <cstddef>
class Check
{
public:
int neu{};
Check() = default;
Check(int n)
{
neu = n;
}
void print()
浏览 3提问于2020-12-20得票数 0
回答已采纳
在std::vector<T>中，向量拥有分配的存储空间，它构造T和析构Ts。不管T的类层次结构如何，std::vector<T>都知道它只创建了一个T，因此当.pop_back()被调用时，它只需要销毁一个T (而不是某个派生的T类)。
#include <vector>
struct Bar {
virtual ~Bar() noexcept = default;
};
struct FooOpen : Bar {
int a;
};
struct FooFinal final : Bar {
int a;
};
void
浏览 18提问于2022-08-06得票数 21
2回答
我在一个c++测试中发现了以下代码：
#include <iostream>
class A
{
public:
A(int n = 2) : m_i(n) { }
~A() { std::cout << m_i; }
protected:
int m_i;
};
class B
: public A
{
public:
B(int n) : m_x(m_i + 1) , m_a(n) { }
public:
~B()
{
std::cout << m_i;
-
浏览 0提问于2013-05-13得票数 1
回答已采纳
1回答
我有一个类，它的成员变量是std::list。我也有这些类的向量。如果我从向量中删除一个元素，是否会在已删除的实例上调用类析构函数？是否必须使用析构函数中的list:: clear ()显式清除列表？
class my_class {
string class_name;
list<int> my_list;
public:
my_class();
~my_class(); // destructor
};
vector<my_class> my_vec;
my_class obj1, obj2, obj3;
my_vec.pus
浏览 3提问于2014-10-22得票数 2
回答已采纳
来自维基百科。
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
回答已采纳
我有这样的情况：
#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
回答已采纳
8回答
关于下面的示例代码，为什么基类的析构函数被调用了两次？
class Base {
public:
Base() {
std::cout << "Base::Base()" << std::endl;
}
~Base() {
std::cout << "Base::~Base()" << std::endl;
}
};
class Derived : public Base {
public:
Derived() {
std:
浏览 1提问于2009-05-21得票数 4
回答已采纳
3回答
删除对象时C++断言错误
、、、、
我有奇怪的断言错误，我找不到这段代码有什么问题。
断言表达式是_BLOCK_TYPE_IS_VALID(pHead->nBlockUse)。
为了更好的可读性，我简化了一些代码。
class Creator
{
public:
virtual ~Creator()
{
for (MyObject* item : _list)
{
delete item; <-- assertion error here
item = 0;
}
_list.clear();
浏览 2提问于2015-01-04得票数 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
回答已采纳
我想基于引用计数器为脚本引擎做一些垃圾收集：
class HeapValue
{
private:
size_t _refCount;
public:
HeapValue()
: _refCount( 0 )
{ }
virtual ~HeapValue() { }
inline void reference() throw()
{
++this->_refCount;
}
inline void unreference() throw()
{
if( 0 == --this->_re
浏览 0提问于2014-07-31得票数 0
我应该为这个结构创建析构函数吗？或者是否有任何隐式析构函数&当它超出作用域时会被破坏吗？
这里，myLogStructure和mySubject都是struct类型。
#include "stdafx.h"
#ifndef MyLogStruct_H
#define MyLogStruct_H
#include <string>
#include<windows.h>
using namespace std;
struct mySubject
{
string Security_ID;
string Account_Name
浏览 5提问于2015-12-14得票数 0
回答已采纳
所以我有一些C++代码：
#include <iostream>
using namespace std;
class C {
public:
C() {i = 9; cout << "C0:" << i << endl;}
C(int i0) {i = i0; cout << "C1:" << i << endl;}
~C() {cout << "C2:" << i << endl;}
priv
浏览 5提问于2016-02-03得票数 0
回答已采纳
什么时候调用析构函数？最初，我认为当我们使用：
delete [] str;
然后，当我谈到“移动赋值”主题时，我注意到在我在我的rhs.str方法中空出我的move assignment之后直接调用了析构函数。
main.cpp
int main() {
Mystring a{"Hello"}; // Overloaded constructor
a = Mystring{"Hola"}; // Overloaded constructor then move assignment
// cout &l
浏览 2提问于2021-08-11得票数 1
回答已采纳
我有类Item，它定义自己的操作符new和operator delete如下：
class Item
{
public:
Item(const std::string &s):msg(s)
{
std::cout<<"Ctor: "<<msg<<std::endl;
}
static void* operator new(size_t size, int ID, const std::string &extra)
{
std::cout<<&#
浏览 0提问于2016-11-21得票数 9
回答已采纳
2回答
我当时正在阅读源代码，偶然发现了这段代码：
void mir::frontend::ResourceCache::free_resource(google::protobuf::Message* key)
{
std::shared_ptr<void> value;
{
std::lock_guard<std::mutex> lock(guard);
auto const& p = resources.find(key);
if (p != resources.end())
{
浏览 5提问于2013-03-11得票数 1
回答已采纳
给定一个代码(真正的伪代码)：
struct A { /* ... */ }; // assume is non-trivial
struct B { /* ... */ }; // assume is non-trivial
using UA = std::unique_ptr< A >;
using UB = std::unique_ptr< B >;
union U
{
UA a;
UB b;
};
U u{std::make_unique< A >(/* init */)};
u.a = nullptr; // destru
浏览 3提问于2015-09-23得票数 4
假设我们有三门课:父母，孩子和其他。
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
回答已采纳
Inner.hpp
#pragma once
#include <vector>
class Outter
{
public:
Outter();
~Outter() = default;
private:
class Inner;
std::vector<Inner> list;
};
Inner.cpp
#include "Inner.hpp"
#include <iostream>
class Outter::Inner
{
public:
Inner() : x(0), y(0), z(
浏览 2提问于2016-12-20得票数 2
回答已采纳
4回答
我试图弄清楚以下是否是未定义的行为。我有一种感觉，它不是UB，但我对标准的解读使它看起来像是UB：
#include <iostream>
struct A {
A() { std::cout << "1"; }
~A() { std::cout << "2"; }
};
int main() {
A a;
new (&a) A;
}
引用C++11标准：
说：“程序可以通过重用对象占用的存储来结束任何对象的生命周期。”
因此，在new (&a) A之后，原始的A对象已经结束
浏览 1提问于2018-09-03得票数 10
回答已采纳
10回答
我用这段代码在C++中试验析构函数：
#include <iostream>
struct temp
{
~temp() { std::cout << "Hello!" << std::endl; }
};
int main()
{
temp t;
t.~temp();
}
我看到了“你好！”正在打印两次。析构函数的调用不应该释放对象吗?当析构函数超出作用域时，不应该再次调用它。还是有其他的概念呢？
(我不打算在实践中这样做。我只是想了解这里发生了什么。)
浏览 0提问于2012-08-09得票数 23
回答已采纳
5回答
编辑:无论我是否使用向量，都会发生这种情况。它与具有自动销毁功能的本地对象有关，尽管我试图显式调用析构函数。
我想弄清楚为什么我的目标被删除了两次。我正在试验std::vector类，并希望了解如何处理对象的删除。有人能告诉我在这种情况下发生了什么吗？
代码：
#include<iostream>
#include<vector>
#include"DummyClass.h"
using namespace std;
void main(void){
//Make vector
vector<DummyClass> objV
浏览 6提问于2016-06-07得票数 3
回答已采纳
像std：：可选的求和类型是用条件简单的成员函数实现的，因为模板参数可能有一个非平凡的析构函数。因此，它的析构函数实现如下：
~optional()
{
if (bool(*this))
{
payload.~T();
}
}
~optional() requires std::is_trivially_destructible_v<T> = default;
为了表达脱离接触的状态，我们写道：
constexpr optional& operator = (nullopt_t) noexcept
{
if
浏览 18提问于2022-03-16得票数 0
我有一个类，成员变量是std::unique_ptr<double[]>。初始化此变量始终由make_unique<double[]>(size)完成。但是我不知道如何为这个成员变量编写析构函数的代码
我知道std::unique_ptr有一个方法get_deleter()，但当我查看文档时，它只提供了自定义的delete。我对相似的例子做了一些研究。但所有这些都是关于新的className()，而不是make_unique()。
cpp的版本是c++17
我的代码
class test{
public:
test(int size) : size_{size
浏览 1提问于2019-06-29得票数 2
那么，如果我使用一个RAII成语来管理某些上下文属性*，如果我在try块开始时赤裸裸地使用它，它会像我预期的那样工作吗？
换句话说，如果我有这个：
struct raii {
raii() {
std::cout << "Scope init"
<< std::endl; }
~raii() {
std::cout << "Scope exit"
<< std::endl; }
};
…我成功地使
浏览 10提问于2016-01-20得票数 5
回答已采纳
编辑：给任何人阅读这个问题以供将来使用:这个错误与unique_ptr没有任何关系。正如JoergB在他的回答中所说的，忘记基类的虚拟析构函数是我的一个错误。
在偶尔的运行时崩溃之后，我发现我的代码遭受了严重的内存泄漏。我运行我的程序与瓦兰，医生似乎同意:字节是绝对失去了。不过，我一辈子都找不出哪里出了问题。
我设法在这三行中确定了泄漏发生的原因：
std::unique_ptr<Operator> pointer(new Operator{"left", "right"});
NodeSpace space; // The node space
浏览 1提问于2013-01-27得票数 1
回答已采纳
3回答
#include <iostream>
class Base {
virtual void method() {std::cout << "from Base" << std::endl;}
public:
virtual ~Base() {method();}
void baseMethod() {method();}
};
class A : public Base {
void method() {std::cout << "from A" << std::en
浏览 0提问于2018-09-22得票数 1
2回答
据我所知，从容器中删除元素时调用析构函数，如果我是wrong..But Destr X打印不应出现在擦除后的之前，请纠正我
#include <iostream>
#include <memory>
#include <vector>
struct X
{
X()
{
std::cout<<"Contr X"<<std::endl;
}
~X()
{
std::cout<<"Destr X"<<std::
浏览 3提问于2021-05-02得票数 1
回答已采纳
2回答
函数指针可以指向自由函数、函数对象、成员函数调用的包装器中的任何内容。
但是，std::bind创建的函子可以有状态，也可以有自定义的。在哪里分配该状态，谁正在删除它？
考虑下面的例子-当向量被删除时，状态(数字10)会被删除吗？谁知道在函子上调用删除器，而在函数指针上不调用删除器？
#include <iostream>
#include <functional>
#include <vector>
using namespace std;
using namespace std::placeholders;
class Bar
{
public:
浏览 3提问于2014-08-20得票数 7
回答已采纳
正如我们所知道的，放置新的只是构造一个对象而不分配任何内存。而且，类Resource中的所有成员都是对象，而不是指针，尽管std::string内部持有一个动态数组，在销毁std::string对象时将释放该数组。*this指向堆栈上分配的内存，这意味着析构函数将始终被调用。所以我认为新的布局就是覆盖原来的对象。下面是一个简单的例子。当我运行这个示例时，内存使用量不断上升( VS 2019年)。
class Resource
{
public:
Resource() {};
Resource(const std::string& s) : str(s)
{
浏览 4提问于2020-08-18得票数 1
回答已采纳
我正在试验STL算法，更具体的是使用for_each函数。我尝试了一个简单的用例来连接字符串向量。请注意，这可能不是一个好的和/或有效的代码。如果您真的想连接字符串向量，请看boost::algorithm::join函数。
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "concatenator.h"
using namespace std;
int main(int argc, char **arg
浏览 7提问于2010-11-17得票数 1
1回答
我是C++的初学者，我有两个单独的错误的问题。无法访问内存和堆栈溢出。
这是我使用指针实现一个包含字符a的单词的Trie的实现。在运行测试时，我可以在没有问题的情况下成功地添加数百个甚至数千个节点，直到它最终崩溃。错误:无法访问内存。当我试图运行一个查询并使用"isAWord“函数时，我经常会遇到这个错误。当我试图运行解构函数时，我也会得到堆栈溢出。任何帮助都是值得赞赏的，因为我花了两天的时间尝试调试，但没有成功。
#include "Trie.h"
#include <iostream>
#include <iterator>
#include
浏览 0提问于2018-09-27得票数 1
回答已采纳
我正在尝试下面的示例：
class base // base class
{
public:
std::list<base*> values;
base(){}
void initialize(base *b) {
values.push_front(b);
}
virtual ~base()
{
values.clear();
cout<<"base called"<<endl;
}
};
class derived : public
浏览 0提问于2012-04-23得票数 4
1回答
虚拟析构函数？
、、
得到一些错误，认为它是一个带有非虚拟析构函数的虚拟函数。如何修复此错误？它在g++ 4.6.x中工作，但我需要它在旧版本的g++上工作。:(
#include <list>
template <typename T>
class container{
public:
~queue(){
queuel.clear();
queuel.~list();
}
virtual T func_x(){
T temp;
//do stuff with list<t> test
浏览 1提问于2012-01-27得票数 0
回答已采纳
我刚开始学习C++，我正在编写一个n体重力模拟器作为学习练习。为了了解线程处理，我决定将工作分成一个呈现线程(屏幕上显示状态)和一个模拟线程(推进模拟)。
RAII似乎很重要，因此呈现线程使用它来将控制台的游标在活动时变为可见的和不可见的，这是基于一个在构造函数&析构函数中管理状态的InvisibleCursor对象。这是可行的，而不是被描绘的。问题是，我只是让Ctrl气泡打开，从而关闭线程，它调用线程上的终止()，显然它不调用本地析构函数。
所以线程应该自己退出，很好。我决定也尝试为它们使用RAII，从而生成一个具有线程和方法以及stop标志成员变量的对象。在构造时，对象初始化其线程
浏览 1提问于2020-05-01得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
