返回在循环中创建的变量会导致析构函数被调用两次
是因为在每次循环迭代中，变量会被创建和销毁多次，每次销毁时都会调用一次析构函数。这种情况下，如果返回该变量，会导致该变量的析构函数被调用两次。
为了避免析构函数被调用两次的问题，可以采取以下几种方式：
- 将变量声明为局部变量而非循环内部的变量，这样可以避免变量被多次创建和销毁。
- 在循环内部创建变量时，避免返回该变量，可以将需要返回的结果保存在其他变量或数据结构中，在循环结束后返回该结果。
- 如果需要返回在循环中创建的对象，可以考虑使用智能指针，如shared_ptr或unique_ptr来管理对象的生命周期。这样可以确保在对象不再被引用时，析构函数能够正确地被调用，避免重复调用析构函数的问题。
总结： 返回在循环中创建的变量会导致析构函数被调用两次，可以通过将变量声明为局部变量、避免返回变量、使用智能指针等方式来避免这个问题。
相关·内容
4回答
class box
{
public:
double length;
double breadth;
double height;
~box()
{
cout<<"destructor executed "<<"\n";
}
};
int main(){
box mybox;
mybox.~box();
return 0;
}
我是以上述方式编写代码的。我希望析构函数~box()只会被调用一次。但实际上，指示符“析构函数已执行”被打印了两次。有什么线索吗？
浏览 12提问于2017-10-28得票数 1
我了解到，当一个对象超出作用域时会调用析构函数，并且析构函数也会删除这些对象。好吧，但这是怎么回事？
我显式地调用析构函数，如果它删除对象，那么为什么要隐式调用析构函数？尽管现在没有对象，因为它已经被显式析构函数调用删除了。抱歉，我可能是明明白白地说错了，但试着理解我的问题。
#include <iostream>
using namespace std;
class A{
public:
A(){
cout << "Constructor" << endl;
}
浏览 8提问于2015-06-07得票数 0
回答已采纳
我们曾经采访过一个非常有经验的C++开发人员，他无法回答以下问题:是否有必要从C++中的派生类析构函数中调用基类析构函数？
显然答案是否定的，C++将自动调用基类析构函数。但如果我们试着打电话呢？在我看来，结果将取决于基类析构函数是否可以在不调用错误行为的情况下被调用两次。
例如，在本例中：
class BaseSafe {
public:
~BaseSafe()
{
}
private:
int data;
};
class DerivedSafe {
public:
~DerivedSafe()
{
BaseSafe::~B
浏览 5提问于2010-05-04得票数 4
回答已采纳
3回答
我正在使用SDL在c++中制作一个游戏。我有一个main函数，它只调用run游戏函数。运行游戏函数运行游戏，并在退出时返回0。我尝试在每次调用之前和之后打印内容，seg错误应该在返回0时发生；
functioncall()
{
Loads of SDL and other stuff
SDL_Quit();
gamestatemanager.~Gamestatemanager();
return 0; // This is probably where i get the seg fault
}
浏览 2提问于2013-06-18得票数 0
回答已采纳
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
回答已采纳
此代码：
#include <iostream>
class Base { };
class Derived : public Base
{
public:
~Derived()
{
std::cout<< "Derived dtor" << std::endl;
}
};
int main()
{
Derived objD;
objD.~Derived();
return 0;
}
指纹：
Derived dtor // destructor called
Derived
浏览 2提问于2019-03-07得票数 1
回答已采纳
3回答
中断：--我不认为这是同一个问题--实际上，另一个问题是关于手动调用析构函数的一般问题。这是在创建过程中，在类本身内。仍然想知道当你这样做时会发生什么，如下面的问题所述。
一开始，我认为这很糟糕，真的很糟糕。只需分析构造函数的这段代码(请参阅下面)，这是由两个人编写的，需要将其转换为Delphi对象Pascal。它的行为必须和C版本一样。我不喜欢这种风格，很丑，但没关系。
另一件事是，在代码的两个阶段，它在失败时调用析构函数(我想关闭连接，但是删除时自动调用析构函数，为什么要这样做？)我认为这不是做这件事的方法，或者是在这里错过了什么？
另外，在调用析构函数之后，他们希望抛出一个异常(嗯？
浏览 0提问于2018-06-30得票数 6
回答已采纳
我正在运行主页中的hello示例代码：
extern crate iron;
use iron::prelude::*;
use iron::status;
fn main() {
fn hello_world(_: &mut Request) -> IronResult<Response> {
Ok(Response::with((status::Ok, "Hello World!")))
}
Iron::new(hello_world).http("localhost:3000").un
浏览 1提问于2015-08-11得票数 3
回答已采纳
在C++中，依赖本地对象按照构造的反向顺序进行销毁是一种糟糕的做法，还是应该在析构函数中以反向顺序显式地删除它们，以确保其遵循该顺序？
是的，你们是对的，问题本身就很糟糕。
因此，基本上这是一个场景：
class A {
private:
unique_ptr<Something> firstP;
unique_ptr<Something> secondP;
};
在某种程度上，firstP和secondP都会得到他们需要拥有的东西。我需要的是确保当A被破坏时，firstP会在第二P之后被销毁，所以firstP拥有的东西比secondP拥有
浏览 11提问于2015-08-12得票数 2
回答已采纳
我有下面的代码只是为了测试，模板函数是两次使用，第一次它是好的。在第二种情况下，我创建一个指针，并将指针作为引用传递到模板函数中。我预期行"obj.~T()“编译时失败。但实际上，代码编译并运行良好。当我通过函数进行调试时，程序简单地跳过obj.~T()；我使用的是VC10。
我的问题是：
这是一种预期的行为吗？如果它是基于c++标准中的哪个部分的？
对于这种行为有什么正反两面吗？在我的例子中，这是好的，因为没有编译错误，也没有运行时错误。但可能有一些情况，我不知道，但确实破坏了代码。
谢谢
template<typename T>
void ptrDest
浏览 3提问于2014-03-13得票数 5
回答已采纳
3回答
同步对返回值的访问
、、、
考虑以下C++成员函数：
size_t size() const
{
boost::lock_guard<boost::mutex> lock(m_mutex);
return m_size;
}
这里的目的不是同步对私有成员变量m_size的访问，而是确保调用方收到m_size的有效值。目标是防止函数在其他线程修改m_size的同时返回m_size。
但是，在调用此函数时是否涉及到任何潜在的种族条件？我不确定RAII风格的锁在这里是否足以防止比赛。假设在将函数的返回值推送到堆栈之前调用了锁的析构函数？
我是否需要这样做来保证线程的安全？
size_t si
浏览 4提问于2010-07-08得票数 14
回答已采纳
我是c++的新手，最近我使用c++学习数据结构。当错误发生时，我被卡住了，我试着调试，但它仍然困扰着我。所以，这个错误是我试图实现两个操作的连接和合并，我的终端在逻辑上显示了似乎成功的结果。然而，错误将在下一秒到来。就像img:enter image description here call stack 这是我的代码。希望有人能帮我解决这个问题，谢谢！ #pragma once
#include <iostream>
using namespace std;
class LinkedList;
class Node
{
private:
int data;
No
浏览 71提问于2021-06-21得票数 0
回答已采纳
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
回答已采纳
2回答
我读到过，当我们到达作用域的末尾时，会调用一个自动变量来清理资源。
那么，基本数据类型有析构函数吗？或者这里调用析构函数来清理资源的意思不同于当自动变量的作用域结束时删除它们？
浏览 2提问于2019-12-12得票数 2
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
回答已采纳
我从获取代码并编辑它，通过显式调用移动构造对象之一的析构函数来生成分段错误：
using namespace std;
struct Foo
{
Foo()
{
s = new char[100];
cout << "Constructor called!" << endl;
}
Foo(const Foo& f) = delete;
Foo(Foo&& f) :
s{f.s}
{
cout <<
浏览 1提问于2015-05-26得票数 0
回答已采纳
4回答
我只是在学习c++，因为我对C和Java都有一定的理解。我不太明白为什么我写的一些代码不会泄漏内存。代码如下：
// Foo.h
class Foo {
private:
std::vector<int> v;
public:
Foo();
virtual ~Foo();
void add_int(int);
}
// Foo.cpp
Foo::Foo(): v () {}
Foo::~Foo() {}
Foo::add_int(int x) {
v.append(x);
}
存储在v中的向量显然在内部存储了一个指向堆分配的内存的指针，该内存需要释放，但我从
浏览 3提问于2013-04-01得票数 2
回答已采纳
我想知道在传入析构函数时如何使用pthread_key_create。
我想要这样的东西：
static ComplexObject foo;
void workoncomplex(void *) {
foo.dosomestuff();
}
static pthread_key_t pthreadkey;
void function_called_by_threads() {
pthread_key_create(&pthreadkey, workoncomplex)
}
显然，我遗漏了相当多的细节。
对于任何不是主线程的线程，这显然是很好的(提供了锁定等)，并
浏览 3提问于2011-06-15得票数 4
回答已采纳
出于好奇，我试着做一些类似下面的例子，看看编译器是否给了我一个警告，而不是调用一个无穷无尽的循环，最终导致堆栈溢出。我想也许有一种不同的行为，而不仅仅是调用普通的函数或方法。但事实并非如此。有什么特别的解释吗?或者它只是作为普通的函数调用来处理，因为我是使用this操作符显式地调用基类析构函数？
示例：
class A {
virtual ~A();
};
class B : A {
virtual ~B() { this->~A(); }
};
浏览 5提问于2017-02-22得票数 0
回答已采纳
当我有一个循环，在这个循环中创建一个新的堆栈变量(不是在堆上分配它，而是在循环体中声明它的变量)，这个对象的析构函数保证在下一个迭代开始之前被调用，还是编译器展开的循环会改变它呢？
浏览 0提问于2019-12-06得票数 13
回答已采纳
1回答
显式调用析构函数
、、
在对对象的析构函数进行显式调用之后，我还能访问它吗？
例如,
class A{
public:
A(){
cout<<"Constructor\n";
x=5;
}
~A(){
cout<<"Destructor\n";
}
int x;
};
int main() {
ios_base::sync
浏览 1提问于2015-04-19得票数 3
回答已采纳
16回答
正如在中提到的，简单地第二次调用析构函数已经是未定义的行为12.4/14(3.8)。
例如：
class Class {
public:
~Class() {}
};
// somewhere in code:
{
Class* object = new Class();
object->~Class();
delete object; // UB because at this point the destructor call is attempted again
}
在这个例子中，类的设计方式使得析构函数可以被多次调用--不会发生双重删除这样的事情。
浏览 0提问于2010-05-05得票数 16
回答已采纳
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
回答已采纳
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
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
回答已采纳
2回答
#include <iostream.h>
class a {
public:
~a() { cout << 1; }
};
int main()
{
a ob;
ob.~a();
return 0;
}
如果错了比它有什么问题？
我尝试过在turbo c++上运行这段代码，但是我仍然得到了
预期在“ob.~a();”行的成员标识符
不然你猜输出？
浏览 0提问于2016-12-22得票数 0
回答已采纳
5回答
我知道如果不使用delete/free释放已分配的内存，最终会导致内存泄漏。我的问题是:如果我的程序被终止，即使我没有释放内存，操作系统也会为我释放内存吗？
浏览 0提问于2013-02-06得票数 2
回答已采纳
3回答
我检查了这段代码，在函数func()结束时，基类的析构函数已经被调用了两次。我不明白为什么？？谢谢。。
class base {
public:
base(){cout << "ctor of base\n";}
~base(){cout << "d-ctor of base\n";}
};
class derived: public base
{
public:
derived(){cout << "ctor of derived\n";}
~derived(){cout
浏览 0提问于2014-06-18得票数 0
回答已采纳
4回答
在下面的代码中，当执行从fn()返回到main时，在情况1中调用了B类的析构函数，但在情况2中没有调用。我不明白这种区别，因为当用new创建A时，两者都在堆内存上。你能解释一下吗？
class B {
public:
B() {
printf(" [B] COntsructor");
}
~B() {
printf(" [B] Destructor");
}
};
class A {
public:
A() {
printf(" [A] COntsructor&#
浏览 0提问于2013-01-07得票数 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
班级
class Dummy
{
public:
int x;
Dummy(int y):x(y)
{
}
~Dummy()
{
std::cout<<"boom"<<std::endl;
}
};
函数
Dummy& getRef()
{
Dummy* temp = new Dummy(5);
return *temp;
}
打电话
Dummy* get = &getRef();
std::cout<<get->x<<
浏览 5提问于2015-05-30得票数 0
回答已采纳
1回答
我是编程和学习课程的初学者。我正在跟踪一个，并为class Polygon制作一个析构函数。
的~Polygon没有删除PointArray points的行，只包含要减少numPolygons的行。我假设以某种方式激活了~PointArray以删除points。
为什么我们不必在delete[] &points; in ~Polygon
如果我的假设是正确的，那么PointArray的析构函数何时以及如何生效？
delete[] &points;在~Polygon中会如何影响程序？
下面的简化代码在VisualStudioCommunity2015下编译。
浏览 2提问于2017-01-04得票数 2
回答已采纳
3回答
通过删除基类析构派生类
、、、
我有一个类似以下代码的情况：
#include <iostream>
class A
{
public:
A() { std::cout << "A created!" << std::endl; }
~A() { std::cout << "A destroyed!" << std::endl; }
virtual const char* Name() { return "A"; }
};
class B : public A
{
public:
浏览 0提问于2010-07-31得票数 1
回答已采纳
如果我有以下课程：
class Small {
public:
Small();
Small(const Small &small);
~Small();
private:
int *arr;
};
和
class Big {
public:
Big();
Big(const Big &big);
~Big();
private:
char *name;
Small smallObject;
};
当我调用~Big()时，我会删除分配给name成员的动态内存，但是smallObject也使用动态内存，这是我
浏览 1提问于2021-03-15得票数 0
回答已采纳
2回答
我正在学习c++，并用操作编写了矩阵生成类的代码。
但是，当我尝试删除用户在整个工作之后输入的两个矩阵时，它会弹出以下消息：
“矩阵1.3.exe: 0xC0000005:访问冲突读取位置0xDDDDDDCD中0x0F4DBF9B (ucrtbased.dll)引发的异常”
在“(45) delete[] arri;”行，它位于析构函数中。
我试图删除方括号，但由于需要这些括号来删除数组，所以它也不起作用。
你知道这里出了什么问题吗？
#include <iostream>
#include <iomanip>
using namespace std;
class
浏览 1提问于2018-02-08得票数 2
回答已采纳
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
回答已采纳
在以下简单代码片段中：
#include <cstddef>
struct B
{
virtual ~B() = default;
static void operator delete(void *, int);
static void * operator new(size_t, int);
};
struct C : B
{
virtual ~C() = default;
};
Clang3.7抱怨“未删除的函数'~C‘不能覆盖已删除的函数”：
Visual和GCC都不报告此代码中的错误。是嘎嘎的缺陷还是什么？
浏览 0提问于2015-11-10得票数 7
回答已采纳
在C++编程语言中，有以下示例(3.2.4节)。
unique_ptr<Shape> read_shape(istream& is);
void user()
{
vector<unique_ptr<Shape>> v;
while (cin)
v.push_back(read_shape(cin));
draw_all(v);
// call draw() for each element
rotate_all(v,45);
// call rotate(45) for each e
浏览 9提问于2020-10-13得票数 2
回答已采纳
6回答
下面的代码调用析构函数4次：
#include<iostream>
using namespace std;
class A{
public:
A(){cout<<"A"<<endl;}
~A(){cout<<"~A"<<endl;}
A f(){cout<<"F"<<endl; A b; return b;}
};
int main(){
A a,b;
b=a.f();
}
输出：
A
A
F
A
~A
~A
~A
~A
浏览 43提问于2012-02-12得票数 5
class ParentClass {
protected:
int* intArray;
public:
~ParentClass(){
delete [] intArray;
}
};
class ChildClass : public ParentClass {
public:
ChildClass() : ParentClass() {
intArray = new int[5];
}
};
int main(int argc, const char * argv[]) {
ChildClass ch
浏览 15提问于2015-02-26得票数 0
回答已采纳
2回答
下面的代码只是用来说明我的问题。
template<class T>
class array<T>
{
public:
// constructor
array(cap = 10):capacity(cap)
{element = new T [capacity]; size =0;}
// destructor
~array(){delete [] element;}
void erase(int i);
private:
T *element;
int capacity;
浏览 3提问于2011-02-04得票数 4
回答已采纳
1回答
如果我有一个像这样的std::map std::map<int, std::list<int> > myMap; 在映射中填充了列表之后，我希望稍后清除所有元素，这样做就足够了吗?还是应该先遍历映射中的每个元素，然后先清除每个列表？
浏览 92提问于2020-09-30得票数 0
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
回答已采纳
下面的代码是用MSVC编译的(/MSVC)，并且无法用GCC/Clang编译m_ptr1和m_ptr2。
#include <memory>
struct ForwardDeclared;
class A {
public:
explicit A();
~A();
private:
std::unique_ptr<ForwardDeclared> m_ptr1 = nullptr; // not ok
std::unique_ptr<ForwardDeclared> m
浏览 5提问于2020-12-14得票数 11
10回答
我用这段代码在C++中试验析构函数：
#include <iostream>
struct temp
{
~temp() { std::cout << "Hello!" << std::endl; }
};
int main()
{
temp t;
t.~temp();
}
我看到了“你好！”正在打印两次。析构函数的调用不应该释放对象吗?当析构函数超出作用域时，不应该再次调用它。还是有其他的概念呢？
(我不打算在实践中这样做。我只是想了解这里发生了什么。)
浏览 0提问于2012-08-09得票数 23
回答已采纳
2回答
向量不释放线程中的内存
、、、、
如果我用_beginthreadex创建一个线程，并且在线程中使用了消耗200 If内存的std::vector<WCHAR> --当线程结束时，内存不会释放。即使在CloseHandle之后，内存也不会释放。
下面是一个有用的例子：
#include <windows.h>
#include <process.h>
#include <vector>
using namespace std;
unsigned __stdcall Thread_RestartComputer(void* pComputerName)
{
std::
浏览 6提问于2022-03-22得票数 1
回答已采纳
我的程序不会调用基类的虚拟析构函数。我在上找到了这个方法，所以我不知道出了什么问题。能请人帮忙吗。
#include <iostream>
#include <vector>
using namespace std;
class Number{
private:
int *arr;
int n;
public:
Number(int *a, int i):
arr(a),n(i){}
virtual vector<int> operator()()=0
浏览 2提问于2014-05-10得票数 0
回答已采纳
当QObject派生的对象被析构时，是否可以从其析构函数发出信号？我试过了，它似乎起作用了，但我不确定是否应该这样做。
例如，下面的代码
class MyClass : public QObject {
signals:
void mySignal(const QString &str);
public:
QString myString;
~MyClass() { emit mySignal(myString); }
}
将传递对某个对象的常量引用，该对象在执行连接的槽时可能已超出作用域。
浏览 0提问于2012-12-25得票数 15
回答已采纳
1回答
修改指针导致SIGSEGV信号
、、、、
这是我的第一次体验，所以不要挑剔。
这是SIGSEGV问题，它只出现在类链接中。"SDL_surface *屏幕面“指针中的问题。
密码来了..。
屏幕头
class screen
{
public:
screen();
SDLclass_Window *MainWindow=NULL;
SDL_Surface *ScreenSurface=NULL; //this is the problem pointer to the struct that cause error
//Those pointer are't NULL, see below
浏览 0提问于2013-11-14得票数 0
回答已采纳
我发现了一些我不明白的del行为，希望你能给我一些洞察力。我试图用hello_triangle和glfw来实现OpenGL的PyOpenGL。关闭OpenGL窗口后，我的程序应该清理，但是glDeleteBuffers会引发TypeError，但前提是在__del__函数中调用它：
class Scene:
def __init__ (self):
# ...
self.buffer = glGenBuffers(1)
# ...
def __del__ (self):
# ...
glDelete
浏览 0提问于2019-03-03得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
