c++ - 尝试在 C++ 中将字符串转换为 double 时遇到段错误

Question

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

[N/S/n/s] number number

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

问题是，当我尝试实现我认为应该是相当简单的几行代码来执行此操作时，我遇到了“段错误(核心已转储)”，这似乎与我的尝试直接相关实际将 stringstream 发送到我创建的 double 变量。到目前为止，我已经包含了我的代码(显然还远未完成)，并且还通过输出“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++ 接口(interface)的线程时最好避免使用指针，因为当您不能简单地按值传递智能指针时，处理动态内存管理会很痛苦。如果您使用 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)