std::getline() reads carriage return \r into the string, how to avoid that?

Question

I need to read all attributes from a tеxt file that looks like the following for one Stern (engl.: Star) object. I need to replace the string "leer" with "" but there can also be a valid string which shouldn't be replaced with "".

I.e for another Stern object there could be "leer" instead of "Sol" as well.

Problem:
The problem is it doesn't replace the "leer" with the "". And it seems like it saves "leer\\r" in the object instead of only "leer" but I tried to replace "leer\\r" as well and it still doesn`t work.

This is one Stern in the text file that should be read:

0
Sol
0.000005
0.000000
0.000000
leer
1
0

And this is my operator >> to read it:

istream& operator>>(istream& is, Stern& obj)
{
    string dummy;
    is >> obj.m_ID;
    getline(is, dummy);
    getline(is, obj.m_Bez);

    if (obj.m_Bez == "leer")
        obj.m_Bez = "";

    is >> obj.m_xKoord >> obj.m_yKoord >> obj.m_zKoord;
    getline(is,dummy);
    getline(is,obj.m_Sternbild);

    if (obj.m_Sternbild == "leer")
        obj.m_Sternbild = "";

    is >> obj.m_Index >> obj.m_PrimID;

    return is;
}

Stern.h:

#ifndef STERN_H
#define STERN_H
#include <string>
#include <iostream>

using namespace std;

class Stern
{
public:
    Stern();
    // 2.a)
    //Stern(int m_ID, string m_Bez, float m_xKoord, float m_yKoord, float m_zKoord, string m_Sternbild, int m_Index, int m_PrimID); 
    virtual ~Stern();

    void print() const; // 1.b)
    friend ostream& operator<<(ostream& os, const Stern& obj); // 1.b)i.
    friend istream& operator>>(istream& is, Stern& obj);


private:
    int m_ID;
    string m_Bez;
    float m_xKoord;
    float m_yKoord;
    float m_zKoord;
    string m_Sternbild;
    int m_Index;
    int m_PrimID;
};

#endif /* STERN_H */

Answer 1

The problem is that in Windows a newline is represented as CR + LF which is: "\r\n" and in Unix it is LF which is just "\n".
Your std::getline(...) command is reading till the "\n" in "leer\r\n" and discards the "\n", your resulting string will be:

"leer\r"

To solve this problem and convert files between Unix/Windows there are the 2 tools dos2unix and unix2dos. The Ubuntu equivalents are fromdos and todos, you will need fromdos to convert your Windows text file to a Unix text file.

To test wether a file uses CR + LF or LF you can do:

dos2unix < myfile.txt | cmp -s - myfile.txt

which was ansered here on the Unix & Linux StackExchange site.

---

And it seems like it saves "leer\\r" in the object instead of only "leer" but I tried to replace "leer\\r" as well and it still doesn`t work. I still cant understand why my if (obj.m_Sternbild == "leer\\r") didn`t work because imo it should have worked?

It should be:

if (obj.m_Sternbild == "leer\r")

without escaping the backslash \, because \r is read into the string.

Edit:

As @FreelanceConsultant in the comment below write: The above answer is not a general solution. Because a binary compiled either on Windows or Unix should work for text files for both platforms.

There are two solutions for that.

The obvious one is, to compare against two different versions of the input. With std::getline the Windows result is "leer\r" and Unix result is "leer".

if (obj.m_Sternbild == "leer\r" || obj.m_Sternbild == "leer")

Another solution would be to normalize the newline representation to one form and only check against that. It is a matter of taste and performance, because you would need to create new strings. See his answer as example.

Answer 2

You could use this to remove any unwanted characters returned by std::getline.

// std::string s;
// std::getline(input, s);
s.erase(std::remove(s.begin(), s.end(), '\r' ), s.end());
s.erase(std::remove(s.begin(), s.end(), '\n' ), s.end());

This works on Linux systems where the input file is formatted with line endings CRLF. This is because, on Linux systems, std::getline is searching for the \n character, hence it returns an extra \r at the end of each line.

I would not expect this to work exactly as you might anticipate on other systems. For example, it might be the case that:

• On OS X, getline probably searches for \r, meaning subsequent calls return a string which starts with \n. (The above will probably still work, because you still erase the \n.
• On Windows, getline searches for \r\n. If a file was produced on OS X or Linux, I would assume getline fails to split the input into different lines, and just returns the entire input.
• I'm not 100% sure about the above two points and haven't tested either case, because I don't happen to have an OS X system available, or a Windows system setup for development work.

Answer 3

And it seems like it saves "leer\r" in the object instead of only "leer"

You can either trim the string you get from getline or use getline in combination with a stringstream :

 std::string line;
 getline(is,line);
 std::stringstream ss(line);
 std::string trimmed_string;
 ss >> trimmed_string;

Now trimmed_string will contain only the desired string, no end line, trainling or leading whitespace or other stuff.

PS: this only works if the string you want to read does not contain whitespace itself. If thats the case you have to resort to a bit more involved massaging of the string you get from getline or choose some special character that you can replace with whitespaces after reading (eg read "Alpha_Centauri" and then replace "_" with " " to get "Alpha Centauri").