#include<iostream>
#include<fstream>
#include<string>
#include<iomanip>
#include<sstream>
using namespace std;

int main()
{
	string filename{ "temps.txt" };

	ofstream outFile(filename);
	if (outFile)
	{
		outFile << fixed << setprecision(1);
		outFile << 48.4 << " " << 57.23 << '\n';
		outFile << 46.0 << " " << 50.0 << '\n';
		outFile << 78.3 << " " << 101.4 << '\n';
		outFile.close();
	}
	
	ifstream inFile(filename);
	if (inFile)
	{
		string line;
		stringstream ss;
		double low, high;

		cout << fixed << setprecision(1);
		while (getline(inFile, line))
		{
			ss.str(line);
			ss.clear();

			if (ss >> low >> high)
				cout  << setw(8) << low << setw(8) << high << endl;
		}
		inFile.close();
	}
	else
		cout << "Could not open file \"" << filename << "\"!\n";

	return 0;
}

#include <fstream>   // I personally prefer to order these alphabetically.
#include <iomanip>   // This makes it so much easier to see whether a
#include <iostream>  // required header is listed
#include <sstream>
#include <string>

// `using namespace std;` is for wannabes and script kiddies. Break the habit!

int main()
{
	// Prefer natural syntax -- it compiles to the exact same thing
	std::string filename = "temps.txt";
	
	// Our file output is simple enough we don't even need to name
	// our temporary variable. It creates the file, and if successful,
	// writes data to it, then closes the file when the variable is
	// destroyed.
	std::ofstream(filename)
		<< std::fixed << std::setprecision(1)
		<< 48.4 << " " << 57.23 << '\n'
		<< 46.0 << " " << 50.0  << '\n'
		<< 78.3 << " " << 101.4 << '\n';
		
	// Now we need a named (== persistent) variable.
	// It'll be destroyed at the end of main(), which will also
	// close the file, so RAII has again comes to the rescue!
	std::ifstream f(filename);
	
	// Prefer to check errors first. This keeps the error response 
	// close to the line that may cause it, and therefore significantly
	// reduces mental load on you, the programmer. The logic reads:
	//
	//   try something
	//   --> wut? No work?! CRASH AND BURN!!!
	//
	//   do next thing, 'cause everything is hunky dory good here
	//
	if (!f)
	{
		// Print information about errors to standard error.
		std::cerr<< "Could not open file \"" << filename << "\"!\n";
		return 1;
	}
	
	std::cout << std::fixed << std::setprecision(1);
	
	// The only variable that needs to persist outside the `while` loop is `line`[*1*].
	std::string line;
	while (getline(f, line))
	{
		// All the other variable belong _inside_ the loop.
		// (Let the compiler decide how to make this efficient!)
		std::istringstream ss(line);  // an _input_ string stream
		double low, high;
		
		// Attempt to read a line and print the values we got
		if (ss >> low >> high)
			std::cout << std::setw(8) << low << std::setw(8) << high << "\n";
		
		// (Note that an error in obtaining values from the
		//  line does NOT stop attempts to read further lines!)[*2*]
	}
	
	// Here both `line` and `f` go out of scope and RAII cleans up.
	// Notice also that main() is a _special_ function: You do not need
	// to `return 0`!
}