when running a function from my project, the stod() function gives an incorrect result

I have three files - a json file, my project, and test (main.cpp)

json file:

{
    "points": {
        "range": 25,
        "step": 0.001
    }
}

in file main.cpp this code:

#include <iostream>
#include <fstream>
#include <string>
#include <nlohmann/json.hpp>


using std::cout;
using std::endl;
using std::string;
using json = nlohmann::json;


int main()
{
    std::ifstream jsonFile("json/settings.json");
    json parsedFile = json::parse(jsonFile);
    jsonFile.close();

    double parsed_number;
    printf("string: %s\nstod return: %f\n", 
           parsedFile["points"]["step"].dump().c_str(), 
           stod(parsedFile["points"]["step"].dump()));

    printf("type: %s\n", typeid(stod(parsedFile["points"]["step"].dump())).name());
    
    parsed_number = stod(parsedFile["points"]["step"].dump());
    printf("step: %f\n", parsed_number);

    std::string temporary = "0.001";
    parsed_number = stod(temporary);
    printf("temporary: %s \nstep: %f \n", temporary.c_str(), parsed_number);
}

/* outputs:
string: 0.001
stod returns: 0.001000
type: d
step: 0.001000
temporary: 0.001 
step: 0.001000
*/

This is the correct answer.

But in my project, the same code:

    std::ifstream jsonFile(json_filename);
    assert(jsonFile.is_open());
    json parsedFile = json::parse(jsonFile);
    jsonFile.close();
    //range = stoi(parsedFile["points"]["range"].dump());

    double parsed_number;
    printf("string: %s\nstod returns: %f\n", 
           parsedFile["points"]["step"].dump().c_str(), 
           stod(parsedFile["points"]["step"].dump()));

    printf("type: %s\n", typeid(stod(parsedFile["points"]["step"].dump())).name());
    
    parsed_number = stod(parsedFile["points"]["step"].dump());
    printf("step: %f\n", parsed_number);

    std::string temporary = "0.001";
    parsed_number = stod(temporary);
    printf("temporary: %s \nstep: %f \n", temporary.c_str(), parsed_number);

/* outputs:
string: 0.001
stod returns: 0,000000
type: d
step: 0,000000
temporary: 0.001 
step: 0,000000
*/

That is, from the string "0.001" in my project, the number 0 is obtained, and in the test file, the correct 0.001.

I tried to see what stod(parsedFile["points"]["step"].dump()) returns.
I also tried to convert string to double, you can see the result for yourself.

How can I get around this problem without using crutches?

C++20 standard.

I can't find any answers to this...

You should use the library function get<T>() to extract the value from the json object and not do it yourself with std::stod which is affected by the current locale.

In your case:

double parsed_number = parsedFile["points"]["step"].get<double>();

You could also create a from_json overload an populate objects directly if you wish:

#include <nlohmann/json.hpp>

#include <fstream>
#include <iostream>

using json = nlohmann::json;

json read_json_file() {
    if(std::ifstream jsonFile("json/settings.json"); jsonFile) {
        return json::parse(jsonFile);
    }
    return {};
}

struct points {
    int range;
    double step;
};

void from_json(const json& j, points& p) {
    auto& jpnts = j.at("points");
    jpnts.at("range").get_to(p.range);
    jpnts.at("step").get_to(p.step);
}

int main() {
    auto parsedFile = read_json_file();
    auto pnts = parsedFile.get<points>();

    std::cout << pnts.range << '\n' << pnts.step << '\n';
}