std::getline with char* to strings - c++

Question

I have this code for reading from a file:
MyObject* LoadObject(wstring filePath)
{
ifstream fileReader;
fileReader.open(filePath);
if (fileReader.is_open())
{
string currentLine;
//std::basic_istream &std::getline
while (getline(fileReader, currentLine))
{
//Logic for loading MyObject* here
}
}
}
Now I'd like to be able to read from a char* buffer as well, is there a way I can keep the same reading logic and just changing how I read the lines?
MyObject* LoadObject(char* buffer, ulong length)
{
//Change how I read each line
//Keep the same logic for loading MyObject*
}

Answer 1

Move your work into something that takes a std::istream & to read from:
MyObject *ReadObject(std::istream &is)
{
string currentLine;
while (getline(is, currentLine))
{
//Logic for loading MyObject* here
}
}
Now just make your other functions use this one:
MyObject* LoadObject(wstring filePath)
{
ifstream fileReader;
fileReader.open(filePath);
if (fileReader.is_open())
{
return ReadObject(fileReader);
}
... //return something else
}
MyObject* LoadObject(char* buffer, ulong length)
{
std::string str(buffer, length);
std::istringsteam iss(str);
return ReadObject(iss);
}
Some small notes:
Pass filePath by const reference since you're not changing it and don't need a copy.
Make buffer a const char * if it's a C string, since you don't need to modify it. Better to use one parameter that knows the length instead of relying on the caller to synchronize the two parameters.
Consider returning a MyObject by value unless you really need the pointer.
Consider naming the two overloads of LoadObject differently to convey their intent. For all the caller knows, the C string overload could be a file path as well.

Answer 2

I'm not sure it would perform well, but you can do something like this:
std::istringstream iss(std::string(buffer, length));
while (getline(iss, currentLine))
{ ... }

Answer 3

You should modify your existing method and take actual reading code into separate method:
MyObject* LoadObjectFromStream(std::istream &in)
{
string currentLine;
//std::basic_istream &std::getline
while (getline(fileReader, currentLine))
{
//Logic for loading MyObject* here
}
}
Then use this method in both variants:
MyObject* LoadObject(wstring filePath)
{
ifstream fileReader;
fileReader.open(filePath);
if (fileReader.is_open())
return loadObjectFromStream( fileReader );
}
MyObject* LoadObject(const char *buffer, size_t size )
{
istrstream stream( buffer, size );
return loadObjectFromStream( stream );
}
you may want to make LoadObjectFromStream private etc, but that details of implementation.