It's usually good to add streaming operators to the class/struct since it breaks down a big problem into smaller parts. I've made an example here. I've added a class (OrderBox) for keeping many Order objects and added streaming operators for that class too. I don't write the length of the FIO field to the file but instead read/write until \0. Since \0 is perfectly valid in the middle of a string (but I assume that you will not use strings like that), I make sure that \0 in the middle of a string is never saved to file (look for the std::strlen in Orders ofstream operator). Should work in C++14/17/2a.
#include <iostream>
#include <initializer_list>
#include <fstream>
#include <vector>
#include <cstring>
#include <stdexcept>
enum Products {OOPlabs}; // no idea if this is an enum, needed it to compile ...
//-----------------------------------------------------------------------------
// slightly restructured - I put the FIO field last
struct Order
{
unsigned int productamount = 0;
Products product = Products::OOPlabs;
double cost = 0.0;
unsigned int orderID = 0;
std::string FIO = "Иванов Иван Иванович";
// operator to read from file
friend std::ifstream& operator>>(std::ifstream&, Order&);
// operator to write to file
friend std::ofstream& operator<<(std::ofstream&, const Order&);
// operator to stream to other ostreams, like std::cout
friend std::ostream& operator<<(std::ostream&, const Order&);
};
using OrderVec = std::vector<Order>;
//-----------------------------------------------------------------------------
// read one Order from a file stream
std::ifstream& operator>>(std::ifstream& is, Order& ord) {
is.read(reinterpret_cast<char*>(&ord.productamount), sizeof(ord.productamount));
is.read(reinterpret_cast<char*>(&ord.product), sizeof(ord.product));
is.read(reinterpret_cast<char*>(&ord.cost), sizeof(ord.cost));
is.read(reinterpret_cast<char*>(&ord.orderID), sizeof(ord.orderID));
std::getline(is, ord.FIO, '\0');
return is;
}
// write one Order to a file stream
std::ofstream& operator<<(std::ofstream& os, const Order& ord) {
os.write(reinterpret_cast<const char*>(&ord.productamount), sizeof(ord.productamount));
os.write(reinterpret_cast<const char*>(&ord.product), sizeof(ord.product));
os.write(reinterpret_cast<const char*>(&ord.cost), sizeof(ord.cost));
os.write(reinterpret_cast<const char*>(&ord.orderID), sizeof(ord.orderID));
// using strlen in case a '\0' has snuck into the string
os.write(ord.FIO.c_str(), std::strlen(ord.FIO.c_str())+1);
return os;
}
// stream an Order ... to std::cout
std::ostream& operator<<(std::ostream& os, const Order& ord) {
os << "{" << ord.productamount << "," << ord.product << "," << ord.cost
<< "," << ord.orderID << "," << ord.FIO << "}";
return os;
}
//-----------------------------------------------------------------------------
class OrderBox { // to keep all your Order objects
OrderVec m_orders;
public:
// default ctor
OrderBox() : m_orders() {}
// ctor to read from a file
OrderBox(const std::string file) :
m_orders()
{
if(!readbinfile(file))
throw std::runtime_error("error reading file");
}
// ctor to populate from an initializer_list {...}
OrderBox(std::initializer_list<Order> il) :
m_orders(il)
{}
bool createbinfile(const std::string& filename)
{
std::ofstream f(filename, std::ios::trunc | std::ios::binary);
if(f) f << *this; // use OrderBox's ofstream operator
return f.good();
}
bool readbinfile(const std::string& filename)
{
std::ifstream f(filename, std::ios::binary);
if(f) f >> *this; // use OrderBox's ifstream operator
return f.good();
}
// the OrderBox's stream operators
friend std::ifstream& operator>>(std::ifstream&, OrderBox&);
friend std::ofstream& operator<<(std::ofstream&, const OrderBox&);
friend std::ostream& operator<<(std::ostream&, const OrderBox&);
};
//-----------------------------------------------------------------------------
std::ifstream& operator>>(std::ifstream& is, OrderBox& ob) {
OrderVec result;
Order tmpord;
size_t reqlen;
is.read(reinterpret_cast<char*>(&reqlen), sizeof(reqlen));
result.reserve(reqlen);
while(is>>tmpord) // use the ifstream operator of Order
{
result.emplace_back(std::move(tmpord));
if(result.size()==reqlen) break; // all records read
}
if(result.size()!=reqlen) is.setstate(std::ios_base::failbit);
else std::swap(result, ob.m_orders);
return is;
}
std::ofstream& operator<<(std::ofstream& os, const OrderBox& ob) {
size_t reqlen = ob.m_orders.size();
os.write(reinterpret_cast<const char*>(&reqlen), sizeof(reqlen));
for(const auto& ord : ob.m_orders)
{
os << ord; // use the ofstream operator of Order
}
return os;
}
std::ostream& operator<<(std::ostream& os, const OrderBox& ob) {
os << "{\n";
for(const auto& ord : ob.m_orders) {
std::cout << " " << ord << "\n"; // print one order
}
os << "}\n";
return os;
}
//-----------------------------------------------------------------------------
int main() {
OrderBox ob = { // OrderBox with orders to write to file
{10, OOPlabs, 0.1, 1, "Hello One"},
{20, OOPlabs, 0.2, 2, "Hello Two"},
{30, OOPlabs, 0.3, 3, "Hello Three"},
{40, OOPlabs, 0.4, 4, "Hello Four"},
{50, OOPlabs, 0.5, 5, "Hello Five"}
};
try {
if(ob.createbinfile("orders.db")) {
// a new OrderBox to populate directly from the file
OrderBox newbox("orders.db");
// stream OrderBox
std::cout << newbox;
}
} catch(const std::exception& ex) {
std::clog << "Exception: " << ex.what() << "\n";
}
}
Output if it all works:
{
{10,0,0.1,1,Hello One}
{20,0,0.2,2,Hello Two}
{30,0,0.3,3,Hello Three}
{40,0,0.4,4,Hello Four}
{50,0,0.5,5,Hello Five}
}
