Example from book failing to compile, converting ifstream into bool

Question

I am a student of C++. I am working through the book, "Starting Out With C++ Early Objects (9th Edition). Example 27 from Chapter 6 (on Functions) reads data from a file but will not compile. Here is the full code:

// Program 6-27
#include <iostream>
#include <string>
#include <fstream>
#include <iomanip>
using namespace std;

// Function prototype
bool readData(ifstream &someFile, string &city, double &rain);

int main()
{
    ifstream inputFile;
    string city;
    double inchesOfRain;

    // Display table headings
    cout << "July Rainfall Totals for Selected Cities \n\n";
    cout << " City      Inches \n";
    cout << "_________________ \n";

    // Open the data file
    inputFile.open("rainfall.dat");
    if (inputFile.fail())
    cout << "Error opening data file.\n";
    else
    {
        // Call the readData function
        // Execute the loop as long as it found and read data
        while (readData(inputFile, city, inchesOfRain) == true)
        {
            cout << setw(11) << left << city;
            cout << fixed << showpoint << setprecision(2)
                << inchesOfRain << endl;
        }
        inputFile.close();
    }
    return 0;
}

bool readData(ifstream &someFile, string &city, double &rain)
{
    bool foundData = someFile >> city >> rain;
    return foundData;
}

And here's the accompanying data for the data file Rainfall.dat:

Chicago 3.70
Tampa 6.49
Houston 3.80

The problem lies with this line in the "bool readData" function:

bool foundData = someFile >> city >> rain;

I am using Visual Studio Community 2017. "someFile" gets a red squiggly line and the dropdown displays the following error:

no suitable conversion function from "std::basic_istream<char, std::char_traits<char>>" to "bool" exists

I don't really understand the error message but have managed to get this program working with:

A simple cast:

bool readData(ifstream &someFile, string &city, double &rain)
{
    return static_cast<bool>(someFile >> city >> rain);
}

Or this as an alternative:

bool readData(ifstream &someFile, string &city, double &rain)
{
    if(someFile >> city >> rain)
        return true;
    else
        return false;
}

So, my real questions are:

• Are my solutions ok or is there a better way?
• why is an error being thrown at all on Educational material that you would imagine should have been thoroughly tested first. Or is this just Visual Studio (intelliSense) specific, but works just fine on other compilers?

Answer 1

I'd consider

• returning std::ios& to postpone the contextual conversion to bool

  std::ios& readData(std::ifstream &someFile, std::string &city, double &rain) {
      return someFile >> city >> rain;
  }
  

  The upshot is that you can simple use it like so down-the-road:

  if (readData(file, city, rain)) {
      // ...
  }
  

  The interface will compile with just including #include <iosfwd>

---

• manually triggering the contextual conversion:

  bool readData(std::ifstream &someFile, std::string &city, double &rain) {
      return bool{someFile >> city >> rain};
  }
  

Answer 2

The stream has a member

explicit operator bool() const;

which makes it convertible to a bool value, but because the operator is explicit this only works in a context that requires a bool.

You have already discovered that this includes if-statements and explicit casts. It doesn't include other types of expressions, like assignments.

Originally (C++98) the operator wasn't explicit (because such things weren't invented yet) so the code example would probably have worked at the time. Seems like the book hasn't been updated in this part.

Answer 3

The operator bool for streams is declared in the base class basic_ios the following way

explicit operator bool() const;
^^^^^^^^

So there is no implicit conversion from the std::basic_ifstream to the type bool.

This solution

bool readData(ifstream &someFile, string &city, double &rain)
{
    return static_cast<bool>(someFile >> city >> rain);
}

looks good.

You can also use a trick with the logical negation operator the following way

bool readData(ifstream &someFile, string &city, double &rain)
{
    return !!(someFile >> city >> rain);
}

because according to the C++ Standard (5.3.1 Unary operators)

9 The operand of the logical negation operator ! is contextually converted to bool (Clause 4); its value is true if the converted operand is false and false otherwise. The type of the result is bool.

Though in my opinion the first function implementation is more readable.

Answer 4

I suppose they don't cover it until later in the book, but I'd approach this somewhat differently. I'd start by defining a struct to hold the name and rainfall for a city together:

struct precipitation { 
    std::string location;
    double amount;
};

Then I'd define an overload of operator>> to extract an object of that type from a stream:

std::istream &operator>>(std::istream &is, precipitation &p) { 
     return is >> p.location >> p.amount;
}

This is pretty much the standard form for stream extractors--take reference to a stream and a reference to an object of the type being extracted, and return the stream (again, by reference).

This lets you read fairly cleanly:

precipitation precip;

std::ifstream in("rainfall.dat");

while (in >> precip)
    std::cout << "City: " << precip.location << ", amount: " << precip.amount << "\n";

In case you're wondering how that works: a stream object supports conversion to Boolean, which produces true when reading from the stream has succeeded, and false when it fails, so this reads from the stream until reading fails, then it stops.

This is also the form expected by stream iterators, so it lets you use them as well. For example, to read the entire contents of the file into a vector, you'd do something like this:

std::vector<precipitation> data { std::istream_iterator<precipitation>(in),{}};