在Java中:
Lock lock = new ReentrantLock();
try{
lock.lock();
someFunctionLikelyToCauseAnException();
}
catch(e){...}
finally {
lock.unlock();
}
我的问题是上面这个例子我们知道锁总是会被解锁,因为最终总是执行,但是C++的保证是什么？
mutex m;
m.lock();
someFunctionLikelyToCauseAnException();
/// ????
这将如何工作？为什么？
我是C++新线程的新手,我试图清楚地了解线程之间如何共享/不共享内存.我正在使用std::threadC++ 11.从我在其他SO问题上看到的,堆栈内存只由一个线程拥有,堆内存在线程之间共享.所以从我认为我对堆栈与堆的理解,以下内容应该是正确的:
#include <thread>
using namespace std;
class Obj {
public:
int x;
Obj(){x = 0;}
};
int main() {
Obj stackObj;
Obj *heapObj = new Obj();
thread t([&]{
stackObj.x++;
heapObj->x++;
});
t.join();
assert(heapObj->x == 1);
assert(stackObj.x == 0);
}
请原谅我,如果我搞砸了一堆东西,lambda语法对我来说是非常新的.但希望我正在努力做的是连贯的.这会像我期望的那样表现吗？如果没有,我有什么误解？
析构函数可能不会抛出异常(因此在异常处理期间可以完成堆栈展开),并且必须释放分配给该对象的任何资源(因此不会泄漏资源).包含多个其他对象(或分配了多个资源)的对象的设计可能会在STL容器中记录指向它们的指针.因此析构函数将使用以下与迭代器相关的方法:
begin(),end()对于容器operator++ 对于有效的迭代器operator*或者operator->对于有效的迭代器但是为了保证析构函数不会抛出异常并释放其资源,您需要依赖那些永远不会抛出异常的方法.
依赖那些从不抛出异常的方法是否安全？很难想象一个实际的实现会抛出异常,因为STL迭代器本质上是一个指针.但标准C++是否要求这些方法永远不会抛出异常？我没有在C++标准中找到明确的陈述.
编辑:有趣的情况是C++ 03,当你想拥有一个指向资源的容器.这样做有充分的理由; 例如,如果您有多态资源.正如BjörnPollex在他的回答中指出的那样,如果你使用一个资源容器(比如a std::list< Resource >)而不是一个指向资源的指针的容器,容器的析构函数将为你处理对象的破坏(释放)Resource.
此代码导致未定义的行为:
void some_func() {
goto undefined;
{
T x = T();
undefined:
}
}
不调用构造函数.
但是这段代码怎么样？x的析构函数会被调用吗？我想会是,但我想确定.:)
void some_func() {
{
T x = T();
goto out;
}
out:
}
Swift Docs中有一条说明如下:
Swift中的错误处理类似于其他语言中的异常处理,使用了try,catch和throw关键字.与许多语言中的异常处理不同 - 包括Swift中的Objective-C-error处理不涉及展开调用堆栈,这可能是计算上昂贵的过程.因此,throw语句的性能特征与return语句的性能特征相当.
在Swift和Obj-c中展开调用堆栈意味着什么？这里的相关问题,但它是C++特定的.我知道调用栈是什么,但想要更详细地解释unwinding.
如果Swift没有展开调用堆栈,它会做什么呢？
为什么这在计算上会很昂贵？
总结:我想更好地理解异常如何工作以及Swift中的执行流程.
有谁知道这个错误代表什么？我们目前正在使用Azure Service Bus，并试图理解它的含义。
Microsoft.Azure.WebJobs.Script.HostDisposeException：主机已处置且无法使用。处置对象：'Microsoft.Azure.WebJobs.Script.WebHost.DependencyInjection.ScopedResolver'；在堆栈跟踪中找到 IListener：'Microsoft.Azure.WebJobs.ServiceBus.Listeners.ServiceBusListener
好吧,如果我使用RAII惯用语来管理某些上下文属性*,如果我在try块的开头裸体使用它,它是否会像我期望的那样工作？
换句话说,如果我有这个:
struct raii {
raii() {
std::cout << "Scope init"
<< std::endl; }
~raii() {
std::cout << "Scope exit"
<< std::endl; }
};
......我成功地使用它:
{
raii do_the_raii_thing;
stuff_expecting_raii_context();
/* … */
}
...如果我这样做,RAII实例将以相同的方式工作:
try {
raii do_the_raii_thing;
stuff_expecting_raii_context_that_might_throw();
/* … */
} catch (std::exception const&) {
/* … */
}
这可能是一个愚蠢的问题,但我想在此检查自己的理智 - 我对noexcept保证的微妙之处以及其他与例外相关的细节感到模糊- 所以请原谅我的天真
[*]对于那些好奇的人来说,这是我在RAII管理的Python C-API狡猾的GIL(全球翻译锁),在我的具体案例中
我正在关注内存布局和堆栈以了解堆栈帧..
作者很好地解释了堆栈帧，并说明了在给定时间点堆栈中的内容
他也在下面问了一些问题
以下是我尝试回答上述问题
- 假设一个程序进行了 5 次函数调用。堆栈上应该有多少帧？
如果函数相互独立，则只有主函数或主函数和调用函数会在堆栈中
我们看到堆栈线性向下增长，当函数返回时，堆栈上的最后一帧被释放并返回到未使用的内存。是否有可能将堆栈中间某处的帧返回到未使用的内存中？如果是这样，那对正在运行的程序意味着什么？
我认为这是不可能的，因为这可能会破坏内存
我不确定其余的问题。你能帮忙解决这个问题吗
如果您需要更多信息，请告诉我
所以这是一个关于动态内存分配和对象创建的C++练习.基本上 - 一个自定义类学生和一个自定义类组,它保留了一系列指向学生内部的指针.Group的析构函数显然存在问题,但我花了几个小时阅读手册和浏览论坛,但仍然无法理解我做错了什么.
欢迎任何评论.
UPD:问题是 - 退出时出错."调试断言失败了...... _BLOCK_TYPE_IS_VALID ......"
class Student{
char *firstName;
char *lastName;
public:
Student(): firstName(NULL), lastName(NULL){}
Student(const char *fname, const char *lname){
firstName = new char[32];
lastName = new char[32];
strcpy_s(firstName, 32, fname);
strcpy_s(lastName, 32, lname);
}
void Show(){
cout << firstName << " " << lastName << endl;
}
~Student(){
if(lastName != NULL)
delete[] lastName;
if(firstName != NULL)
delete[] firstName;
}
};
class Group{
Student *students;
int studentCounter;
public:
Group(){
students = NULL;
}
Group(const int …