Можно ли при чтении из файла элементов в список удалять эти элементы(без очистки файла)

template <typename T>
int List<T>::LoadList1(const char* s)
{
    std::ifstream f("Phones.txt");
    if(!f.is_open())                                                 
    {                                                       
        std::cout << "------------------------------------------------------------------------------------------------------------------------" << std::endl;
        std::cout << " Ошибка открытия файла!" << std::endl;
        return 0;                                            
    }
    int Count;
    f >> Count;
    std::cout << Count;
    for(int i = 0; i < Count; i++)
        {
            char Identificator[25];
            char PhoneName[30];
            char PhoneFabricator[20];
            char PhoneColor[20];
            float PhoneWeight;
            int PhoneNumberOfSIMCards;
            float PhoneScreenDiagonal;
            char PhoneTouchScreen[12];
            char PhoneTypeOfShell[20];
            f >> Identificator;
            if ((strcmp(Identificator,s)==0))
            //if (strspn(Identificator,s)==strlen(Identificator))
                {
                    f >> PhoneName;
                    f >> PhoneFabricator;
                    f >> PhoneColor;
                    f >> PhoneWeight;
                    f >> PhoneNumberOfSIMCards;
                    f >> PhoneScreenDiagonal;
                    f >> PhoneTouchScreen;
                    f >> PhoneTypeOfShell;
                    auto cell = new Cell (PhoneFabricator,PhoneName,PhoneColor,PhoneWeight,PhoneNumberOfSIMCards,PhoneScreenDiagonal,PhoneTouchScreen,PhoneTypeOfShell);
                    push_back(*cell);//T*
                    free(cell);
                }
        }
    f.close();
    return 1;
}

//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   Конструктор копирования
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
List<T>::List(const List<T>& src):
head(NULL), tail(NULL), count(0)                                        // Изначально новый список пустой
{
    Node<T>* current = src.head;                                        // Создаём current и присваиваем
                                                                        // ей новое начало списка
    while (current != NULL)                                             // Выполняем цикл,пока current равна NULL
    {
        this->push_back(current->data);                                 // Добавляем элемент в конец этого списка
        current = current->next;                                        // и перемещаем current вперёд на один элемент
    }
 
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   Деструктор
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
List<T>::~List()
{
    clear();                                                            // Вызов метода очистки списка
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   Очистка списка
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
void List<T>::clear()
{
    while (! this->empty())                                             // Пока список не пустой,
    {
        this->pop_front();                                              // удаляем элементы с начала
    }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   Добавить элемент в начало
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
void List<T>::push_front(T d)
{
    Node<T>* new_head = new Node<T>(d, head);
    if (this->empty())                                                  // Если список пуст,то новый элемент
    {                                                                   // станет и началом, и концом списка
        head = new_head;
        tail = new_head;
    }
    else                                                                // Иначе добавляем элемент в начало списка
    {
        head = new_head;
    }
    count++;                                                            // Смещаемся вперёд
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   Добавить элемент в конец
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
void List<T>::push_back(T d)
{
    Node<T>* new_tail = new Node<T>(d, NULL);                           // Выделяем динамическую память
                                                                        // для пового конца списка
    if (this->empty())                                                  // Если список пуст,то новый элемент
    {                                                                   // станет началом списка
        head = new_tail;
    }
    else
    {
        tail->next = new_tail;                                          // Иначе добавляем элемент в конец списка
    }
    tail = new_tail;                                                    // и смещаем конец списка
    count++;                                                            // Смещаемся вперёд
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   Удалить элемент из начала
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
void List<T>::pop_front()
{
    assert(head != NULL);                                               // Если конец списка равен NULL,
                                                                        // функция assert немедленно завершает метод
    Node<T>* old_head = head;                                           // Резервируем место для текущего начала списка
    if (this->size() == 1)                                              // Если в списке один элемент, то
    {                                                                   // очищаем его
        head = NULL;
        tail = NULL;
    }
    else                                                                // Иначе смещаем начало списка
    {
            head = head->next;                                          // на один элемент вперёд
    }
    delete old_head;                                                    // и удаляем оставшийся позади элемент
    count--;                                                            // Смещаемся назад
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   Удалить элемент из конца
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
void List<T>::pop_back(void)
{
    assert(tail != NULL);                                               // Если конец списка равен NULL,
                                                                        // функция assert немедленно завершает метод
    Node<T>* old_tail = tail;
    if (this->size() == 1)                                              // Если в списке один элемент, то
    {                                                                   // очищаем его
        head = NULL;
        tail = NULL;
    }
    else                                                                // Иначе перемещаемся в конец списка
    {                                                                   // с помощью current
        Node<T>* current = head;                                        // Для начала приравниваем её к началу списка,
        while (current->next != tail)                                   // затем выполняем цикл, пока не дошли до конца:
        {
            current = current->next;                                    // Смещаем current вперёд на один элемент
        }                                                               // Когда доходим до конца,
        current->next = NULL;                                           // смещаемся ещё на один элемент
                                                                        // и приравниваем этот элемент к NULL
        tail = current;                                                 // Затем приравниваем концу списка
    }                                                                   // currect, которая равна NULL
    delete old_tail;                                                    // Очищаем старый конец списка
    count--;                                                            // Смещаемся назад
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   Распечатать список
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
void List<T>::PrintList(void)
{
    Node<T>* current = head;                                            // Создаём новую переменную
                                                                        // и приравниваем к ней начало списка
    if (current != NULL)                                                // Если список не пустой,
    {
        while (current!= NULL)                                          // То выполняем цикл до тех пор,
        {                                                               // пока список не пустой:
            std::cout << current->data;                                 // выводим элемент списка и
            current = current->next;                                    // смещаемся на один элемент вперёд
        }
    }
    else std::cout << " Список пуст!" << std::endl;
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   Сохранить список в файл
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
void List<T>::SaveList()
{
    std::ifstream f1;
    f1.open("Phones.txt",std::ios::out);
    int Count;
    f1 >> Count;
    Count = Count + count;
    f1.close();
    std::ofstream f;
    f.open("Phones.txt",std::ios::app);
    f << Count << std::endl;
    f.close();
    Node<T>* current = head;
    if (current != NULL)
    {
        while (current!= NULL)
        {
            current->data.Save();
            current = current->next;
        }
    }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//   ЗАгрузить список из файла
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
int List<T>::LoadList1(const char* s)
{
    std::ifstream f("Phones.txt");
    if(!f.is_open())                                                    // Если файл не открывается, то
    {                                                                   // информируем об этом
        std::cout << "------------------------------------------------------------------------------------------------------------------------" << std::endl;
        std::cout << " Ошибка открытия файла!" << std::endl;
        return 0;                                                       // и возвращаем 0
    }
    int Count;
    f >> Count;
    std::cout << Count;
    for(int i = 0; i < Count; i++)
        {
            char Identificator[25];
            char PhoneName[30];
            char PhoneFabricator[20];
            char PhoneColor[20];
            float PhoneWeight;
            int PhoneNumberOfSIMCards;
            float PhoneScreenDiagonal;
            char PhoneTouchScreen[12];
            char PhoneTypeOfShell[20];
            f >> Identificator;
            if ((strcmp(Identificator,s)==0))
            //if (strspn(Identificator,s)==strlen(Identificator))
                {
                    f >> PhoneName;
                    f >> PhoneFabricator;
                    f >> PhoneColor;
                    f >> PhoneWeight;
                    f >> PhoneNumberOfSIMCards;
                    f >> PhoneScreenDiagonal;
                    f >> PhoneTouchScreen;
                    f >> PhoneTypeOfShell;
                    auto cell = new Cell (PhoneFabricator,PhoneName,PhoneColor,PhoneWeight,PhoneNumberOfSIMCards,PhoneScreenDiagonal,PhoneTouchScreen,PhoneTypeOfShell);
                    push_back(*cell);//T*
                    free(cell);
                }
        }
    f.close();
    return 1;
}
template <typename T>
int List<T>::LoadList2(const char* s)
{
    std::ifstream f("Phones.txt");
    if(!f.is_open())                                                    // Если файл не открывается, то
    {                                                                   // информируем об этом
        std::cout << "------------------------------------------------------------------------------------------------------------------------" << std::endl;
        std::cout << " Ошибка открытия файла!" << std::endl;
        return 0;                                                       // и возвращаем 0
    }
    int Count;
    f >> Count;
    std::cout << Count;
    for(int i = 0; i < Count; i++)
        {
            char Identificator[25];
            char PhoneName[30];
            char PhoneFabricator[20];
            char PhoneColor[20];
            float PhoneWeight;
            int PhoneNumberOfSIMCards;
            float PhoneScreenDiagonal;
            int PhoneROM;
            int PhoneRAM;
            f >> Identificator;
            if ((strcmp(Identificator,s)==0))
            //if (strspn(Identificator,s)==strlen(Identificator))
                {
                    f >> PhoneName >> PhoneFabricator >> PhoneColor >> PhoneWeight >> PhoneNumberOfSIMCards >> PhoneScreenDiagonal >> PhoneROM >> PhoneRAM;
                    auto smart = new Smartphones (PhoneName,PhoneFabricator,PhoneColor,PhoneWeight,PhoneNumberOfSIMCards,PhoneScreenDiagonal,PhoneROM,PhoneRAM);
                    push_back(*smart);//T*
                }
        }
    f.close();
    return 1;
}
template <typename T>
int List<T>::LoadList3(const char* s)
{
    std::ifstream f("Phones.txt");
    if(!f.is_open())                                                    // Если файл не открывается, то
    {                                                                   // информируем об этом
        std::cout << "------------------------------------------------------------------------------------------------------------------------" << std::endl;
        std::cout << " Ошибка открытия файла!" << std::endl;
        return 0;                                                       // и возвращаем 0
    }
    int Count;
    f >> Count;
    std::cout << Count;
    for(int i = 0; i < Count; i++)
        {
            char Identificator[25];
            char PhoneName[30];
            char PhoneFabricator[20];
            char PhoneColor[20];
            float PhoneWeight;
            char PhoneCallerID[12];
            char PhoneBuiltInNotebook[15];
            char PhoneMaterial[25];
            int PhoneRangeOfAction;
            f >> Identificator;
            if ((strcmp(Identificator,s)==0))
            //if (strspn(Identificator,s)==strlen(Identificator))
                {
                    f >> PhoneName >> PhoneFabricator >> PhoneColor >> PhoneWeight >> PhoneCallerID >> PhoneBuiltInNotebook >> PhoneMaterial >> PhoneRangeOfAction;
                    auto cordless = new Cordlessphones (PhoneName,PhoneFabricator,PhoneColor,PhoneWeight,PhoneCallerID,PhoneBuiltInNotebook,PhoneMaterial,PhoneRangeOfAction);
                    push_back(*cordless);//T*
                }
        }
    f.close();
    return 1;
}
template <typename T>
int List<T>::LoadList4(const char* s)
{
    std::ifstream f("Phones.txt");
    if(!f.is_open())                                                    // Если файл не открывается, то
    {                                                                   // информируем об этом
        std::cout << "------------------------------------------------------------------------------------------------------------------------" << std::endl;
        std::cout << " Ошибка открытия файла!" << std::endl;
        return 0;                                                       // и возвращаем 0
    }
    int Count;
    f >> Count;
    std::cout << Count;
    for(int i = 0; i < Count; i++)
        {
            char Identificator[25];
            char PhoneName[30];
            char PhoneFabricator[20];
            char PhoneColor[20];
            float PhoneWeight;
            char PhoneCallerID[12];
            char PhoneBuiltInNotebook[15];
            char PhoneDisplay[15];
            int PhoneLineInput;
            f >> Identificator;
            if ((strcmp(Identificator,s)==0))
            //if (strspn(Identificator,s)==strlen(Identificator))
                {
                    f >> PhoneName >> PhoneFabricator >> PhoneColor >> PhoneWeight >> PhoneCallerID >> PhoneBuiltInNotebook >> PhoneDisplay >> PhoneLineInput;
                    auto wire = new Wired (PhoneName,PhoneFabricator,PhoneColor,PhoneWeight,PhoneCallerID,PhoneBuiltInNotebook,PhoneDisplay,PhoneLineInput);
                    push_back(*wire);//T*
                }
        }
    f.close();
    return 1;
}
}

template <typename T> class List;                           // Определяем дружественные классы для итераторов
template <typename T> class Iterator;                       // по соответствующим контейнерным классам
 
 
template <typename T>
class Node                                                  // Создаём класс для определения типов данных
    {                                                       // и переменной смещения
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
        friend class List<T>;                               // Задаём дружественность классам
        friend class Iterator <T>;                          // итератора и списка
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    private:
        T data;                                             // Задаём тип данных списка
        Node* next;                                         // задаём переменную смещения
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    public:
        Node(T d, Node* n = NULL) : data(d), next(n) {}     // Задаём их начальное значение через конструктор
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    };
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
class List                                                  // Создаём класс списка
{
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
private:
    Node<T>* head;                                          // Задаём начало списка
    Node<T>* tail;                                          // Задаём конец списка
    int count;                                              // Задаём переменную для нумерации элементов списка
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public:
    typedef Iterator<T> iterator;                           // Задаём синоним для для типа данных
 
    List(const List<T>& src);                               // Конструктор копирования
    ~List();                                                // Деструктор
    void clear();                                           // Очистка списка
    List() : head(NULL), tail(NULL), count(0) {}            // Конструктор
 
    int size() {return count;}                              // Возвращает переменную count
    bool empty() {return count == 0;}                       // Возвращает true,если count равен 0
 
    void push_front(T);                                     // Добавить элемент в начало
    void push_back(T);                                      // Добавить элемент в конец
 
    void pop_front();                                       // Удалить элемент из начала
    void pop_back();                                        // Удалить элемент из конца
 
    void SaveList();                                        // Сохранить список в файл
    int LoadList(const char* s);                            // Загрузка списка из файла
 
    int LoadList1(const char* s);                            // Загрузка списка из файла
    int LoadList2(const char* s);                            // Загрузка списка из файла
    int LoadList3(const char* s);                            // Загрузка списка из файла
    int LoadList4(const char* s);                            // Загрузка списка из файла
 
    void PrintList();                                       // Распечатать список
 
    Iterator<T> begin()                                     // Перемещаем итератор в начало списка
    {
        return Iterator<T>(head);
    }
    Iterator<T> end()                                       // Перемещаем итератор в конец списка
    {
        return Iterator<T>(tail);
    }
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
};
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename T>
class Iterator                                              // Создаём класс итератора
{
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
private:
    Node<T> *target;                                        // Задаём элемент итератора для работы со списком
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public:
    Iterator() {}                                           // Конструктор
    Iterator(Node<T> *target) : target(target) {}           // Задаём начальное значение target
 
    T& operator*()                                          // Перегружаем оператор непрямого обращения
        {
            return target->data;
        }
    T* operator->()                                         // Перегружаем оператор обращения к члену структуры
        {
            return &target->data;
        }
    Iterator& operator++()                                  // Перегружаем оператор инкремент(префиксный)
    {
        target = target->next;
        return *this;
    }
    Iterator operator++(int)                                // Перегружаем оператор инкремент(постфиксный)
    {
        target = target->next;
        return *this;
    }
    bool operator==(Iterator const& r)                      // Перегружаем оператор равенста
        {
            return (target == r.target);
        }
    bool operator!=(Iterator const& r)                      // Перегружаем оператор неравенства
        {
            return (target != r.target);
        }
/*----------------------------------------------------------------------------*/
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
};

#include <iostream>
 
using namespace std;
 
class Phone {
public:
    Phone() { /* инициализация*/ }
 
    virtual bool write(ostream &os) const {
        os.write(Identificator, sizeof(Identificator));
        os.write(PhoneName, sizeof(PhoneName));
        os.write(PhoneFabricator, sizeof(PhoneFabricator));
        os.write(PhoneColor, sizeof(PhoneColor));
        os.write((const char *)&PhoneWeight, sizeof(PhoneWeight));
        return os.good();
    }
 
    virtual bool read(istream &is) {
        is.read(Identificator, sizeof(Identificator));
        is.read(PhoneName, sizeof(PhoneName));
        is.read(PhoneFabricator, sizeof(PhoneFabricator));
        is.read(PhoneColor, sizeof(PhoneColor));
        is.read((char *)&PhoneWeight, sizeof(PhoneWeight));
        return is.good();
    }
 
    virtual ostream& print(ostream &os) const {
        return os
            << Identificator << endl
            << PhoneName << endl
            << PhoneFabricator << endl
            << PhoneColor << endl
            << PhoneWeight << endl;
    }
 
protected:
    char Identificator[25];
    char PhoneName[30];
    char PhoneFabricator[20];
    char PhoneColor[20];
    float PhoneWeight;
};
 
class Mobile : public Phone {
public:
    Mobile() { /* инициализация*/ }
 
    virtual bool write(ostream &os) const override {
        Phone::write(os);
        os.write((const char *)&PhoneNumberOfSIMCards, sizeof(PhoneNumberOfSIMCards));
        os.write((const char *)&PhoneScreenDiagonal, sizeof(PhoneScreenDiagonal));
        return os.good();
    }
 
    virtual bool read(istream &is) override {
        Phone::read(is);
        is.read((char *)&PhoneNumberOfSIMCards, sizeof(PhoneNumberOfSIMCards));
        is.read((char *)&PhoneScreenDiagonal, sizeof(PhoneScreenDiagonal));
        return is.good();
    }
 
    virtual ostream& print(ostream &os) const override {
        Phone::print(os);
        return os
            << PhoneNumberOfSIMCards << endl
            << PhoneScreenDiagonal << endl;
    }
 
protected:
    int PhoneNumberOfSIMCards;
    float PhoneScreenDiagonal;
};
 
class Stationary : public Phone {
public:
    Stationary();
    virtual bool write(ostream &os) const override;
    virtual bool read(istream &is) override;
    virtual ostream& print(ostream &os) const override;
protected:
    char PhoneCallerID[12];
    char PhoneBuiltInNotebook[15];
 
};
 
class Cell : public Mobile {
public:
    Cell();
    virtual bool write(ostream &os) const override;
    virtual bool read(istream &is) override;
    virtual ostream& print(ostream &os) const override;
private:
    char PhoneTouchScreen[12];
    char PhoneTypeOfShell[20];
};
 
class Smartphone : public Mobile {
public:
    Smartphone();
    virtual bool write(ostream &os) const override;
    virtual bool read(istream &is) override;
    virtual ostream& print(ostream &os) const override;
private:
    int PhoneROM;
    int PhoneRAM;
};
 
class Cordlessphone : public Stationary {
public:
    Cordlessphone();
    virtual bool write(ostream &os) const override;
    virtual bool read(istream &is) override;
    virtual ostream& print(ostream &os) const override;
private:
    char PhoneMaterial[25];
    int PhoneRangeOfAction;
};
 
class Wired : public Stationary {
public:
    Wired();
    virtual bool write(ostream &os) const override;
    virtual bool read(istream &is) override;
    virtual ostream& print(ostream &os) const override;
private:
    char PhoneDisplay[15];
    int PhoneLineInput;
};