gpt4 book ai didi

c++ - 程序在一段时间后终止 "std::bad_alloc"

转载 作者:行者123 更新时间:2023-11-30 05:31:49 25 4
gpt4 key购买 nike

我全神贯注于此,但找不到错误。任何人都可以帮助我在哪里我做不好的编程。
boost::thread收到strings通过套接字,将它们拆分为 vector<string>并将它们排序到 shared class 中的正确变量中.其他线程从那里读取。我试图通过互斥使它成为线程安全的,如图所示 here .
感谢任何帮助,即使是小提示:)
这是程序终止的方式:

Looping...<enter to exit>
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
Aborted (core dumped)

这是对应的文件。纠缠ROS ,但这部分不应该是判决。

class shared
{
public:
shared() : count(0) {/*emp. body*/ } //constructor

void setvec(vector<string> &strVec, int type){

boost::upgrade_lock<boost::shared_mutex> lock(mtx);
boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock);

switch(type) {
case 1: typ1acc = strVec; setsensor[0] = true; break;
case 2: typ2mag = strVec; setsensor[1] = true; break;
case 3: typ3 = strVec; setsensor[2] = true; break;
}/**/
}
vector<string> getvec(int type) {
boost::shared_lock<boost::shared_mutex> lock(mtx);
switch(type) {
case 1: tmp = typ1acc; break;
case 2: tmp = typ2mag; break;
case 3: tmp = typ3; break;
}
return tmp;
}
private:
boost::shared_mutex mtx;
vector<string> tmp;
vector<string> typ1acc;
vector<string> typ2mag;
vector<string> typ3;
};

shared c; //class object

类从多个 boost::threads 调用:

    //socket function which sorts vectors into shared class
//this happens from one boost::thread
int type; //key sort by sensor type
vector<string> strVec;
c.setvec(strVec,type);

//multiple boost::threads call this to read the vectors
//this happens from multiple boost::thread
strVec = c.getvec(type);

最佳答案

我认为在函数外部设置 tmp 的问题在于,互斥析构函数将(或可以)在从 tmp 到永久变量的复制操作之前运行,从而导致一个小窗口,可以在其中覆盖 tmp 并导致潜在的数据竞争。

如果您创建简单的假互斥锁/字符串类来显示它们何时运行,您就可以看到这一点。最后的代码为我输出了以下内容(VC++ 2015):

CSimpleString Raw Constructor (g_tmp)
CSimpleString Raw Constructor (result)
CFakeMutex Constructor
CSimpleString Copy Raw Operator (TestFunction)
CSimpleString Copy Constructor (TestFunction)
CFakeMutex Destructor
CSimpleString Copy Operator (TestFunction)
CSimpleString Destructor (TestFunction)
Result = TestFunction

重要的行缩进显示你的互斥锁在重要的复制发生之前被销毁/释放。如果将 tmp 放入函数中,操作顺序似乎不会改变,但由于 tmp 是局部变量,因此不会发生潜在的数据竞争。

下面是用于测试的非常基本的代码。

#include <string.h>
#include <vector>

class CFakeMutex
{
public:

CFakeMutex()
{
printf("CFakeMutex Constructor\n");
}

~CFakeMutex()
{
printf("CFakeMutex Destructor\n");
}
};


class CSimpleString
{
public:

CSimpleString() {
printf("CSimpleString Empty Constructor\n");
}

CSimpleString(const char* pString) : m_String(pString) {
printf("CSimpleString Raw Constructor (%s)\n", pString);
}

CSimpleString(const CSimpleString& String) : m_String(String.m_String) {
printf("CSimpleString Copy Constructor (%s)\n", String.m_String.c_str());
}

~CSimpleString()
{
printf("CSimpleString Destructor (%s)\n", m_String.c_str());
}


CSimpleString& operator=(const CSimpleString& Src)
{
if (&Src == this) return *this;

printf("CSimpleString Copy Operator (%s)\n", Src.m_String.c_str());

m_String = Src.m_String;
return *this;
}

CSimpleString& operator=(const char* pString)
{
printf("CSimpleString Copy Raw Operator (%s)\n", pString);

m_String = pString;
return *this;
}

std::string m_String;

};

CSimpleString g_tmp("g_tmp");



CSimpleString TestFunction()
{
CFakeMutex Mutex;
CSimpleString local_tmp("local_tmp");

//local_tmp = "TestFunction";
//return local_tmp;

g_tmp = "TestFunction";
return g_tmp;

}

int main()
{
CSimpleString result("result");

result = TestFunction();

printf("Result = %s\n", result.m_String.c_str());

return 0;
}

关于c++ - 程序在一段时间后终止 "std::bad_alloc",我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/35391894/

25 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com