Reading in information from test.txt in C++ [closed] - c++

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 3 years ago.
Improve this question
I'm trying to read in from a text file in C++ for a Testing Harness. The idea is that I have to read in the 5 values of dice and put it into an array, and then read in a string, run through the program, then read in 5 more values of dice and put those into an array, and then read in a string, and run the program, etc.
The text file looks like this:
1 1 2 1 1 Aces
2 2 4 5 6 Twos
3 3 3 2 2 FullHouse
1 2 3 4 4 SmallStraight
2 3 4 5 6 LargeStraight
6 6 6 6 6 Sixes
What would be the best way using ifstream to search the file for 1 1 2 1 1 and put those values into an array, and then read in "Aces" into a string, and then go to the next line and do the same with the values 2 2 4 5 6 and the string "Twos."

Answer 1

One possible and also C++-style and object oriented approach is, to put the data and operations on the data in a tiny claas.
So let's create a small struct containing an array with 5 integers and a std::string.
For that class, we additionally overwrite the 'inserter' and 'extractor' operator. Then we can use this class for input and output in the same way like for an integral data type.
The inserter operator is ultra simple an just puts the 5 integers and the text in an std:ostream. The exteractor operator is some lines more and basically works like this:
Read a complete line with std::getline
Put the read line in an std::istringstream. With that we can easily extract further data
Then we use the std::istream_iterator and copy exact 5 integers from the std::istringstream. And at the end, we read the text.
This is overall not so complicated.
Then, we can simply call in main the standard IO mechanisms.
Please see the example below:
#include <iostream>
#include <sstream>
#include <iterator>
#include <string>
#include <array>
#include <algorithm>
std::istringstream sourceFile{R"(1 1 2 1 1 Aces
2 2 4 5 6 Twos
3 3 3 2 2 FullHouse
1 2 3 4 4 SmallStraight
2 3 4 5 6 LargeStraight
6 6 6 6 6 Sixes)"
};
constexpr size_t MaxValues = 5U;
// Proxy class for reading one line of given format
struct PData {
// The Array for the values
std::array<int, MaxValues> values{};
// The description
std::string text{};
// Overwrite extractor operator
friend std::istream& operator >> (std::istream& is, PData& pdata) {
// Read complete line
std::string line{};
if (std::getline(is, line)) {
// Put line in istringstream
std::istringstream iss(line);
// Extract all integers
std::copy_n(std::istream_iterator<int>(iss), MaxValues, pdata.values.begin());
// Read the text
iss >> pdata.text;
}
return is;
}
// Overwrite inserter operator
friend std::ostream& operator << (std::ostream& os, const PData& pdata) {
std::copy_n(pdata.values.begin(), 5, std::ostream_iterator<int>(os, "\n"));
return os << pdata.text << "\n";
}
};
int main() {
PData p{};
// Read lines and split them
while (sourceFile >> p) {
// Some debug output (Not necessary)
std::cout << p << "\n\n";
// Now do with p whatever you want
}
return 0;
}
Please note: Since I do have no files on SO, I use the std::istringstream as input file. You can of course use any other std::ifstream.

Answer 2

I just thought I would help you out and give you the entire solution. You remind me of myself back when I was just starting out. I've put in some comments as well.
You can read more about c++ file handling here.
#include <iostream>
#include <string>
#include <vector>
#include <fstream>
// Struct to hold each "line" of the data.
struct Info {
static const size_t DICE_LENGTH = 5;
int dice_values[DICE_LENGTH];
std::string description;
};
/**
* #brief Creates the sample file (assuming it doesn't already exist)
*/
void createFile() {
std::ofstream file ("file.txt");
if (file.is_open()) {
file << "1 1 2 1 1 Aces\n";
file << "2 2 4 5 6 Twos\n";
file << "3 3 3 2 2 FullHouse\n";
file << "1 2 3 4 4 SmallStraight\n";
file << "2 3 4 5 6 LargeStraight\n";
file << "6 6 6 6 6 Sixes";
}
else {
throw "Error creating file";
}
}
int main()
{
createFile();
std::vector<Info> data;
std::ifstream file("file.txt");
if (file.is_open()) {
Info info;
while (!file.eof()) {
// read all the dice values (at most = DICE_LENGTH)
for (size_t i = 0; i < Info::DICE_LENGTH; ++i) {
file >> info.dice_values[i];
}
// read the String
std::getline(file, info.description);
data.push_back(info);
}
}
else {
std::cerr << "Error opening the file for reading.\n";
return 1;
}
// display the data the was read from the file.
for (const auto &d : data) {
// Dice values.
for (const auto &dice : d.dice_values) {
std::cout << dice << " ";
}
// String value.
std::cout << d.description << std::endl;
}
return 0;
}
Output:
1 1 2 1 1 Aces
2 2 4 5 6 Twos
3 3 3 2 2 FullHouse
1 2 3 4 4 SmallStraight
2 3 4 5 6 LargeStraight
6 6 6 6 6 Sixes