4semlab4 (C++) ALPHA VERS

/*  Разработать класс "Множество"
    определить конструкторы и деструктор done
    переопределить операции объединения, пересечения и разности двух множеств, методы для организации ввода-вывода
    написать методы проверки включения одного мн-ва в другое, проверки равенства двух мн-в, проверки пустоты двух мн-в
*/
#include <iostream>
#include <vector>

using namespace std;

class Multiplicity {
    private:
        vector <int> many_one;
    public:
        Multiplicity(int n) {
            cout << "Введите множество: ";
            int elem_in = 0;
            for (int i = 0; i < n; i++) {
                cin >> elem_in;
                many_one.push_back(elem_in);
            }
        }
        Multiplicity() {
            many_one.clear();
        }
        ~Multiplicity() {
            many_one.clear();
        }
        Multiplicity operator+ (Multiplicity t) {
            Multiplicity result;
            //result.many_one.clear();
            if (many_one.size() == t.many_one.size()) {
                for (int i = 0; i < many_one.size(); i++) {
                    result.many_one.push_back(many_one[i]);
                }
                for (int i = 0; i < t.many_one.size(); i++) {
                    result.many_one.push_back(t.many_one[i]);
                }
                return result;
            } else if (many_one.size() > t.many_one.size()) {
                for (int i = 0; i < t.many_one.size(); i++) {
                    result.many_one.push_back(t.many_one[i]);
                }
                for (int i = 0; i < many_one.size(); i++) {
                    result.many_one.push_back(many_one[i]);
                }
                return result;
            } else {
                for (int i = 0; i < many_one.size(); i++) {
                    result.many_one.push_back(many_one[i]);
                }
                for (int i = 0; i < t.many_one.size(); i++) {
                    result.many_one.push_back(t.many_one[i]);
                }
                return result;
            }
        }
        Multiplicity operator* (Multiplicity t) {
            Multiplicity result;
            result.many_one.clear();
            if (many_one.size() == t.many_one.size()) {
                for (int i = 0; i < many_one.size(); i++) {
                    if (many_one[i] == t.many_one[i]) {
                        result.many_one.push_back(many_one[i]);
                    }
                }
                return result;
            } else if (many_one.size() < t.many_one.size()) {
                for (int i = 0; i < many_one.size(); i++) {
                    if (many_one[i] == t.many_one[i]) {
                        result.many_one.push_back(many_one[i]);
                    }
                }
                return result;
            } else {
                for (int i = 0; i < t.many_one.size(); i++) {
                    if (many_one[i] == t.many_one[i]) {
                        result.many_one.push_back(many_one[i]);
                    }
                }
                return result;
            }
        }
        // Не реализована (разность двух множеств)
        Multiplicity operator/ (Multiplicity t) {

        }
        void getMany() {
            for (int i = 0; i < many_one.size(); i++) {
                cout << many_one[i] << ' ';
            }
            cout << endl;
        }
        bool multiplicity_equal(Multiplicity t); // Сравнение двух множеств
        bool isEmpty(); // Проверка на пустоту множества
        bool isEncluded(Multiplicity t); // Проверка на включение множества в другое множество
};

/* Реализация некоторых методов класса Multiplicity */
bool Multiplicity :: multiplicity_equal(Multiplicity t) {
    bool check = true;
    if (many_one.size() == t.many_one.size()) {
        for (int i = 0; i < many_one.size(); i++) {
            if (many_one[i] == t.many_one[i]) {}
            else {
                check = false;
                break;
            }
        }
        return check;
    } else
        return false;
}

bool Multiplicity :: isEmpty() {
    if (many_one.size())
        return true;
    else
        return false;
}

bool Multiplicity :: isEncluded(Multiplicity t) {
    int counter = 0;
    if (many_one.size() == t.many_one.size()) {
        for (int i = 0; i < many_one.size(); i++) {
            for (int j = 0; j < t.many_one.size(); j++) {
                if (many_one[i] == t.many_one[j]) {
                    counter++;
                }
            }
            if (counter) {
                //break;
                return false;
            }
        }
        if (counter == many_one.size()) {
            cout << "Множества равны! " << endl;
            return true;
        } else
            return false;
    } else if (many_one.size() < t.many_one.size()) {
        for (int i = 0; i < many_one.size(); i++) {
            for (int j = 0; j < t.many_one.size(); j++) {
                if (many_one[i] == t.many_one[j]) {
                    counter++;
                }
            }
        }
        if (counter == many_one.size()) {
            cout << "Первое множество содержится во втором!" << endl;
            return true;
        } else
            return false;
    } else {
        for (int i = 0; i < t.many_one.size(); i++) {
            for (int j = 0; j < many_one.size(); j++) {
                if (t.many_one[i] == many_one[j]) {
                    counter++;
                }
            }
        }
        if (counter == t.many_one.size()) {
            cout << "Второе множество содержится в первом! " << endl;
            return true;
        } else
            return false;
    }
}

int main() {
    setlocale(LC_ALL, "Russian");
    int n = 0;
    cout << "Введите размерность первого множества: "; cin >> n;
    Multiplicity multiplicity_one(n);
    cout << "\nВведите размерность второго множества: "; cin >> n;
    Multiplicity multiplicity_two(n);
    if (!multiplicity_one.isEmpty() && !multiplicity_two.isEmpty()) {
        cout << "Оба множества пустые! " << "\nВведите заново значения!\n";
        main();
    }
    else if (!multiplicity_two.isEmpty()) {
        cout << "Второе множество пустое! ";
    }
    else {
        cout << "Первое множество пустое! ";
    }
    char choice;
    cout << "Выберите, что хотите сделать с множествами:\n***Объединение множеств --- +\n***Пересечение множеств --- *\n***Сравнение двух множеств --- =\n***Включение одного множества во второе --- %\nВаш ввод: ";
    cin >> choice;
    Multiplicity result;
    switch (choice) {
        case ('+'):
            result = multiplicity_one + multiplicity_two;
            cout << "Объединение двух множеств равно: ";
            result.getMany();
            break;
        case ('*'):
            result = multiplicity_one * multiplicity_two;
            cout << "Пересечение двух множеств равно: ";
            result.getMany();
            break;
        case ('='):
            if (multiplicity_one.multiplicity_equal(multiplicity_two)) {
                cout << "Введенные множества равны! ";
                break;
            } else {
                cout << "Введенные множества не равны! ";
                break;
            }
        case ('%'):
            multiplicity_one.isEncluded(multiplicity_two);
    }
    char final_choice;
    cout << "Чтобы продолжить работу, нажмите 1: "; cin >> final_choice;
    if (final_choice == '1') {
        main();
    } else {
        system("pause");
        return 0;
    }
}