Directly convert char* to std::string inside fscanf

Question

When using fscanf to read a string and store it into to a string variable, fscanf expects a char* as the parameter following the format string, .i.e., this is how it should be (as far as I know):

char str[<appropriate length here>];
std::fscanf(filepointer,"%s\n",str);

If I have std::string str instead of char str[] i get a -Wformat warning (obviously), and the program crashes with a Segnetation fault (i dont' know why, yet, but i'm not surprised). Aside from fixing the segfault i'd also do this properly, i.e., without receiving -Wformat warnings.

Is there a way to do the char* to std::string conversion "inline", i.e., inside the parameter list of fscanf or would I have to create a temporary char* variable to store the data and convert it to a std::string afterwards (as described, e.g., here, and I don't see a way to apply this method to my case).

Answer 1

As you could have read in the reference, it should be:

char str[<appropriate length here>];
fscanf(filepointer, "%s\n", str);

since str is an array. Read more in What is array to pointer decay?

There c_str() and data(), which can give you the C string of an std::string. However, thsese functions return a constant pointer, thus it cannot be used in fscanf() (which is a function coming from C, thus it handles C strings).

Note: In C++17, data() has an overload that returns a non-constant pointer, thus could be used for inline usage, like this:

std::string str(10, '\0');               // a string of size 10, null terminated
fscanf(filepointer, "%9s\n", str.data());
str.resize(strlen(str.data()));          // so that 'str.size()' is correct

Live Demo

But you should really be using C++ streams, like std::cin instead of C IO functions.

Example:

std::string str;
std::cin >> str;

Answer 2

If you are using C++, you should not be using C or C-style functions. Especially functions like std::fscanf which does unprotected writes. Here is how to properly read data from a file to an std::string in C++: Read file line by line using ifstream in C++

Answer 3

One can use std::string with std::scanf() like that:

#include <cstdlib>   // EXIT_FAILURE
#include <cstdio>    // std::scanf()
#include <cstring>   // std::strlen()
#include <string>
#include <iostream>

int main()
{
    std::string foo(40, '\0');  // fill the string with 40 0s
                                // for pre C++11 please make it 41
    int length = 0;
    if (std::scanf("%39s%n", &foo[0], &length) != 1) {
        std::cerr << "Input error :(\n\n";
        return EXIT_FAILURE;
    }

    foo.resize(length);  // let foo know its own length ^^
    std::cout << foo.length() << " chars: " << foo << '\n';
}

Answer 4

Since C++17, you can:

std::string str(<appropriate length here>, 0);
fscanf(filepointer, "%s\n", str.data());
str.resize(strlen(str.c_str()));

But you shouldn't.

First of all, it is not doing what you want it to do. If you have an input line like "Tom Jerry\n", it will only read "Tom", and what is even worse, it will try to read "Jerry" next time you read from the file. You should really use fgets(), std::istream::getline(), or, better yet, std::getline(file, str).

Second, a '\0', or char() is a valid character in a C++ string. If you read "Tom\0Jerry\n", the actual string your code will manage to read will contain "Tom\0Jerry", which is probably a valid result, but then it will cut it to "Tom" because of that resize(strlen(str.c_str())). You can alleviate it with creative use of %n format specifier, but why complicate your life in the first place?

Third, C++ string input routines can resize the string when necessary. In C functions, you need to specify a string size limit, which is often arbitrary. That may lead to buffer overflows if you are sloppy with your format specifiers (like in your example), but also to logical errors if you don't handle the special cases of truncated input correctly.

So, just use std::getline(file, str) with C++ stream input, and you will avoid all this.