C++ operators on reference vars, what does this do? - c++

Question

I ran across a class with a member var as a reference (to a std::istream), with operator void *() and bool operator !() that return that reference, and i'm wondering what that would be for. The class is related to reading/parsing text files with config param pairs. I've pulled out from the (much) larger project the basic parts. In qt (MSVC 2015 community tool chain), i had to change the operator void *() to get a compile, but seems ok on the original linux system.
(In my desktop environment i get: "error: C2440: 'return': cannot convert from 'std::istream' to 'void *'", so i replaced with a call to if(m_in.eof()) and return nullptr)
class LR { // (line reader)
public:
LR(const std::string &filename);
.... other stuff
operator void *() const { return &m_in; }
bool operator !() { return !m_in; }
LR & operator>>(std::string &line);
private:
std::istream &m_in; // input stream
std::ifstream m_in_file; // input file (if specified)
};
LR::LR(const std::string &filename, ... other stuff) :
: m_in(m_in_file)
{
// .... other stuff
if(filename.size() > 0)
{
m_in_file.open(filename.c_str());
}
// .... other stuff
}
and the class that uses this:
class CR { // config reader
public:
// .... other stuff
void Load_Variable(const std::string &section, value, etc...);
private:
LR m_reader;
};
void CR::Load_Variable(const std::string &section, value, etc.) {
string line;
bool found = false;
while (m_reader >> line)
{
// .... check stuff, etc.
}
}
Debugging in Qt, while (m_reader >> line) calls the operator void *().
My questions:
Why use a member var reference to a std::istream like this?
What's the purpose of returning the address of member var &m_in when it's always valid because it's a member var (or is this not true?)
Would operator *() of m_reader ever return false? I've searched a bit online and not found any similar examples of this kind of use of operators on member var refs. I need to look next at what it does when the file open fails.
Possibly this code originally used heap pointer vars or some other approach for the m_in var and it was changed somewhere along the way to be a normal member var, with the operators then edited to this? I think the history is not easy to get.
Thanks for the help, stackoverflow is awesome.

Answer 1

The istream has a flag that indicates if an error has occurred and it overrides the ! operator for easy access. You'll often see it used like this:
myStream >> line;
if(!myStream)
cout<<"Error reading data"<<endl;
So you are not returning a reference, you are returning a Boolean flag. Think of the ! operator as isNoError() accessor.
Your class is doing the same thing, just passing through the result from the stream it wraps.
The * operator is probably there as backward compatibility measure. Probably the existing code base is expecting a pointer and this was added so that the existing code base works with the new implementation.