Question

我正在开发一个相当简单的优先级调度程序，该程序采用格式为行的文本文件：

[N/S/n/s] number number

我正在尝试将数字转换为双重格式。我正在尝试使用stringstream（这是一个必须在没有stod的Linux版本上运行的类项目），使用此处的示例作为参考：https://www.geeksforgeeks.org/converting-strings-numbers-cc/

问题是，当我尝试实现我认为应该是相当简单的几行代码时，我遇到了“Segmentation Fault（Core Dumped）”，这似乎与我的尝试直接相关实际上将stringstream发送到我创建的double变量。到目前为止，我已经包含了我的代码（显然还远远没有完成），并且还通过输出“将其设置为此处”来指示我能够执行的最后一行。我对这个问题非常困惑，并希望得到任何帮助。请注意，虽然为了完成起见我已经发布了我的整个代码，但只有一小部分底部与问题相关，我已明确指出。

代码：

#include <iostream>
#include <stdio.h>
#include<string.h>
#include <stdlib.h>
#include<cstring>
#include<sstream>
#include<cstdlib>
#include <unistd.h>
#include<pthread.h>
#include<ctype.h>
#include <vector>
#include <sys/wait.h>
#include <fstream>
#include<ctype.h>
using namespace std;

struct Train{
        public:
        char trainDirection;
        double trainPriority;
        double trainTimeToLoad;
        double trainTimeToCross;
};

void *trainFunction (void* t){cout << "placeholder function for "<< t <<endl;}

vector<string> split(string str, char c = ' '){

        vector<string> result;
        int start = 0;
        int end = 3;
        int loadCounter = 1;
        int crossCounter = 1;

        result.push_back(str.substr(start, 1));
        start = 2;

        while (str.at(end) != ' '){
                end++;
                loadCounter++;
        }

        result.push_back(str.substr(start, loadCounter));

        start = end + 1;
        end = start +1;

        while(end < str.size()){
                end++;
                crossCounter++;
        }

        result.push_back(str.substr(start, crossCounter));

        for(int i = 0; i < result.size(); i++){
                cout << result[i] <<"|";
        }

        cout<<endl;
        return result;
}

int main(int argc, char **argv){
//READ THE FILE

        const char* file = argv[1];
        cout << file <<endl;
        ifstream fileInput (file);
        string line;
        char* tokenPointer;
        int threadCount = 0;
        int indexOfThread = 0;

        while(getline(fileInput, line)){
                threadCount++;
        }

        fileInput.clear();
        fileInput.seekg(0, ios::beg);

//CREATE THREADS

        pthread_t thread[threadCount];

        while(getline(fileInput, line)){

                vector<string> splitLine = split(line);

                //create thread

                struct Train *trainInstance;

                stringstream directionStringStream(splitLine[0]);
                char directionChar = 'x';
                directionStringStream >> directionChar;
                trainInstance->trainDirection = directionChar;

                if(splitLine[0] == "N" || splitLine[0] == "S"){
                        trainInstance->trainPriority = 1;
                }
                else{
                        trainInstance->trainPriority = 0;
                }

                stringstream loadingTimeStringStream(splitLine[1]);
                double doubleLT = 0;
                cout << "made it to here" <<endl;
                loadingTimeStringStream >> doubleLT;        //THIS IS THE PROBLEM LINE
                trainInstance->trainTimeToLoad = doubleLT;

                stringstream crossingTimeStringStream(splitLine[2]);
                double doubleCT = 0;
                crossingTimeStringStream >> doubleCT;
                trainInstance->trainTimeToCross = doubleCT;

                pthread_create(&thread[indexOfThread], NULL, trainFunction,(void *) trainInstance);

                indexOfThread++;
        }
}

Answer 1

您通过collection运算符取消引用trainInstance而未分配有效缓冲区，因此系统会尝试写入奇怪的位置并导致分段错误。

您可以像这样分配缓冲区：

->

此处不需要

struct Train *trainInstance = new struct Train;，但我使用了一个，因为它在原始代码中使用。

另外，在使用struct之前，请不要忘记检查参数的数量。

Answer 2

您的代码中存在一些导致未定义行为的错误，这是导致细分错误的原因。即：

在使用之前，请不要检查参数的数量
您不会在trainFunction
您没有为trainInstance创建指向

前两个有点明显可以解决，所以我会谈谈最后一个。 C ++中的内存管理是微妙的，适当的解决方案取决于您的用例。因为Train对象很小，所以将它们分配为局部变量是最佳的。这里棘手的部分是确保它们不会过早被破坏。

简单地将声明更改为struct Train trainInstance;将无法正常工作，因为此结构将在当前循环迭代结束时被销毁，而线程仍可能存活并尝试访问该结构。

为了确保在线程完成后销毁Train对象，我们必须在线程数组之前声明它们，并确保在线程超出范围之前加入它们。

Train trainInstances[threadCount];
pthread_t thread[threadCount];

while(...) {
    ...
    pthread_create(&thread[indexOfThread], nullptr, trainFunction,static_cast<void *>(&trainInstances[indexOfThread]));
}
// Join threads eventually

// Use trainInstances safely after all threads have joined

// trainInstances will be destroyed at the end of this scope

这很干净且有效，但它并不是最佳选择，因为您可能希望线程由于某种原因而超过trainInstances。在这种情况下，保持它们存活直到线程被破坏是浪费内存。根据对象的数量，甚至可能不值得花时间尝试优化销毁时间，但您可以执行以下操作。

pthread_t thread[threadCount];
{
    Train trainInstances[threadCount];
    while(...) {
        ...
        pthread_create(&thread[indexOfThread], nullptr, trainFunction,static_cast<void *>(&trainInstances[indexOfThread]));
    }
    // Have threads use some signalling mechanism to signify they are done
    // and will never attempt to use their Train instance again

    // Use trainInstances

 }  // trainInstances destroyed

    // threads still alive

最好在处理不提供C ++接口的线程时避免使用指针，因为当你不能简单地按值传递智能指针时，处理动态内存管理是一件痛苦的事。如果使用new语句，则执行必须始终在返回的指针上找到一个相应的delete语句。虽然在某些情况下这可能听起来微不足道，但由于潜在的例外和早期的退货声明，它很复杂。

最后，请注意pthread_create对以下内容的更改。

pthread_create(&thread[indexOfThread], nullptr, trainFunction,static_cast<void *>(&trainInstances[indexOfThread]));

这条线的安全性有两个重大变化。

使用nullptr：NULL具有整数类型，可以无声地传递给非指针参数。如果没有命名参数，这是一个问题，因为如果没有查找函数签名并逐个验证参数，很难发现错误。 nullptr是类型安全的，只要在没有显式强制转换的情况下将其分配给非指针类型，就会导致编译器错误。

使用static_cast：C风格的演员阵容是危险的事情。他们会尝试一堆不同的演员阵容，然后选择第一个有效的演员阵容，这可能不是你想要的。看看下面的代码。

// Has the generic interface required by pthreads
void* pthreadFunc(void*);

int main() {
    int i;
    pthreadFunc((void*)i);
}

糟糕！应该(void*)(&i)将i的地址转换为void*。但是编译器不会抛出错误，因为它可以隐式地将整数值转换为void*，因此它只会将i的值转换为void*并将其传递给功能具有潜在的灾难性后果。使用static_cast将捕获该错误。 static_cast<void*>(i)根本无法编译，因此我们注意到我们的错误并将其更改为static_cast<void*>(&i)

尝试在C ++中将字符串转换为双精度时遇到分段错误

2 个答案: