Работа с абстрактным классом, считывание данных

/*
Создать класс Изготовитель cо следующими полями:
    - торговая марка;
    - страна происхождения.
Создать базовый класс Часы (модель, изготовитель) и дочерние классы:
    - механические часы (продолжительность работы, гарантийный срок);
    - электронные часы (тип батареи, тип экрана);
    - использовать класс Изготовитель как поле класса Часы.
Функции:
    - cчитать из текстового файла данные о разных часах;
    - используя механизм виртуальных функций, в новый файл записать информацию о часах, отсортированных по названию марки;
    - подсчитать количество часов указанного изготовителя с заданным типом батареи;
    - вывести информацию о механических часах с самым большим гарантийным сроком.
 
Пример входных данных:
 
    C4698/4 Candino Switzerland 35 2
    KP-1434M-E Kappa Italy 15 1
    ES-8091-01 Earnshaw England 10 2
    SYG194B Superdry England 20 1
    W0991G7 Guess USA 5 2
    JZ1065-05E Citizen Japan 15 3
    SKW2726 Skagen Denmark 10 5
    P.2.1.5 Putnik Russia 15 1
 
    A-163WA-1 Casio Japan Alkaline FRP
    A-168WEC-3E Casio Japan Lithium Plastic
    T5K335 Timex USA Alkaline Mineral
    SN05 SmartWatch China Lithium Plastic
    SS022663000 Suunto Finland Alkaline Plastic
    47326 StormDigitron England Lithium Mineral
*/
 
#include <iostream>
#include <string>
#include <algorithm>
#include <numeric>
#include <fstream>
#include <sstream>
#include <vector>
 
using namespace std;
 
int check_type(ifstream&);
 
class Producer { //Класс Изготовитель (этот класс используется внутри другого класса Часы (композиция объектов))
 
public:
 
    string t_mark; //Торговая марка
    string c_origin; //Страна происхождения
};
 
class Clock { //Базовый, абстрактный класс Часы
 
protected:
 
    int _clock_type;
    string model; //Модель
    Producer prod; //Изготовитель
 
public:
 
    virtual ~Clock() {}
 
    int clock_type() const { return _clock_type; }//функция для сортировки по типу часов
    virtual string Data_to_string() const = 0; //Виртуальная функция для вывода данных
    virtual string Data_to_sort() const = 0;//Виртуальная функция возвращающая данные для сортировки
    const string& getClockModel() const { return model; } //Геттер (модель)
    const Producer& getProducer() const { return prod; } //Геттер (изготовитель)
};
 
class Mechanical : public Clock { //Класс-наследник (механические часы)
 
private:
 
    int lifetime; //Продолжительность работы
    int w_period; //Гарантийный срок
 
public:
    explicit Mechanical() { _clock_type = 0; }
 
    int getMechanicalClockLifeTime() const; //Геттер (продолжительность работы)
    int getMechanicalClockWarrantyPeriod() const; //Геттер (гарантийный срок)
 
    string Data_to_string() const;
    string Data_to_sort() const;
 
    friend ifstream& operator>>(ifstream &in, Mechanical &obj) {
        if (check_type(in) == 1) {
            in.setstate(ios_base::failbit);
            return in;
        }
 
        in >> obj.model
            >> obj.prod.t_mark
            >> obj.prod.c_origin
            >> obj.lifetime
            >> obj.w_period;
        return in;
    }
};
 
 
class Electronic : public Clock { //Класс-наследник (электронные часы)
 
private:
 
    string battery_t; //Тип батареи
    string display_t; //Тип дисплея
 
public:
    explicit Electronic() { _clock_type = 1; }
 
    string getElectronicClockBatteryType() const; //Геттер (тип батареи)
    string getElectronicClockDisplayType() const; //Геттер (тип экрана)
 
    string Data_to_string() const;
    string Data_to_sort() const;
 
    friend ifstream& operator>>(ifstream &in, Electronic &obj) {
        if (check_type(in) == 0) {
            in.setstate(ios_base::failbit);
            return in;
        }
 
        in >> obj.model
            >> obj.prod.t_mark
            >> obj.prod.c_origin
            >> obj.battery_t
            >> obj.display_t;
        return in;
    }
};
 
ostream& operator<<(ostream &out, const Clock &obj) {//функция вывода в поток
    return out << obj.Data_to_string() << endl;
}
 
class clock_vector {//контейнер для указателей на объекты базового класса
    vector<Clock*> cv;
public:
    void push_back(Clock* c) { cv.push_back(c); }
 
    ~clock_vector() { for (auto i : cv) delete i; }
 
    typedef vector<Clock*>::iterator iterator;
 
    iterator begin() { return cv.begin(); }
    iterator end() { return cv.end(); }
};
 
bool by_trade_mark(const Clock* a, const Clock* b) {//предикат сортировки по торговой марке
    return (a->getProducer()).t_mark < (b->getProducer()).t_mark;
}
 
class by_producer_n_battary_type {//предикат для  подсчета по изготовителю и типу батареи
    Producer prod;
    string b_type;
public:
    by_producer_n_battary_type(const Producer& p, const string& b) : prod(p), b_type(b) {}
    int operator()(int acc, const Clock* clock) const {
        if ((clock->getProducer()).t_mark == prod.t_mark &&
            clock->Data_to_sort() == b_type)
            ++acc;
        return acc;
    }
};
 
struct by_clock_type {//предикат поиска по типу часов
    int c_type;
    bool operator()(const Clock* clock) {
        return clock->clock_type() == c_type;
    }
};
 
Clock* max_w_period(clock_vector& cv) {//поиск механических часов с самым большим гарантийным сроком.
    typedef clock_vector::iterator iterator;
 
    iterator current = cv.begin();
    Clock* result = 0;
    while (true) {
        current = find_if(current, cv.end(), by_clock_type({ 0 }));
        if (current == cv.end()) break;
        if (!result) result = *current;
        else if (result->Data_to_sort() < (*current)->Data_to_sort()) result = *current;
        ++current;
    }
    return result;
}
 
bool read_from_file(const string& fname, clock_vector& cv) {//чтение из файла в контейнер
    ifstream in(fname.c_str());
    if (!in) return 0;
    
    while (in.peek() != EOF) {
        Electronic e;
        Mechanical m;
        in >> e;
        if (in.fail()) {
            in.clear();
            if (!(in >> m)) break;
            cv.push_back(new Mechanical(m));
        }
        else cv.push_back(new Electronic(e));
    }
    in.close();
    return 1;
}
 
void print_vector(clock_vector& cv, ostream& os) {
    for (auto i : cv) os << i->Data_to_string() << endl;
}
 
int main() {
    clock_vector cv;
    if (!read_from_file("clock.txt", cv)) cerr << "file_not_found" << endl;
    else {
        print_vector(cv, cout);
        cout << endl;
 
        sort(cv.begin(), cv.end(), by_trade_mark);
        cout << "Sorted by TM:" << endl;
        print_vector(cv, cout);
        cout << endl;
 
        cout << "Count of Casio Alkaline: "
            << accumulate(cv.begin(), cv.end(), 0, by_producer_n_battary_type({ "Casio","" }, "Alkaline"))
            << endl << endl;
 
        Clock* max = max_w_period(cv);
        if (max) cout << "Max warranty period: " << max->Data_to_string() << endl;
 
    }
    system("pause");
    return 0;
}
 
int check_type(ifstream& is) {
    string str;
    int val;
 
    streampos pos = is.tellg();
    if (is.peek() == '\n') is.get();
    getline(is, str);
    is.seekg(pos);
 
    stringstream ss(str);
    if (ss >> str >> str >> str >> val >> val) return 0;
    return 1;
}
 
//Геттеры (механические часы):
 
int Mechanical::getMechanicalClockLifeTime() const { //Продолжительность работы (механические часы) 
    return lifetime;
}
 
int Mechanical::getMechanicalClockWarrantyPeriod() const { //Гарантийный срок (механические часы)
    return w_period;
}
 
string Mechanical::Data_to_string() const
{
    stringstream ss;
    ss << model << ' '
        << prod.t_mark << ' '
        << prod.c_origin << ' '
        << lifetime << ' '
        << w_period;
    return ss.str();
}
 
string Mechanical::Data_to_sort() const
{
    return to_string(w_period);
}
 
//Геттеры (электронные часы):
 
string Electronic::getElectronicClockBatteryType() const { //Тип батареи (электронные часы) 
    return battery_t;
}
 
string Electronic::getElectronicClockDisplayType() const { //Тип экрана (электронные часы)
    return display_t;
}
 
string Electronic::Data_to_string() const
{
    stringstream ss;
    ss << model << ' '
        << prod.t_mark << ' '
        << prod.c_origin << ' '
        << battery_t << ' '
        << display_t;
    return ss.str();
}
 
string Electronic::Data_to_sort() const
{
    return battery_t;
}