С ++ Сложность с пониманием темы перегрузка операторов, необходимо решить задачу.
Разработать класс Set (множество). Внутренним представлением класса Set является целочисленный массив элементов множества. Класс должен обеспечивать следующие возможности: добавление элементов в множество с исключением дублирования элементов, путем перегрузки оператора +; выполнение операций сравнения множеств.
Ответы
Ответ:
Конечно, давайте реализуем класс Set с перегрузкой оператора `+` и операторов сравнения. В данном случае, мы также будем использовать динамический массив для хранения элементов множества:
```cpp
#include <iostream>
#include <algorithm>
class Set {
private:
int* elements;
int size;
public:
// Конструктор по умолчанию
Set() : elements(nullptr), size(0) {}
// Конструктор копирования
Set(const Set& other) : size(other.size) {
elements = new int[size];
std::copy(other.elements, other.elements + size, elements);
}
// Деструктор
~Set() {
delete[] elements;
}
// Перегрузка оператора +
Set operator+(const Set& other) const {
Set result = *this; // Создаем копию текущего множества
for (int i = 0; i < other.size; ++i) {
if (!result.contains(other.elements[i])) {
result.addElement(other.elements[i]);
}
}
return result;
}
// Перегрузка оператора присваивания
Set& operator=(const Set& other) {
if (this != &other) {
delete[] elements;
size = other.size;
elements = new int[size];
std::copy(other.elements, other.elements + size, elements);
}
return *this;
}
// Перегрузка оператора ==
bool operator==(const Set& other) const {
if (size != other.size) {
return false;
}
for (int i = 0; i < size; ++i) {
if (!other.contains(elements[i])) {
return false;
}
}
return true;
}
// Перегрузка оператора !=
bool operator!=(const Set& other) const {
return !(*this == other);
}
// Проверка наличия элемента в множестве
bool contains(int element) const {
for (int i = 0; i < size; ++i) {
if (elements[i] == element) {
return true;
}
}
return false;
}
// Добавление элемента в множество
void addElement(int element) {
if (!contains(element)) {
int* newElements = new int[size + 1];
std::copy(elements, elements + size, newElements);
newElements[size] = element;
delete[] elements;
elements = newElements;
++size;
}
}
// Вывод элементов множества
void display() const {
std::cout << "Элементы множества: ";
for (int i = 0; i < size; ++i) {
std::cout << elements[i] << " ";
}
std::cout << std::endl;
}
};
int main() {
Set set1, set2, setResult;
set1.addElement(1);
set1.addElement(2);
set1.addElement(3);
set2.addElement(3);
set2.addElement(4);
set2.addElement(5);
// Перегрузка оператора +
setResult = set1 + set2;
set1.display();
set2.display();
setResult.display();
// Перегрузка оператора ==
if (set1 == set2) {
std::cout << "Множества равны." << std::endl;
} else {
std::cout << "Множества не равны." << std::endl;
}
// Перегрузка оператора !=
if (set1 != set2) {
std::cout << "Множества не равны." << std::endl;
} else {
std::cout << "Множества равны." << std::endl;
}
return 0;
}
```
Этот пример демонстрирует перегрузку оператора `+` для объединения множеств, а также операторов `==` и `!=` для сравнения множеств.
(Шаблон) Функция, определяющая второй по величине элемент массива (т.е. тот, который будет максимальным, если исключить из массива текущий максимальный?
Ответ:
#include <iostream>
#include <algorithm>
#include <vector>
class Set {
private:
std::vector<int> elements;
public:
Set() {}
Set(std::vector<int> initial_elements) {
for (int element : initial_elements) {
if (std::find(elements.begin(), elements.end(), element) == elements.end()) {
elements.push_back(element);
}
}
}
void add(int element) {
if (std::find(elements.begin(), elements.end(), element) == elements.end()) {
elements.push_back(element);
}
}
Set operator+(const Set& other) {
std::vector<int> combined_elements = elements;
for (int element : other.elements) {
if (std::find(combined_elements.begin(), combined_elements.end(), element) == combined_elements.end()) {
combined_elements.push_back(element);
}
}
return Set(combined_elements);
}
bool operator==(const Set& other) {
if (elements.size() != other.elements.size()) {
return false;
}
for (int element : elements) {
if (std::find(other.elements.begin(), other.elements.end(), element) == other.elements.end()) {
return false;
}
}
return true;
}
bool operator!=(const Set& other) {
return !(*this == other);
}
};