在for循环中构造的对象是在它们各自的迭代之后还是在整个循环结束后被析构的？
在for循环中构造的对象是在它们各自的迭代之后被析构的。
在for循环中，每次迭代都会创建一个新的对象，并在迭代结束后被析构。这意味着每次循环都会创建一个新的对象实例，并在当前迭代结束后销毁。这种行为确保了每次迭代都使用独立的对象，避免了对象之间的干扰和冲突。
对于每次迭代创建的对象，其生命周期仅限于当前迭代。一旦迭代结束，对象就会被析构，释放相关的资源。这样可以有效地管理内存和资源，并确保程序的正确执行。
需要注意的是，如果在循环外部定义了对象，它们的生命周期将会延长到整个循环结束后才被析构。这是因为这些对象的作用域超出了循环范围，它们的析构发生在整个循环结束后。
总结起来，在for循环中构造的对象是在它们各自的迭代之后被析构的，而在循环外部定义的对象则在整个循环结束后被析构。这种行为确保了对象的正确创建和销毁，保证程序的正常运行。
相关·内容
我在一个并行的for循环中创建了大量的对象，以执行相同任务的细微变化。在构造时，对象会分配一些向量。循环看起来像这样： #pragma omp parallel for schedule(dynamic)
for (long long unsigned i=0; i<nparam; i++) {
Foo x;
x.do_task();
x.save_results();
} 它导致计算机内存不足。这是因为在循环的所有迭代完成之前，每个Foo对象都不会被析构。这可能是一个问题，因为如果我有100,000次迭代要做，并且每个对象使用一个有10,000个双精度的向量，
浏览 24提问于2019-12-07得票数 1
回答已采纳
当我有一个循环，在这个循环中创建一个新的堆栈变量(不是在堆上分配它，而是在循环体中声明它的变量)，这个对象的析构函数保证在下一个迭代开始之前被调用，还是编译器展开的循环会改变它呢？
浏览 0提问于2019-12-06得票数 13
回答已采纳
2回答
我正在尝试实现堆栈和队列。我还获得了测试堆栈和队列的代码(查看它们各自的功能是否正常工作)。
我实现了堆栈和quete的函数，但是当试图编译它们时，我得到了错误:在析构函数‘stack：：~Stack()’预期的类名之前'(‘token’)
在他们俩身上。
以下是泛型堆栈类：
template <class T>
class Stack
{
List<T> list;
public:
Stack();
Stack(const Stack<T>& otherStack);
~Stack();
}
列表类：
浏览 1提问于2013-02-08得票数 4
回答已采纳
4回答
当在C++中的循环中声明变量时，C++会在循环的每次迭代中重新生成变量吗？我的意思是，它会为另一个num变量重新分配内存吗？因此，如果循环迭代5次，是否会得到5个独立的num变量，它们各自具有唯一的值？在循环开始之前声明一个变量是不是更好的做法，即使该变量只在循环中使用？例如，如果我想将变量用作计数器或占位符，该怎么办？
// is this better code?
// int num;
for (int i = 0; i < 5; i++) {
int num;
// do stuff with num
}
浏览 2提问于2017-04-05得票数 4
2回答
考虑一下这个
class Foo
{
public:
Foo(){}
~Foo(){}
void NonConstBar() {}
void ConstBar() const {}
};
int main()
{
const Foo* pFoo = new Foo();
pFoo->ConstBar(); //No error
pFoo->NonConstBar(); //Compile error about non const function being invoked
delete pFoo; //No er
浏览 21提问于2011-12-04得票数 26
回答已采纳
这是的衍生产品。
我相信一个对象是完全形成的，并且可以期望在初始化列表的末尾(编辑:我错了！)。具体来说，成员函数和从构造函数本身访问本地状态的行为与其他成员函数的行为完全一样。
这似乎是一个有点争议的观点，但另一种观点是，只有在构造函数正常返回之后，对象才会完全形成。
下面是一个快速和肮脏的测试用例，它显示了初始化列表中提到的所有成员字段正在初始化，以及那些未被默认构造的成员字段。
#include <cstdio>
struct noise
{
noise() { printf("noise default constructed\n"); }
noi
浏览 2提问于2017-01-15得票数 3
回答已采纳
问题
在派生类的析构函数执行之后、基类的析构函数执行之前，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
回答已采纳
我想把MyClass存储在向量中。MyClass有指向InnerClass的指针和MyClass的内部析构函数，我想为以前分配的InnerClass对象释放内存。
下面是我的代码：
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#define PB push_back
#define MP make_pair
using namespace std;
int cnt;
map<int, int> m;
void mark(in
浏览 3提问于2013-05-27得票数 0
回答已采纳
class System
{
public:
virtual ~System() final { Shutdown(); };
virtual void Shutdown() = 0;
}
class DerivedSystem : public System
{
public:
virtual void Shutdown() override;
private:
Object* MySelfAllocatedObj;
}
这是我的用例
我有一个管理器，它持有由其他各种“模块”注册的系统*的列表，每个系
浏览 0提问于2018-08-01得票数 0
回答已采纳
1回答
嗨，我在网上的一个教程里找到了这一行。
当您声明一个静态对象并且析构函数抛出和异常时会发生什么？
与静态构造函数异常一样，应用程序将崩溃。
我无法理解如果物体是静态的还是非静态的.
谢谢
浏览 3提问于2013-06-09得票数 7
回答已采纳
5回答
class xyz{
...
...
};
while(i<n){
xyz ob;
...
...
}
在重新分配内存给之前的对象之前，我需要销毁它吗？
浏览 0提问于2010-10-10得票数 6
回答已采纳
5回答
删除对象
、、
我是个新手，只是想问一个关于删除对象的问题。
我有一个名为MyClass1的对象，从它我还有许多其他类，MyClassA，MyClassB等。
现在，我应该在MyClass1中执行此操作：
MyClass1::~MyClass1()
{
delete MyClassA;
delete MyClassB;
}
或者，当我删除MyClass1时，会自动删除在MyClass1中创建的所有内容吗？
另外，如果我在MyClassA和MyClassB中创建了更多的对象，这些对象是否也必须在各自的类中手动删除？
谢谢
浏览 0提问于2013-01-02得票数 0
我已经问了一个与私有析构函数相关的问题()，但我已经以下面的问题结束了，我仍然不明白确切的答案。
问题：
为什么当我创建一个具有私有析构函数的类的对象时，会调用私有析构函数？但当我创建一个普通对象时就不会了。
案例I
// myclass.h
#include <iostream>
class MyClass {
public:
static MyClass& GetInstance();
void Display();
private:
MyClass();
virtual ~MyClass();
};
MyClass::MyClas
浏览 0提问于2013-10-21得票数 1
3回答
我有这样的代码：
class Class {
public:
virtual ~Class() {}
};
int main()
{
Class* object = new Class();
delete object;
}
我用Visual C++ 10编译了它，并得到了下面的delete object反汇编语句：
delete object;
test eax,eax
je wmain+23h (401041h)
mov edx,dword ptr [eax]
push 1
mov
浏览 0提问于2011-11-08得票数 15
回答已采纳
3回答
当我执行这段代码时到底发生了什么？
class MyClass
{
MyClass()
{
//do something
delete this;
}
}
浏览 6提问于2011-03-15得票数 29
回答已采纳
3回答
在以下代码中，我很难理解造成崩溃的原因：
class A {
public:
virtual ~A() { goo(); }
void goo() { absFoo(); }
virtual void absFoo() = 0;
};
class B : public A {
public:
void absFoo() { cout << "In B \n"; }
};
int main()
{
B b1;
b1.goo();
}
主输出"In B“和预期的一样，但是当它崩溃时，我也无法调试它，编译器会
浏览 1提问于2018-02-13得票数 16
回答已采纳
这是维基上给出的例子，我看到的每个教程都是这样做的…… while (1) {
SDL_Event event;
while (SDL_PollEvent(&event)) {
/* handle your event here */
}
/* do some other stuff here -- draw your app, etc. */
} 如果我在我的游戏循环中的更新函数中有这种事件循环，我是否认为程序在每次循环迭代时重新定义和重新分配一个新的事件结构的位置是错误的？我认为这是一种低效的方式，这是错误的吗？难道事件结构
浏览 12提问于2020-10-23得票数 0
回答已采纳
1回答
在下面的代码中，我得到了以下链接器错误：
undefined reference toIBase::Name() const'` `
注在基类中，它调用虚拟函数名称()。目的是要调用派生类的名称实现，但是链接器正在查找IBase:: Name，而不是派生的：：Name()。如何解决这个问题？
template<class T_Extendable>
class IBase
{
public:
virtual ~IBase() = default;
virtual const std::string& Name() const = 0;
};
tem
浏览 3提问于2016-06-09得票数 0
回答已采纳
2回答
在通信main()之前初始化的对象时，我们通常将其称为“静态初始化”。是否有一个标准术语与之相反，比如“静态去初始化”？这指的是那些静态对象何时被销毁(在退出main()之后)。
浏览 0提问于2018-09-17得票数 1
回答已采纳
2回答
我遇到了一些我不清楚的例外问题。在C++中，当抛出对象时，首先将其复制到临时对象，然后将临时对象传递给捕获代码。复制涉及对象的类复制构造函数的使用。AFAIK，这意味着如果一个类有一个私有的拷贝构造函数，它不能被用作异常。但是，在VS2010中，将编译并运行以下代码：
class Except
{
Except(const Except& other) { i = 2; }
public:
int i;
Except() : i(1) {}
};
int main()
{
try
{
Except ex1;
th
浏览 2提问于2012-04-11得票数 11
回答已采纳
问题是关于循环中的变量。它是如何工作的？类似的问题：
代码：
for ( i = 0 ; i < 3 ; i++ ) {
vector<int> vint;
vint.push_back(i);
cout << "vecor size is: " << vint.size() << endl;
for ( j = 0 ; j < vint.size() ; j++ ) {
cout << "vint[" << j <<
浏览 0提问于2012-01-03得票数 0
回答已采纳
1回答
嗯，我正在尝试构建这一行代码，位，我得到了一个编译器错误。我尝试过在没有编译器的情况下构建，但这也不起作用。是关于__try和__except的。有人告诉我将try块中的代码移到另一个函数中。但我不明白：
错误12错误C2712:不能在需要对象展开的函数中使用__try
错误437错误LNK1181:无法打开输入文件
void MSocketThread::Run()
{
__try{
//throw(pThread);
while (true) { // Waiting for SafeUDP Settting...
浏览 4提问于2015-10-23得票数 1
我了解到，当一个对象超出作用域时会调用析构函数，并且析构函数也会删除这些对象。好吧，但这是怎么回事？
我显式地调用析构函数，如果它删除对象，那么为什么要隐式调用析构函数？尽管现在没有对象，因为它已经被显式析构函数调用删除了。抱歉，我可能是明明白白地说错了，但试着理解我的问题。
#include <iostream>
using namespace std;
class A{
public:
A(){
cout << "Constructor" << endl;
}
浏览 8提问于2015-06-07得票数 0
回答已采纳
这是潜在的内存泄漏，对吗?如果构造函数抛出，arr不会被释放，对吗？我已经读过，在这种情况下不会调用析构函数，但是badType的任何子对象都会被调用，但是我认为数组不在这里，因为它是一个原始指针，对吗？
class badType
{
private:
int* arr;
int myLen, myNum;
public:
badType(int myLen, int aNum)
{
this->myLen = myLen;
arr = new int[myLen];
if (aNum < 100)
浏览 2提问于2014-02-11得票数 2
回答已采纳
在析构函数调用主题的许多问题中，我找不到与我的情况完全相同的任何问题。
当传递的参数是引用时，为什么要调用析构函数？我把注释(主要是主要的)放在代码行下面，我认为输出是从代码行执行的。
struct X { // simple test class
int val;
void out(const std::string& s, int nv)
{
std::cerr << this << "–>" << s << ": " << val << &
浏览 0提问于2018-10-26得票数 4
我知道它不允许修改常量对象的状态，但是为什么析构函数可以更改这个状态呢？
class A
{
public:
~A()
{
i = 2; //?
}
void test() const
{
//i = 1; //Not allowed
}
int i = 0;
};
int main()
{
const A o;
o.test();
}
浏览 0提问于2019-07-10得票数 22
回答已采纳
void MyClass::method()
{
SomeObject a;
methodThatCanThrowException();
}
我希望在调用栈中捕获更高层的异常，而不是在method()中-但是在这个例子中，SomeObject析构函数会被调用吗？
浏览 1提问于2013-06-12得票数 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
回答已采纳
我在Delphi 7应用程序(CLX)中遇到了内存泄漏问题，代码如下：
unit Unit2;
interface
uses ECRClass, ECR_Text, SysUtils, Types, Classes, Variants, Math;
type tLeakClass = class
private
fsType : integer;
public
fsPrinter : TECR_Class;
published
constructor Create (AOwner : TComponent);
destructor Destroy
浏览 23提问于2013-03-31得票数 3
回答已采纳
5回答
在为课程做作业和学习C++时，我正在阅读何时使用堆栈分配和动态分配的问题。我知道，在很多情况下，使用堆栈分配更容易，也更好。但有一个简单的情况我很困惑。
假设您有一个for循环：
for(int i = 0; i < 10; i++)
{
MyObject obj(file);
obj.doSomething();
}
现在的问题是，如果对象包含状态，那么它在从1到10的迭代过程中保持状态(保持相同的对象)。也许来自Java/C#背景的消息会让我走上错误的道路。但我只看到了解决这个问题的两种方法：
使用动态内存的。不是将文件提供给构造函数，而是提供给方法doSomething
浏览 5提问于2011-01-18得票数 1
回答已采纳
我是AngularJS的新手，我正在用它写一个小的介绍网页。下面是JS文件：
// Create an Angular Module with the name as 'MyPersonalWebsiteApp'.
var myWebsiteApp = angular.module('MyPersonalWebsiteApp', [] );
myWebsiteApp.controller( 'dateAndTimeController', [ '$scope', '$interval', '$log
浏览 0提问于2019-09-01得票数 0
2回答
我的理解是，在调用move构造函数之后，在输入上调用析构函数。我决定在代码中测试这一点(见底部)，但得到的结果与我所期望的不同。我使用std::unique_ptr得到了同样的结果。
预期：
1
2
bar constructed
foo destructed //due to move
3
i'm foo
4
[Error?]
实数：
1
2
bar constructed
3
i'm foo
4
i'm foo
5
foo destructed
foo destructed
代码：
#include <iostream>
class Foo
{
pub
浏览 3提问于2014-12-22得票数 3
回答已采纳
2回答
我想知道何时对C++03和C++11都调用了临时的析构函数。
假设我有以下情况
foo method()
{
foo f;
......
......
return foo;
}
void doSomething()
{
foo f = method();
....
}
假设我使用的是标志-fno-elide-constructors，因为我想从理论上了解何时调用临时的析构函数。因此，在C++03中的上述代码中，当method()完成时，将使用其复制构造函数生成foo的副本。之后，在语句foo f = method()中，再次调用foo的复制构造函数。在本
浏览 3提问于2015-03-31得票数 8
回答已采纳
2回答
在使用"placement new“时，建议显式调用构造函数和析构函数。
在这种情况下，在类的初始化器部分中初始化的对象是否也可以正确构造？
显式调用析构函数也一样吗？成员对象是否被正确销毁？
浏览 0提问于2011-01-07得票数 0
回答已采纳
我正在尝试学习C++ (目前正在使用C)，我正在花时间在互联网上搜索好的教程(也许有人给了我一个好的建议)。
但是我找不到关于错误处理的标准方法的信息。
假设我有一个简单的类(我的example.h文件)：
const int MAX = 1000;
class Example {
public:
Example(int x);
private:
int x_val;
}
所以我想要做的就是检查，当一个类Example的对象被创建的时候，给定的坐标是否被允许，如果它高于允许的值，中止程序？
因此，在.cpp文件中：
Example::Example
浏览 3提问于2018-10-06得票数 0
在C++中，当对象的下降器被调用时，它首先调用子类的析构函数，然后调用父类的析构函数，这与构造过程相反。但是为什么呢？这似乎是一个简单的问题，但我还没有在互联网上找到一个令人满意的答案。有人能解释一下按这样的顺序进行破坏是多么的愚蠢吗？
浏览 2提问于2021-07-10得票数 0
回答已采纳
4回答
我使用Borland C++生成器。
我有个问题
#include <Classes.hpp>
class TMyObject : public TObject
{
__fastcall TMyObject();
__fastcall ~TMyObject();//I would like to inherite my destructor from TObject
};
__fastcall TMyObject::TMyObject() : TObject()//it will inherited my constructor from TObject
{
}
对于
浏览 4提问于2011-07-28得票数 5
回答已采纳
1回答
在以下守则中：
#include <string>
#include <iostream>
struct S {
std::string a;
int b;
S(const S&) = default;
S(S&&) = default;
S& operator=(const S&) = default;
S& operator=(S&&) = default; // not required here but should be added for co
浏览 1提问于2014-11-04得票数 3
回答已采纳
2回答
使用方法1与方法2的优缺点是什么？
方法1：
for ( std::vector<MyObject*>::iterator it = my_objects.begin(); it != my_objects.end(); ++it )
{
Vector2 temp_position = (*it)->GetPosition();
// do something...
}
方法二：
Vector2 temp_position; // I do NOT need scope for this object outside of the loop.
for ( st
浏览 0提问于2011-07-27得票数 0
回答已采纳
env:centos，gcc 4.8.5代码如下：
#include <iostream>
using namespace std;
class Base{
public:
virtual void Func()
{
cout << "base" << std::endl;
}
virtual void Func2()
{
Func();
}
virtual ~Base() {
Func();
}
};
class Dev :
浏览 1提问于2020-01-20得票数 0
回答已采纳
是否有一种方法可以使类的析构函数不调用某个类成员的析构函数和/或不调用其基类的析构函数？
如果这是不可能的，是否手动创建具有新位置和析构(/不-析构)的类成员是可能的解决办法？谢谢!
编辑:我需要这样做的原因:C类拥有对象M有一个非平凡的析构函数。C是M的朋友，以一种不需要调用M的析构函数的方式来管理M。调用它是可以的，但它意味着性能开销。(在这种情况下是个问题。)我在考虑从M生成一个派生类，它有一个不做任何事情的析构函数，但是它仍然会调用基的析构函数。
浏览 0提问于2017-05-30得票数 0
回答已采纳
我有这样的代码：
struct data {
void doNothing() {}
};
int main() {
data* ptr = new data();
ptr->~data();
ptr->doNothing();
::operator delete(ptr);
}
注意，doNothing()是在对象被销毁之后，而是在内存被释放之前调用的。看起来“对象生存期”已经结束，但是指针仍然指向正确分配的内存。成员函数不访问任何成员变量。
在这种情况下，成员函数调用是否合法？
浏览 8提问于2015-05-18得票数 24
正如我们所知道的，放置新的只是构造一个对象而不分配任何内存。而且，类Resource中的所有成员都是对象，而不是指针，尽管std::string内部持有一个动态数组，在销毁std::string对象时将释放该数组。*this指向堆栈上分配的内存，这意味着析构函数将始终被调用。所以我认为新的布局就是覆盖原来的对象。下面是一个简单的例子。当我运行这个示例时，内存使用量不断上升( VS 2019年)。
class Resource
{
public:
Resource() {};
Resource(const std::string& s) : str(s)
{
浏览 4提问于2020-08-18得票数 1
回答已采纳
一个子类继承一个没有析构函数的父类(只有编译器生成的默认函数)，这会是一个糟糕的设计吗？一些书声称它不好，但没有提到在什么情况下会好。
浏览 0提问于2012-08-05得票数 3
回答已采纳
以下节目：
#include <iostream>
using namespace std;
class Test
{
public:
Test() { cout << "Constructor is executed\n"; }
~Test() { cout << "Destructor is executed\n"; }
};
int main()
{
Test(); // Explicit call to constructor
Test t; // local object
浏览 2提问于2017-03-14得票数 2
回答已采纳
2回答
我目前正在学习C++，并希望了解构造函数如何在继承的上下文中工作。这是我父母和孩子的课程：
#include <iostream>
#include <string>
enum COLOR { Green, Blue, White, Black, Brown, };
class Animal
{
protected:
std::string _name;
COLOR _color;
public:
Animal(): _name("unknown"){
std:
浏览 3提问于2021-10-22得票数 0
回答已采纳
1回答
考虑以下代码：
#include <type_traits>
struct T {};
static_assert(std::is_trivially_destructible< T >{});
static_assert(std::is_trivially_default_constructible< T >{});
struct N { ~N() { ; } };
static_assert(!std::is_trivially_destructible< N >{});
static_assert(!std::is_triviall
浏览 2提问于2015-11-25得票数 15
回答已采纳
1回答
在从GCC用C++0x编译的MinGW代码main返回后，我一直在努力解决分段错误，并将其缩小到简单的情况：
class A {
public:
virtual ~A();
};
A::~A() {
}
const A a;
int main() {
return 0;
}
其原因与以下因素有关：
对象之前的const限定符，删除它将停止seg错误，
class A中缺少构造函数--添加空构造函数可以阻止seg错误。
版本的增强型-更新的TDM MinGW与gcc 4.8.1不构建代码导致seg故障。
是我触发了一些未定义的行为，还是真正的编译器错误是
浏览 4提问于2014-07-15得票数 2
回答已采纳
我想知道为什么我向后推回向量的元素会在这种情况下被调用其析构函数：
#include <iostream>
#include <vector>
class Foo
{
public:
Foo(int a)
: m_a(a)
{
std::cout << "Foo ctor() " << m_a << std::endl;
}
~Foo()
{
std::cout << "Foo dtor() " <&l
浏览 2提问于2014-11-07得票数 2
回答已采纳
上下文
我试图掌握安置-新机制，因为我从来没有使用过它。出于纯粹的好奇心，我正试着理解如何正确地使用它。
为了说明这个问题，我们将考虑以下代码库：
struct Pack
{
int a, b, c, d;
Pack() = default;
Pack(int w, int x, int y, int z) : a(w), b(x), c(y), d(z)
{}
~Pack()
{
std::cout << "Destroyed\n";
}
};
std::ostream & oper
浏览 11提问于2022-06-01得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
