Создать класс "Электронное Устройство"

#include <iostream>
#include <cstring>
#include <string>
#include <conio.h>
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include <queue>
#include <algorithm>
#include <locale>
#include <ctime>
#include <Windows.h>
#include <string.h>
#include <stdlib.h>
#pragma warning (disable: 4996)
using namespace std;
class device
{
protected:
    int interfase;
    int power;
    int weight;
public:
    device(int interfase, int power, int weight)
    {
        this->interfase = interfase;
        this->power = power;
        this->weight = weight;
    }
    virtual void interffase(int x)
    {
        char s[10], st[20] = "Interfase ";
        itoa(x, s, 10);
        strcat(st, s);
        system(st);
    }
    device()
    {
        interfase = 0;
        power = 0;
        weight = 0;
    }
    device(device& d)
    {
        interfase = d.interfase;
        power = d.power;
        weight = d.weight;
    }
    ostream& operator<<(ostream& os)
    {
        os << interfase << power << weight;
        return os;
    }
    istream& operator>>(istream& is)
    {
        is >> interfase >> power >> weight;
        return is;
    }
    device& operator = (device& obj)
    {
        interfase = obj.interfase;
        power = obj.power;
        weight = obj.weight;
        return *this;
    }
    ~device();
 
private:
 
};
 
class Menu
{
protected:
    int count;
    int active;
    char** command;
public:
    Menu(int count, int active, char**command)
    {
        this->count = count;
        this->active = active;
        this->command = new char*[count];
        for (int i = 0; i < count; i++)
        {
            this->command[i] = new char[20];
            strcpy_s(this->command[i], 20, command[i]);
        }
    }
    Menu()
    {
        count = 0;
        active = 0;
        command = NULL;
    }
    Menu(Menu& m)
    {
        count = m.count;
        active = m.active;
        command = new char*[m.count];
        for (int i=0; i < count;i++)
        {
            command[i] = new char[20];
            strcpy_s(command[i], 20, m.command[i]);
        }
    }
    ~Menu()
    {
        for (int i = 0; i < count; i++)
        {
            delete[]command;
        }
    }
    friend istream& operator>>(istream& is, Menu& m)
    {
        for (int i = 0; i < m.count; i++)
        {
            is >> m.command[i];
        }
        return is;
    }
    friend ostream& operator<<(ostream& os, Menu& m)
    {
        for (int i = 0; i < m.count; i++)
        {
            os << m.command[i] << endl;
        }
        return os;
    }
};
 
class Info :public device, public Menu
{
protected:
    int diagonal;
    int rozdil;
    char *info;
public:
    Info(char* info, int diagonal, int rozdil, device d, Menu m) :device(d), Menu(m)
    {
        this->diagonal = diagonal;
        this->rozdil = rozdil;
        this->info = new char[100];
        strcpy_s(this->info, 100, info);
    }
    Info(const Info& i)
    {
        //device
        interfase = i.interfase;
        power = i.power;
        weight = i.weight;
        //Menu
        count = i.count;
        active = i.active;
        command = new char*[i.count];
        for (int i = 0; i < count; i++)
        {
            command[i] = new char[20];
            strcpy_s(command[i], 20, command[i]);
        }
        // Info
        diagonal = i.diagonal;
        rozdil = i.rozdil;
        info = i.info;
    }
    ~Info()
    {
        delete[] info;
    }
    Info() :device(), Menu()
    {
        diagonal = 0;
        rozdil = 0;
        info = NULL;
    }
    friend istream& operator>>(istream& is, Info&i)
    {
        is >> i.interfase >> i.power >> i.weight;
        for (int i = 0; i < i.count; i++)
        {
            is >> i.command[i];
        }
        is >> i.info;
        return is;
    }
    friend ostream& operator<<(ostream& os, Info& i)
    {
        os << i.info << ' ';
        os << i.diagonal;
        os << i.rozdil;
        return os;
    }
    void set()
    {
        cin.ignore();
    }
    char* getname()
    {
        return info;
    }
    int get_diagonal()
    {
        return diagonal;
    }
    int get_rozdil()
    {
        return rozdil;
    }
    Info set(ifstream& f)
    {
        char str[100] = "";
        char*ptr;
        f.getline(info, 50);
        ptr = strtok(str, "\t");
        if (ptr)
        {
            strcpy(info, ptr);
        }
        ptr = strtok(str, NULL);
        if (ptr)
        {
            interffase(atoi(ptr));
        }
        return Info();
    }
    void print(ofstream&f)
    {
        f << info << '\n';
        f << diagonal << '\n';
        f << rozdil << '\n';
    }
    void print()
    {
        Info();
    }
};
 
class Queue
{
protected:
    queue<Info> q;
public:
    void Print();
    void Load();
    void Save();
    void Add();
    void Edit();
    void Del();
    void Find();
};
 
void Queue::Print()
{
    int i = 0;
    cout << "# Пристрій \n";
    cout << "-------------------------------------------------------------------\n";
    int n = q.size();
    queue <Info> t = q;
    while (!t.empty())
    {
        cout << ++i;
        t.front().print();
        t.pop();
    }
}
 
void Queue::Save()
{
    ofstream f("text.txt", ios::out);
    f << q.size() << '\n';
    queue<Info> t = q;
    while (!t.empty())
    {
        t.front().print(f);
        t.pop();
    }
    f.close();
}
 
void Queue::Add()
{
    Info dd;
    dd.set();
    q.push(dd);
}
 
void Queue::Edit()
{
    int i = 0, n;
    Print();
    cout << "Введите номер редактируемоо элемента > ";
    cin >> n;
    if (n < 1 || n > q.size())
    {
        fprintf(stderr, "Элемент с номером %d не существует\n", n); return;
    }
    n--;
    queue<Info> f, f2;
    Info dd;
    while (i < n)
    {
        f.push(q.front());
        q.pop();
        i++;
        //f.back().print();
    }
 
    dd = q.front();
    q.pop();
    dd.set();
 
    while (!q.empty())
    {
        f2.push(q.front());
        q.pop();
    }
 
    while (!f.empty())
    {
        q.push(f.front());
        f.pop();
    }
    q.push(dd);
 
    while (!f2.empty())
    {
        q.push(f2.front());
        f2.pop();
    }
}
void Queue::Del()//vector <osoba> &os)
{
    int i = 0, n;
    Print();
    cout << "Введите номер удаляемоо элемента > ";
    cin >> n;
    if (n < 1 || n > q.size())
    {
        fprintf(stderr, "Элемент с номером %d не существует\n", n); return;
    }
    n--;
    queue<Info> f, f2;
    while (i < n)
    {
        f.push(q.front());
        q.pop();
        i++;
        //f.back().print();
    }
 
    q.pop();
 
    while (!q.empty())
    {
        f2.push(q.front());
        q.pop();
    }
 
    while (!f.empty())
    {
        q.push(f.front());
        f.pop();
    }
 
    while (!f2.empty())
    {
        q.push(f2.front());
        f2.pop();
    }
}
void Queue::Find()
{
    int i = 0;
    char str[50];
    Print();
    cout << "Введите Фамилию> ";
    cin >> str;
    queue<Info> f = q;
 
    while (!f.empty())
    {
        if (strstr(f.front().getname(), str))
        {
            f.front().print(); i++;
        }
        f.pop();
 
        if (i == 0) cout << "Нет записей удовлетворяющих условие!" << endl;
    }
}
int men(void) {
    int c = 0;
    struct tm* t;
    time_t ltime;
    time(&ltime);
    t = localtime(&ltime);
    cout << '\n' << t->tm_mday << '/' << t->tm_mon + 1 << '/' << 1990 + t->tm_year << endl;
 
    while ((c < '0' || c >9) && c != 21)
    {
        printf("\n>>>>>Menu<<<<<\n");
        printf("----------------\n");
        printf("[0] - Exit\n[1] - Add\n[2] - Save\n[3] - Load\n[4] - Print\n[5] - Find\n[6] - Del\n[7] - Edit\n");
        printf("----------------\n");
        printf("---->");
        c = getch();
        printf("%c\n", c);
    }
    return c;
}
 
 
void main()
{
    Queue os;
    int k;
    SetConsoleOutputCP(1251);
    char command[][6] = { "Add", "Save", "Load", "Print", "Find", "Del","Edit" };
    while ((k = men()) != 0 && k != 20)
        switch (k)
        {
        case'1': os.Add(); break;
        case'2': os.Save(); break;
        case'3': os.Load(); break;
        case'4': os.Print(); break;
        case'5': os.Find(); break;
        case'6': os.Del(); break;
        case'7': os.Edit(); break;
        }
 
    /*device f(1, 1, 80, 25, 2);
    cout << "Склад объекта ramka\n" << f;
 
    /*Menu m(7, 0, command);
    cout << "Склад объекта Menu\n" << m;
 
    Info w("MyInfo", f, m);
 
    cout << w << endl;*/
 
    system("pause");
}

#include <iostream>
 
class Device {
public:
    Device(): interface{0}, power{0}, weight{0} {}
    Device(int interface, int power, int weight): interface{interface}, power{power}, weight{weight} {}
 
    // остальные конструкторы и деструкторы -- тривиальные
    Device(const Device &) = default;
    virtual ~Device() = default;
 
    // оператор присваивания тоже в принципе тривиальный можно написать
    // Device &operator=(const Device &) = default;
    Device &operator=(const Device &other) {
        if (this != &other) {
            this->interface = other.interface;
            this->power = other.power;
            this->weight = other.weight;
        }
        return *this;
    }
 
 
    int getInterface() const {
        return interface;
    }
 
    void setInterface(int interface) {
        Device::interface = interface;
    }
 
    // построить полиморфическое кластер на основе виртуального метода для считывания мощности
    virtual int getPower() const {
        return power;
    }
 
    // построить полиморфическое кластер на основе виртуального метода для считывания мощности
    virtual void setPower(int power) {
        Device::power = power;
    }
 
    int getWeight() const {
        return weight;
    }
 
    void setWeight(int weight) {
        Device::weight = weight;
    }
 
private:
    int interface;
    int power;
    int weight;
};
 
 
std::ostream &operator<<(std::ostream &out, const Device &device) {
    return out << "Device{"
        "interface: " << device.getInterface() <<
               ", power: " << device.getPower() <<
               ", weight: " << device.getWeight() <<
               "}";
}
 
std::istream &operator>>(std::istream &in, Device &device) {
    int i, p, w;
    in >> i >> p >> w;
    device.setInterface(i);
    device.setPower(p);
    device.setWeight(w);
    return in;
}
 
class DisplayDevice : public Device {
public:
    DisplayDevice(): Device{}, diagonal{0}, resolution{0}, infofile{} {}
    DisplayDevice(int interface, int power, int weight, int diagonal, int resolution, const std::string &infofile)
        : Device{interface, power, weight}, diagonal{diagonal}, resolution{resolution}, infofile{infofile} {}
 
    // построить полиморфическое кластер на основе виртуального метода для считывания мощности
    int getPower() const override {
        return Device::getPower();
    }
 
    // построить полиморфическое кластер на основе виртуального метода для считывания мощности
    void setPower(int power) override {
        Device::setPower(power);
    }
 
    int getDiagonal() const {
        return diagonal;
    }
 
    void setDiagonal(int diagonal) {
        DisplayDevice::diagonal = diagonal;
    }
 
    int getResolution() const {
        return resolution;
    }
 
    void setResolution(int resolution) {
        DisplayDevice::resolution = resolution;
    }
 
    const std::string &getInfofile() const {
        return infofile;
    }
 
    void setInfofile(const std::string &infofile) {
        DisplayDevice::infofile = infofile;
    }
 
private:
    int diagonal;
    int resolution;
    std::string infofile;
};
 
std::ostream &operator<<(std::ostream &out, const DisplayDevice &device) {
    out << "DisplayDevice{"
        << static_cast<const Device &>(device)
        << ", diagonal: " << device.getDiagonal()
        << ", resolution: " << device.getResolution()
        << ", infofile: '" << device.getInfofile() << "'"
        << "}";
    return out;
}
 
std::istream &operator>>(std::istream &in, DisplayDevice &device) {
    in >> static_cast<Device&>(device);
    int d, r;
    std::string i;
    in >> d >> r >> i;
    device.setDiagonal(d);
    device.setResolution(r);
    device.setInfofile(i);
    return in;
}
 
DisplayDevice &operator<<(DisplayDevice &d, const std::string &advertisement) {
    std::cout << d << ": '" << advertisement << "'" << std::endl;
    return d;
}
 
class Advertisement {
public:
 
    // Для работы с массивом объектов построить и использовать класс итератор.
    using Iterator = DisplayDevice*;
    using ConstIterator = DisplayDevice const*;
 
    Advertisement(const std::initializer_list<DisplayDevice> &devices)
        : size{devices.size()}, devices{new DisplayDevice[size]} {
        std::copy(devices.begin(), devices.end(), Advertisement::devices);
    }
 
    // to keep things simple, let's pretend we shall not copy this object
    // or assign it one to another
    Advertisement(const Advertisement &other) = delete;
    Advertisement &operator=(const Advertisement &other) = delete;
 
    virtual ~Advertisement() {
        delete[] devices;
    }
 
    // Для работы с массивом объектов построить и использовать класс итератор.
    Iterator begin() {
        return devices;
    }
    Iterator end() {
        return devices + size;
    }
 
    ConstIterator begin() const {
        return devices;
    }
    ConstIterator end() const {
        return devices + size;
    }
 
    ConstIterator cbegin() const {
        return devices;
    }
    ConstIterator cend() const {
        return devices + size;
    }
 
    // Для работы с массивом объектов построить и использовать класс итератор.
    void advertise(const std::string &advertisement) {
        for (DisplayDevice &device : *this) {
            device << advertisement;
        }
    }
 
private:
    std::size_t size;
    DisplayDevice *devices;
};
 
int main() {
    Advertisement advertisement{
        DisplayDevice{1, 1000, 2000, 34, 3, "aaa"},
        DisplayDevice{2, 1000, 2000, 34, 3, "bbb"},
        DisplayDevice{3, 1000, 2000, 45, 4, "ccc"},
    };
 
    advertisement.advertise("buy our best product ever!");
 
    return 0;
}

#include <iostream>
 
class Device {
public:
    Device(): interface{0}, power{0}, weight{0} {}
    Device(int interface, int power, int weight): interface{interface}, power{power}, weight{weight} {}
 
    // остальные конструкторы и деструкторы -- тривиальные
    Device(const Device &) = default;
    virtual ~Device() = default;
 
    // оператор присваивания тоже в принципе тривиальный можно написать
    // Device &operator=(const Device &) = default;
    Device &operator=(const Device &other) {
        if (this != &other) {
            this->interface = other.interface;
            this->power = other.power;
            this->weight = other.weight;
        }
        return *this;
    }
 
 
    int getInterface() const {
        return interface;
    }
 
    void setInterface(int interface) {
        Device::interface = interface;
    }
 
    // построить полиморфическое кластер на основе виртуального метода для считывания мощности
    virtual int getPower() const {
        return power;
    }
 
    // построить полиморфическое кластер на основе виртуального метода для считывания мощности
    virtual void setPower(int power) {
        Device::power = power;
    }
 
    int getWeight() const {
        return weight;
    }
 
    void setWeight(int weight) {
        Device::weight = weight;
    }
 
private:
    int interface;
    int power;
    int weight;
};
 
 
std::ostream &operator<<(std::ostream &out, const Device &device) {
    return out << "Device{"
                  "interface: " << device.getInterface() <<
               ", power: " << device.getPower() <<
               ", weight: " << device.getWeight() <<
               "}";
}
 
std::istream &operator>>(std::istream &in, Device &device) {
    int i, p, w;
    in >> i >> p >> w;
    device.setInterface(i);
    device.setPower(p);
    device.setWeight(w);
    return in;
}
 
class DisplayDevice : public Device {
public:
    DisplayDevice(): Device{}, diagonal{0}, resolution{0}, infofile{} {}
    DisplayDevice(int interface, int power, int weight, int diagonal, int resolution, const std::string &infofile)
            : Device{interface, power, weight}, diagonal{diagonal}, resolution{resolution}, infofile{infofile} {}
 
    // построить полиморфическое кластер на основе виртуального метода для считывания мощности
    int getPower() const override {
        return Device::getPower();
    }
 
    // построить полиморфическое кластер на основе виртуального метода для считывания мощности
    void setPower(int power) override {
        Device::setPower(power);
    }
 
    int getDiagonal() const {
        return diagonal;
    }
 
    void setDiagonal(int diagonal) {
        DisplayDevice::diagonal = diagonal;
    }
 
    int getResolution() const {
        return resolution;
    }
 
    void setResolution(int resolution) {
        DisplayDevice::resolution = resolution;
    }
 
    const std::string &getInfofile() const {
        return infofile;
    }
 
    void setInfofile(const std::string &infofile) {
        DisplayDevice::infofile = infofile;
    }
 
private:
    int diagonal;
    int resolution;
    std::string infofile;
};
 
std::ostream &operator<<(std::ostream &out, const DisplayDevice &device) {
    out << "DisplayDevice{"
        << static_cast<const Device &>(device)
        << ", diagonal: " << device.getDiagonal()
        << ", resolution: " << device.getResolution()
        << ", infofile: '" << device.getInfofile() << "'"
        << "}";
    return out;
}
 
std::istream &operator>>(std::istream &in, DisplayDevice &device) {
    in >> static_cast<Device&>(device);
    int d, r;
    std::string i;
    in >> d >> r >> i;
    device.setDiagonal(d);
    device.setResolution(r);
    device.setInfofile(i);
    return in;
}
 
DisplayDevice &operator<<(DisplayDevice &d, const std::string &advertisement) {
    std::cout << d << ": '" << advertisement << "'" << std::endl;
    return d;
}
 
template<typename T, typename PointerType, typename ReferenceType>
struct PointerIterator {
 
    using value_type = T;
    using reference = ReferenceType;
    using pointer = PointerType;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::bidirectional_iterator_tag;
    using iterator = PointerIterator<T, PointerType, ReferenceType>;
 
    PointerIterator(pointer current): current{current} {}
    PointerIterator(): current{nullptr} {}
 
    reference operator*() { return *current; }
    reference operator*() const { return *current; }
    pointer operator->() { return current; }
    pointer operator->() const { return current; }
 
    iterator& operator++() { ++current; return *this; }
    iterator operator++(int) { return current++; }
 
    iterator& operator--() { --current; return *this; }
    iterator operator--(int) { return current--; }
 
    friend bool operator==(const iterator &a, const iterator &b) { return a.current == b.current; }
    friend bool operator!=(const iterator &a, const iterator &b) { return a.current != b.current; }
    friend bool operator<(const iterator &a, const iterator &b) { return a.current < b.current; }
    friend bool operator>(const iterator &a, const iterator &b) { return a.current > b.current; }
    friend bool operator<=(const iterator &a, const iterator &b) { return a.current <= b.current; }
    friend bool operator>=(const iterator &a, const iterator &b) { return a.current >= b.current; }
 
    iterator& operator+=(std::size_t size) { current += size; return *this; }
    friend iterator operator+(const iterator& i, std::size_t size) { return i.current + size; }
    friend iterator operator+(std::size_t size, const iterator&i) { return i.current + size; }
    iterator& operator-=(std::size_t size) { current -= size; return *this; }
    friend iterator operator-(const iterator&i, std::size_t size) { return i.current - size; }
    friend difference_type operator-(const iterator &a, const iterator &b) { return a.current - b.current; }
 
    reference operator[](std::size_t i) { return current[i]; }
 
    pointer current;
};
 
class Advertisement {
public:
 
    // Для работы с массивом объектов построить и использовать класс итератор.
    using Iterator = PointerIterator<DisplayDevice, DisplayDevice*, DisplayDevice&>;
    using ConstIterator = PointerIterator<DisplayDevice, const DisplayDevice*, const DisplayDevice&>;
 
    Advertisement(const std::initializer_list<DisplayDevice> &devices)
            : size{devices.size()}, devices{new DisplayDevice[size]} {
        std::copy(devices.begin(), devices.end(), Advertisement::devices);
    }
 
    // to keep things simple, let's pretend we shall not copy this object
    // or assign it one to another
    Advertisement(const Advertisement &other) = delete;
    Advertisement &operator=(const Advertisement &other) = delete;
 
    virtual ~Advertisement() {
        delete[] devices;
    }
 
    // Для работы с массивом объектов построить и использовать класс итератор.
    Iterator begin() {
        return devices;
    }
    Iterator end() {
        return devices + size;
    }
 
    ConstIterator begin() const {
        return devices;
    }
    ConstIterator end() const {
        return devices + size;
    }
 
    ConstIterator cbegin() const {
        return devices;
    }
    ConstIterator cend() const {
        return devices + size;
    }
 
    // Для работы с массивом объектов построить и использовать класс итератор.
    void advertise(const std::string &advertisement) {
        for (DisplayDevice &device : *this) {
            device << advertisement;
        }
    }
 
private:
    std::size_t size;
    DisplayDevice *devices;
};
 
int main() {
    Advertisement advertisement{
            DisplayDevice{1, 1000, 2000, 34, 3, "aaa"},
            DisplayDevice{2, 1000, 2000, 34, 3, "bbb"},
            DisplayDevice{3, 1000, 2000, 45, 4, "ccc"},
    };
 
    advertisement.advertise("buy our best product ever!");
 
    return 0;
}