Добавление элемента удаления и редактирования

#include <iostream>
#include <iterator>
using namespace std;
struct LinkedListNodeBase {
    LinkedListNodeBase* prev;
    LinkedListNodeBase* next;
 
    LinkedListNodeBase() noexcept : prev(this), next(this) {}
 
    LinkedListNodeBase(LinkedListNodeBase* before) noexcept : prev(before->prev), next(before) {
        prev->next = next->prev = this;
    }
 
    virtual ~LinkedListNodeBase() noexcept {
        prev->next = next;
        next->prev = prev;
    }
};
 
template<typename T>
struct LinkedListNode : public LinkedListNodeBase {
    T value;
 
    LinkedListNode(const T& value, LinkedListNodeBase* after) : LinkedListNodeBase(after), value(value) {}
};
 
template<typename T>
struct LinkedListIterator {
    using Self = LinkedListIterator<T>;
    using Node = LinkedListNode<T>;
    using NodeBase = LinkedListNodeBase;
 
    // для совместимости с stl
    typedef ptrdiff_t difference_type;
    typedef bidirectional_iterator_tag iterator_category;
    typedef T value_type;
    typedef T* pointer;
    typedef T& reference;
 
    NodeBase* node;
 
    LinkedListIterator() : node() {}
 
    LinkedListIterator(NodeBase* node) : node(node) {}
 
    reference operator*() const {
        return static_cast<Node*>(node)->value;
    }
 
    pointer operator->() const {
        return &static_cast<Node*>(node)->value;
    }
 
    Self& operator++() {
        node = node->next;
        return *this;
    }
 
    Self operator++(int) {
        Self result(*this);
        node = node->next;
        return result;
    }
 
    Self& operator--() {
        node = node->prev;
        return *this;
    }
 
    Self operator--(int) {
        Self result(*this);
        node = node->prev;
        return result;
    }
 
    bool operator==(const Self& other) const {
        return node == other.node;
    }
 
    bool operator!=(const Self& other) const {
        return node != other.node;
    }
};
 
template<typename T>
struct ConstLinkedListIterator {
    using Self = ConstLinkedListIterator<T>;
    using Node = const LinkedListNode<T>;
    using NodeBase = const LinkedListNodeBase;
    using Iterator = LinkedListIterator<T>;
 
    // для совместимости с stl
    typedef ptrdiff_t difference_type;
    typedef bidirectional_iterator_tag iterator_category;
    typedef T value_type;
    typedef const T* pointer;
    typedef const T& reference;
 
    NodeBase* node;
 
    ConstLinkedListIterator() : node() {}
 
    ConstLinkedListIterator(NodeBase* node) : node(node) {}
 
    ConstLinkedListIterator(const Iterator& iterator) : node(iterator.node) {}
 
    reference operator*() const {
        return static_cast<Node*>(node)->value;
    }
 
    pointer operator->() const {
        return &static_cast<Node*>(node)->value;
    }
 
    Self& operator++() {
        node = node->next;
        return *this;
    }
 
    Self operator++(int) {
        Self result(*this);
        node = node->next;
        return result;
    }
 
    Self& operator--() {
        node = node->prev;
        return *this;
    }
 
    Self operator--(int) {
        Self result(*this);
        node = node->prev;
        return result;
    }
 
    bool operator==(const Self& other) const {
        return node == other.node;
    }
 
    bool operator!=(const Self& other) const {
        return node != other.node;
    }
};
 
 
template<typename T>
class LinkedList {
public:
    using Node = LinkedListNode<T>;
    using Iterator = LinkedListIterator<T>;
    using ConstIterator = ConstLinkedListIterator<T>;
 
    LinkedList() : base() {}
 
    LinkedList(const LinkedList<T>&) = delete;
 
    LinkedList<T>& operator=(const LinkedList<T>&) = delete;
 
    ~LinkedList() {
        clear();
    }
 
    bool isEmpty() const {
        return base.next == &base;
    }
 
    void clear() {
        while (!isEmpty()) {
            delete base.next;
        }
    }
 
    Iterator begin() {
        return Iterator(base.next);
    }
 
    Iterator end() {
        return Iterator(&base);
    }
 
    ConstIterator begin() const {
        return ConstIterator(base.next);
    }
 
    ConstIterator end() const {
        return ConstIterator(&base);
    }
 
    // inserts value before position
    Iterator insert(ConstIterator position, const T& value) {
        return new Node(value, const_cast<LinkedListNodeBase*>(position.node));
    }
 
    Iterator erase(ConstIterator position) {
        Iterator result = position.node->next;
        delete position.node;
        return result;
    }
 
private:
    LinkedListNodeBase base;
};
 
template<typename Iterator>
size_t distance(Iterator begin, Iterator end) {
    size_t result = 0;
    for (; begin != end; ++begin, ++result);
    return result;
}
 
template<typename Iterator>
void advance(Iterator& iterator, size_t n) {
    while (n--) {
        ++iterator;
    }
}
 
template<typename Iterator, typename T, typename Comparator>
Iterator lowerBound(Iterator begin, Iterator end, const T& value, Comparator compare) {
    size_t count = ::distance(begin, end);
 
    while (count > 0) {
        size_t half = count / 2;
        Iterator middle = begin;
        advance(begin, half);
        if (compare(*middle, value)) {
            begin = ++middle;
            count -= half + 1;
        }
        else {
            count = half;
        }
    }
    return begin;
}
 
class Znak {
public:
    Znak() : surname(), name(), zodiac(), dob() {}
 
    Znak(const string& surname, const string& name, const string& zodiac, int day, int month, int year)
        : surname(surname), name(name), zodiac(zodiac), dob{ day, month, year } {}
 
    const string& getSurname() const {
        return surname;
    }
 
    const string& getName() const {
        return name;
    }
 
    const string& getZodiac() const {
        return zodiac;
    }
 
    int getDay() const {
        return dob[0];
    }
 
    int getMonth() const {
        return dob[1];
    }
 
    int getYear() const {
        return dob[2];
    }
 
private:
    string surname;
    string name;
    string zodiac;
    int dob[3];
};
 
bool operator==(const Znak& a, const Znak& b) {
    return a.getSurname() == b.getSurname() && a.getName() == b.getName() && a.getZodiac() == b.getZodiac() &&
        a.getDay() == b.getDay() && a.getMonth() == b.getMonth() && a.getYear() == b.getYear();
}
 
bool isLessByZodiac(const Znak& a, const Znak& b) {
    return a.getZodiac() < b.getZodiac();
}
 
istream& operator>>(istream& in, Znak& znak) {
    string surname, name, zodiac;
    int day, month, year;
    in >> surname >> name >> zodiac >> day >> month >> year;
    znak = { surname, name, zodiac, day, month, year }; // воспользуюсь оператором присваивания
    return in;
}
 
ostream& operator<<(ostream& out, const Znak& znak) {
    return out << "name=" << znak.getName()
        << ", surname=" << znak.getSurname()
        << ", zodiac=" << znak.getZodiac()
        << ", dob=" << znak.getDay() << "." << znak.getMonth() << "." << znak.getYear();
}
 
template<typename T>
ostream& operator<<(ostream& out, const LinkedList<T>& list) {
    for (auto i = list.begin(), end = list.end(); i != end;) {
        out << *i;
        if (++i != end) {
            out << "\n";
        }
    }
    return out;
}
 
template<typename Iterator, typename OutputIterator, typename Predicate>
OutputIterator copyIf(Iterator begin, Iterator end, OutputIterator output, Predicate predicate) {
    for (; begin != end; ++begin) {
        if (predicate(*begin)) {
            *output = *begin;
            ++output;
        }
    }
    return output;
}
 
template<typename First, typename Second>
struct Pair {
    First first;
    Second second;
};
 
template<typename F, typename S>
ostream& operator<<(ostream& out, const Pair<F, S>& p) {
    return out << "{" << p.first << ", " << p.second << "}";
}
 
template<typename Iterator, typename Comparator>
Iterator maxElement(Iterator begin, Iterator end, Comparator compare) {
    if (begin == end) {
        return end;
    }
    Iterator result = begin++;
    for (; begin != end; ++begin) {
        if (compare(*begin, *result)) {
            result = begin;
        }
    }
    return result;
}
    void menu() {
        cout << "0. Exit" << "\n";
        cout << "1. Input" << "\n";
        cout << "2. Output " << "\n";
        cout << "3. Output man k " << "\n";
        cout << "4. Output max znak" << '\n';
        cout << "5. Delete element k" << '\n';
        cout << "6. Redact element k" << '\n';
        cout << "7. Add element k" << '\n';
        cout << "/////////////////////////////////////////////////////////" << "\n";
    }
int main() {
    LinkedList<Znak> znakList;
    Znak znak;
    LinkedList<Pair<string, size_t>> groupedBySign;
    bool f = false, fl = false;
    int choise = 10, n;
    while (choise) {
        menu(); cin >> choise;
        switch (choise) {
        case 0:
            f = true;
            cout << "Exit" << "\n";
            break;
        case 1:
            cout << "Input" << "\n";
            cin >> n;
            while (n--) {
                cin >> znak;
                // позиция для вставки
                auto position = lowerBound(znakList.begin(), znakList.end(), znak, isLessByZodiac);
                // вставка в позицию
                znakList.insert(position, znak);
            }
            fl = true;
            break;
        case 2:
            cout << "Output\n";
            if (fl) cout << "All:" << endl << znakList << endl;
            else cout << "Input dannie" << "\n";
            break;
        case 3:
            cout << "Output man k\n";
            if (fl) {
                string surname; cin >> surname;
                cout << "All with surname " << surname << endl;
                copyIf(znakList.begin(), znakList.end(), ostream_iterator<Znak>(cout, "\n"),
                    [&surname](const Znak& znak) { return znak.getSurname() == surname; });
            }
            else
                cout << " Dannie deleted" << '\n';
            break;
        case 4:
            cout << " Output max znak\n";
            if (fl) {
                // подсчёт людей по знакам зодиака
                for (auto& z : znakList) {
                    auto position = lowerBound(groupedBySign.begin(), groupedBySign.end(), z.getZodiac(),
                        [](auto& pair, auto& value) { return pair.first < value; });
                    if ((position != groupedBySign.end()) && position->first == z.getZodiac()) {
                        ++(position->second);
                    }
                    else {
                        groupedBySign.insert(position, { z.getZodiac(), 1 });
                    }
                }
                cout << "People count by sign:" << endl << groupedBySign << endl;
 
                if (groupedBySign.isEmpty()) {
                    cout << "No people." << endl;
                }
                else {
                    auto max = maxElement(groupedBySign.begin(), groupedBySign.end(),
                        [](auto& a, auto& b) { return a.second > b.second; });
                    cout << "Maximum people for sign:" << endl << *max << endl;
                }
            }
            break;
        case 5:
            cout << "Delete man k\n";
            if (fl) {
                
            }
            else cout << "Etih dannih i tak ne bilo \n";
        case 6:
            cout << "Redact element k\n";
            if (fl) {
 
            }
            else cout << "Dannih net\n";
        default:
            cout << "Exit" << "\n"; f = true;
            break;
        } cout << "/////////////////////////////////////////////////////////" << "\n";
        if (f) break;
    } return 0;
}