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

Question

我正在开发一个相当简单的优先级调度程序，它接受一个文本文件，其中的行格式为：

[N/S/n/s] number number

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

问题是，当我尝试实现我认为应该是相当简单的几行代码来执行此操作时，我遇到了“分段错误（核心转储）”，这似乎与我的尝试直接相关实际将字符串流发送到我创建的双变量。到目前为止，我已经包含了我的代码（显然还远远没有完成），并且还指出了我可以通过输出“made it to here”来执行的最后一行。我对这个问题感到非常困惑，希望能提供任何帮助。请注意，虽然我为了完成而发布了我的整个代码，但只有靠近底部的一小部分与我已经明确指出的问题相关。

代码：

#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

您的代码中有一些错误会导致未定义的行为，这就是您的分段错误的原因。即：

• 在使用参数之前不要检查参数的数量

• 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);
}

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

Answer 2

您通过-> 操作符取消引用trainInstance 而没有分配有效的缓冲区，因此系统会尝试写入奇怪的地方并导致分段错误。

你可以这样分配缓冲区：

struct Train *trainInstance = new struct Train;

这里不需要struct，但我使用了一个，因为它在原始代码中使用。

在使用argv[1]之前不要忘记检查参数的数量。