Класс PriceList. Разработать программу формирования и распечатки прайс-листов

#include <vector>
#include <string>
#include <iostream>
using namespace std;    
 
class Pricelist
    {
    private:
        vector<Model> list;
    public:
        void add_model();
        int find_model(string type);
        int find_model(int memory_size);
        void change_model(string type);
        void change_model(int memory_size);
        void delete_model(stirng type);
        void delete_model(int memory_size);
    };
    
void Pricelist::add_model()
    {
    cout << "Enter all parameters: " << endl;
    cout << "CPU Type: ";
    string type;
    cin >> type;
    int CPU_frequency, int memory_size; //и т.д.
    cout << "CPU Frequency: ";
    cin >> CPU_frequency;
    cout << "Memory size: ";
    cin >> memory_size;
    
    Model * add = new Model(type, CPU_frequency, memory_size /* и т.д. */);
    list.push_back(add);
    }
    
int Pricelist::find_model(string type)
    {
    bool find = false;
    for (int i = 0; i<list.size(); i++)
        {
        if (list[i]->CPU_type == type)
            {
            cout << *list[i] << endl;
            find = true;
            break;
            }
        }
    if (!find)
        {
        cout << "Error. There's no model with this CPU_type" << endl;
        return -1;
        }
    return i;
    }
    
void Pricelist::change_model(string type)
    {
    int index = find_model(type);
    string new_type;
    cout "Enter new type: ";
    cin >> new_type;
    list[index]->CPU_type = new_type;
    }
    
void Pricelist::delete_model(string type)
    {
    int index = find_model(type);
    list.erase(index);
    }

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
 
class Model{
 public:
     Model ();
    Model(std::string _CPU_type = "Cpu", size_t _CPU_frequency=0,size_t _memory_size=0,
        size_t _harddisk_memory=0, size_t _graphics_memory=0, size_t _price=0, size_t _number=0)
        : CPU_type(_CPU_type), CPU_frequency(_CPU_frequency),
        memory_size(_memory_size), harddisk_memory(_harddisk_memory),
        graphics_memory(_graphics_memory), price(_price), number(_number)  {};
        ~Model() {};
 public:
  std::string CPU_type;
  size_t CPU_frequency;
  size_t memory_size;
  size_t harddisk_memory;
  size_t graphics_memory;
  size_t price;
  size_t number;
 
};
 
    std::ostream &operator<<(std::ostream &out, const Model &Model) {
        out <<"CPU:"<< Model.CPU_type << ", frequency: " << Model.CPU_frequency<<
        ", size memory: " << Model.memory_size<<"," << std::endl<<"Hard Disk memory:"<< Model.harddisk_memory
        <<", Graphics memory:" << Model.graphics_memory<< ", Price:"<< Model.price<< " rub, Number:"
        << Model.number;
    return out;
}
 
int main(int argc, char *argv[]) {
 
    Model m1("Intel", 1000,164, 2000, 65, 68000,7);
    std::cout << "Model: "<<std::endl << m1 << std::endl;
  return 0;
};

class Pricelist
    {
    private:
        vector<Model *> list;
        //Date date; (смотрите сами, как будете писать дату)
        int nominal;
    public:
        Model* add_model();
        Model* find_type(string type);
        Model* find_memory(int memory_size);
        Model* find_harddrive(int hard);
        Model* find_graphic(int graphic);
        void change_model(Model * m);
        void delete_model(Model * m);
        friend Pricelist* unite(Pricelist* first, Pricelist* second); //метод для пересечения листов
        friend Pricelist* operator+(Pricelist* first, Pricelist* second); //метод для объединения листов
    };
    
Model* Pricelist::add_model(Model * model)
    {
    //создавать модель будете в главной программе
    list.push_back(model);
    }
Model* Pricelist::find_type(string type)
    {
    for (int i=0; i<list.size(); i++)
        {
        if (list[i]->CPU_type == CPU_type)
            return list[i];
        }
    return 0;
    }
Model* Pricelist::find_memory(int memory_size)
    {
    for (int i=0; i<list.size(); i++)
        {
        if (list[i]->memory_size >= memory_size)
            return list[i];
        }
    return 0;
    }
Model* Pricelist::find_harddrive(int hard)
    {
    for (int i=0; i<list.size(); i++)
        {
        if (list[i]->harddisk_memory >= harddisk_memory)
            return list[i];
        }
    return 0;
    }
Model* Pricelist::find_graphic(int graphic)
    {
    for (int i=0; i<list.size(); i++)
        {
        if (list[i]->mgraphics_memory >= graphics)
            return list[i];
        }
    return 0;
    }
void Pricelist::change_model(Model * m)
    {
    Model * ptr = find_type(m->CPU_type);
    //меняете модель
    }
void Pricelist::delete_model(Model * m)
    {
    for (int i=0; i<list.size(); i++)
        if (list[i]->CPU_type = m->CPU_type)
            {
            delete list[i];
            list.erase(i); 
            return;
            }
    }
Pricelist* unite(Pricelist * first, Pricelist * second)
    {
    Pricelist * ptr = new Pricelist();
    for (int i=0; i<first->list.size(); i++)
        for (int j=0; j<second->list.size(); j++)
            if ((first->list[i])->CPU_type == (second->list[j])->CPU_type)
                {
                Model * n = new Model(*first->list[i]);
                ptr->add_model(n);
                }
    return ptr;
    }
Pricelist* operator+(Pricelist * first, Pricelist * second)
    {
    Pricelist * ptr = unite(first, second);
    for (int i=0; i<first->size(); i++)
        {
        bool good = true;
        for (int j=0; j<ptr->size(); j++)
            if ((first->list[i])->CPU_type == (ptr->list[j])->CPU_type)
                good = false;
        if (good)
            {
            Model * n = new Model(*first->list[i]);
            ptr->add_model(n);
            }
        }
    for (int i=0; i<second->size(); i++)
        {
        bool good = true;
        for (int j=0; j<ptr->size(); j++)
            if ((second->list[i])->CPU_type == (ptr->list[j])->CPU_type)
                good = false;
        if (good)
            {
            Model * n = new Model(*second->list[i]);
            ptr->add_model(n);
            }
        }       
    return ptr;
    }