Создать типированный файл записей, который содержит данные о квартирах, которые продаются

#include <iostream>
#include <vector>
#include <fstream>
#include <string>
 
namespace cf
{
    enum TYPE_HOUSE { BRICK, PANEL, NONE };
 
    struct Flat
    {
        Flat() : totalArea(0), livingArea(0), kitArea(0), loggia(false),typeHouse(NONE),
            totalNumFloors(0), floor(0), region("none"), cost(0){}
        Flat(float tA, float lA, float kA, bool l, TYPE_HOUSE th, int tNF, int f, char * r, float c) :
            totalArea(tA), livingArea(lA), kitArea(kA), loggia(l),typeHouse(th),
            totalNumFloors(tNF), floor(f), region(r), cost(c){}
        float totalArea;
        float livingArea;
        float kitArea;
        bool loggia;
        int typeHouse;
        int totalNumFloors;
        int floor;
        std::string region;
        float cost;
    };
    
    class DataBaseApartament
    {
        private:
            std::vector<Flat> base;
            char * fileName;
            std::fstream stream;
        public:
            DataBaseApartament(char * file)
            {
                fileName = file;
                stream.open(fileName);
                Flat flat;
                for(int n; !stream.read(reinterpret_cast<char*>(&flat), sizeof(flat)).fail(); base.push_back(flat));
            }
            void addFlat() 
            { 
                    Flat flat;
                    char * t;
                    std::cout << "total area  : "; std::cin >> flat.totalArea;
                    std::cout << "living area : "; std::cin >> flat.livingArea;
                    std::cout << "kitchen area : "; std::cin >> flat.kitArea;
                    std::cout << "loggia : "; std::cin >> flat.loggia;
                    std::cout << "type house(1 - brick, 2 - panel) : "; std::cin >> flat.typeHouse;
                    std::cout << "total number floors : "; std::cin >> flat.totalNumFloors;
                    std::cout << "floor: "; std::cin >> flat.floor;
                    std::cout << "region : "; std::getline(std::cin, flat.region);
                    std::cout << "cost : "; std::cin >> flat.cost;
                    base.push_back(flat);
            }
            void printBase()
            {
                for(std::vector<Flat>::const_iterator it = base.begin(); it != base.end(); ++it)
                {
                    std::cout << "total area  : " << it->totalArea << std::endl;
                    std::cout << "living area : " << it->livingArea << std::endl;
                    std::cout << "kitchen area : " << it->kitArea << std::endl;
                    if(it->loggia)
                        std::cout << "loggia : " << "yes" << std::endl;
                    else
                        std::cout << "loggia : " << "no" << std::endl;
                    if(it->typeHouse == BRICK)  
                        std::cout << "type house : " << "brick"  << std::endl;
                    else if(it->typeHouse == PANEL) 
                        std::cout << "type house : " << "brick"  << std::endl;
                    else
                        std::cout << "type house : " << "none"  << std::endl;
                    std::cout << "total number floors : " << it->totalNumFloors << std::endl;
                    std::cout << "floor: " << it->floor << std::endl;
                    std::cout << "region : " << it->region << std::endl;
                    std::cout << "cost : " << it->cost << std::endl;
                }
            }
            void save()
            {
                for(int i = 0; i < base.size(); ++i)
                    stream.write(reinterpret_cast<char*>(&base[i]), sizeof(base[i]));   
            }
            void erase(){}
            void findPrint(){}
            ~DataBaseApartament() { stream.close(); }
    
    };
}
 
int main()
{
 
    std::cout << "1. Add new flat." << std::endl;
    std::cout << "2. Print all flats" << std::endl;
    std::cout << "3. Save" << std::endl;
    std::cout << "4. Save and quit" << std::endl;
    
    char select;
    cf::DataBaseApartament apartaments("apartaments.res");
    
    while(std::cin >> select)
    {
        switch(select)
        {
            case '1' : apartaments.addFlat(); break;
            case '2' : apartaments.printBase(); break;
            case '3' : apartaments.save(); break;
            case '4' : apartaments.save(); return 0;
        }
        
        std::cout << "1. Add new flat." << std::endl;
        std::cout << "2. Print all flats" << std::endl;
        std::cout << "3. Save" << std::endl;
        std::cout << "4. Save and quit" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <fstream>
 
enum house_type { PANEL, BRICK, UNKNOWN };
 
class Flat {
public:
    float total_area, living_area, kitchen_area;
    bool loggia;
    house_type type;
    int total_floors, floor;
    std::string region;
    int price;
 
    Flat(float ta, float la, float ka, bool lg, house_type t, int tf, int f, std::string r, int p) :
    total_area(ta), living_area(la), kitchen_area(ka), loggia(lg), type(t), total_floors(tf), floor(f), region(r), price(p) 
    { }
    
    Flat(std::istream& ifs) {
        ifs.read((char *) &total_area, sizeof(total_area));
        ifs.read((char *) &living_area, sizeof(living_area));
        ifs.read((char *) &kitchen_area, sizeof(kitchen_area));
        ifs.read((char *) &loggia, sizeof(loggia));
        ifs.read((char *) &type, sizeof(type));
        ifs.read((char *) &total_floors, sizeof(total_floors));
        ifs.read((char *) &floor, sizeof(floor));
        
        int size;
        ifs.read((char *) &size, sizeof(size));
        char *strbuf = new char[size + 1];
        strbuf[size] = 0;
        ifs.read(strbuf, size);
        
        region = strbuf;
        delete[] strbuf;
        ifs.read((char *) &price, sizeof(price));
    }
    
    void serialize(std::ostream& of) {
        of.write((char *) &total_area, sizeof(total_area));
        of.write((char *) &living_area, sizeof(living_area));
        of.write((char *) &kitchen_area, sizeof(kitchen_area));
        of.write((char *) &loggia, sizeof(loggia));
        of.write((char *) &type, sizeof(type));
        of.write((char *) &total_floors, sizeof(total_floors));
        of.write((char *) &floor, sizeof(floor));
        
        int size = region.size();
        of.write((char *) &size, sizeof(size));
        of.write(region.c_str(), region.size());
        of.write((char *) &price, sizeof(price));
    }
    
    std::string str_type() const {
        switch (type) {
            case BRICK : return "brick"; break;
            case PANEL : return "panel"; break;
            default: return "unknown"; break;
        }
    }
    
    friend std::ostream& operator << (std::ostream&, const Flat&);
};
 
std::ostream& operator << (std::ostream& ofs, const Flat& f) {
    ofs << "Total area: " << f.total_area << ", "
        << "Living area: " << f.living_area << ", "
        << "Kitchen area: " << f.kitchen_area << ", "
        << "Loggia: " << (f.loggia ? "exists" : "not exists") << ", "
        << "Type: " << f.str_type() << ", "
        << "Total floors: " << f.total_floors << ", "
        << "Floor: " << f.floor << ", "
        << "Region: " << f.region << ", "
        << "Costs: " << f.price << ".";
    return ofs;
}
 
class DB_Flat {
    std::vector<Flat> cont;
public:
    DB_Flat() { }
    DB_Flat(std::istream& ifs) {
        int size;
        ifs.read((char *) &size, sizeof(size));
 
        for (int i = 0; i < size; ++i) {
            Flat f(ifs);
            cont.push_back(f);
        }
    }
    
    void serialize(std::ostream& ofs) {
        int size = cont.size();
        ofs.write((char *) &size, sizeof(size));
        for (std::vector<Flat>::iterator i = cont.begin(); i != cont.end(); ++i)
            i->serialize(ofs);
    }
    
    void add(const Flat& f) {
        cont.push_back(f);
    }
    
    void remove(int index) {
        cont.erase(cont.begin() + index);
    }
    
    int count() const {
        return cont.size();
    }
    
    template <class FlatFilter, class Callback>
    void filter(FlatFilter filter, Callback f) {
        int index = 0;
        for (std::vector<Flat>::iterator i = cont.begin(); i != cont.end(); ++i, ++index)
            if (filter(*i)) f(*i, index);
    }
};
 
class ByAreaInRegion {
    std::string region;
    float area;
public:
    ByAreaInRegion(std::string r, int a) : region(r), area(a) { }
    bool operator () (Flat& f) {
        return f.total_area > area && f.region == region;
    }
};
 
class BrickFlatNotHigher {
    int floor;
public:
    BrickFlatNotHigher(int f) : floor(f) { }
    bool operator () (Flat& f) {
        return f.floor <= floor && f.type == BRICK;
    }
};
 
class OneRoomNotMoreExpensive {
    int cost;
public:
    OneRoomNotMoreExpensive(int c) : cost(c) { }
    bool operator () (Flat& f) {
        return f.kitchen_area >= 10 && f.price <= cost;
    }
};
 
class PrintFlat {
public:
    void operator () (Flat& f, int index) {
        std::cout << index << ". " << f << "\n";
    }
};
 
class EveryFlat {
public:
    bool operator () (Flat& f) {
        return true;
    }
};
 
 
 
class ConsoleInterface {
    DB_Flat *db;
public:
    ConsoleInterface(DB_Flat& database) : db(&database) { }
    void show ( ) {
        while (true) {
            std::cout << "\n1. Add new flat\n"
            "2. Print all flats\n"
            "3. Remove an flat by number\n"
            "4. Filter flats\n"
            "5. Save database to file\n"
            "6. Load database from file\n"
            "7. Exit\n"
            "[flats]: >";
            
            int choice;
            std::cin >> choice;
            while (std::cin.get() != '\n');
            
            switch (choice) {
                case 1: add(); break;
                case 2: print(); break;
                case 3: remove(); break;
                case 4: filter(); break;
                case 5: save(); break;
                case 6: load(); break;
                case 7: return; break;
                default: std::cout << "Unknown command"; break;
            }
        }
    }
    
    void add() {
        float ta, la, ka;
        char lg, type;
        int tf, f;
        std::string region;
        int price;
        
        std::cout << "Total area: ";
        std::cin >> ta;
        std::cout << "Living area: ";
        std::cin >> la;
        std::cout << "Kitchen area: ";
        std::cin >> ka;
        
        while (std::cin.get() != '\n');
        std::cout << "Loggia: (y) = Exists, (n) = Not exists: ";
        std::cin >> lg;
        
        while (std::cin.get() != '\n');
        std::cout << "House type: (b) = Brick, (p) = Panel: ";
        std::cin >> type;
        
        std::cout << "Total count of floors in the house: ";
        std::cin >> tf;
        
        std::cout << "Floor: ";
        std::cin >> f;
        
        while (std::cin.get() != '\n');
        std::cout << "Region: ";
        std::getline(std::cin, region);
        
        std::cout << "Price: ";
        std::cin >> price;
        
        bool loggia = lg == 'y' || lg == 'Y';
        house_type tp;
        tp = UNKNOWN;
        if (type == 'b' || type == 'B') tp = BRICK;
        if (type == 'p' || type == 'P') tp = PANEL;
        
        db->add(Flat(ta, la, ka, loggia, tp, tf, f, region, price));
        return;
    }
    void print() {
        std::cout << "\n";
        db->filter(EveryFlat(), PrintFlat());
    }
    void remove() {
        int num;
        std::cin >> num;
        if (num < db->count()) db->remove(num);
        else std::cout << "Wrong number\n";
    }
    void filter() {
        std::cout << "\n1.By area in specified region"
        "\n2.In brick house and not higher than specified floor"
        "\n3.With small kitchen and limited cost\n";
        
        int filt;
        std::cin >> filt;
        
        if (filt == 1) {
            float area;
            std::string r;
            std::cout << "Minimal area: ";
            std::cin >> area;
            
            while (std::cin.get() != '\n');
            std::cout << "Region: ";
            std::getline(std::cin, r);
            std::cout << '\n';
            db->filter(ByAreaInRegion(r, area), PrintFlat());
            return;
        }
        
        if (filt == 2) {
            int floor;
            std::cout << "Maximal floor: ";
            std::cin >> floor;
            std::cout << '\n';
            db->filter(BrickFlatNotHigher(floor), PrintFlat());
            return;
        }
        
        if (filt == 3) {
            int price;
            std::cout << "Maximal price: ";
            std::cin >> price;
            std::cout << '\n';
            db->filter(OneRoomNotMoreExpensive(price), PrintFlat());
            return;
        }
        
        std::cout << "Unknown filter";
        return;
    }
    void save() {
        std::string file;
        std::cout << "Enter file name: ";
        std::getline(std::cin, file);
        
        std::ofstream ofs(file.c_str(), std::ios::binary);
        db->serialize(ofs);
        ofs.close();
        return;
    }
    void load() {
        std::string file;
        std::cout << "Enter file name: ";
        std::getline(std::cin, file);
        std::ifstream ifs(file.c_str(), std::ios::binary);
        *db = DB_Flat(ifs);
        return;
    }
};
int main ( ) {
    DB_Flat db;
    ConsoleInterface ci(db);
    ci.show();
    
    return 0;
}