Модель предметной области Кинопоиск на языке C++:

Файл header.h

#ifndef HEADER_H
#define HEADER_H
#include <iostream>
#include <list>
#include <iterator>
#include <cstddef>
#include<utility>
using namespace std;
enum class MPAA {
    G,
    PG,
    PG_13,
    R,
    NC_17
};
enum class Grade {
    One = 1,
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten
};
enum class Status {
    Production,
    Air,
    Finished
};

template<class T>
class MyListTemplate
{
    using value_type = T;
    using reference = T&;
    using const_reference = const T&;
    using difference_type = std::ptrdiff_t;
    using size_type = unsigned int;

public:
    T* head;
    T* tail;
    int m_size;

public:
    MyListTemplate() : head(nullptr), tail(nullptr), m_size(0) {}

    MyListTemplate(const MyListTemplate& a) : head(a.head), tail(a.tail), m_size(a.m_size) {}

    void freeMemory()
    {
        if (head == nullptr)
            return;

        T* current = head;
        T* nextNode = nullptr;

        for (int i = 0; i < m_size; i++)
        {
            nextNode = current->next;
            delete current;
            current = nextNode;
        }
        this->m_size = 0;
        head = tail = nullptr;
    }

    void add(std::string Name)
    {
        if (m_size < 100)
        {
            T* newNode = new T(Name);
            newNode->next = newNode->prev = nullptr;

            if (head == nullptr)
            {
                head = newNode;
                tail = newNode;
            }
            else
            {
                newNode->prev = tail;
                tail->next = newNode;
                tail = newNode;
            }
            ++m_size;
        }
        else
            std::cout << "The size is already maximum" << std::endl;
    }

    void remove(std::string Name)
    {
        if (head == nullptr)
        {
            return;
        }

        if (head->getName() == Name)
        {
            if (head->next == head)
            {
                delete head;
                head = tail = nullptr;
                m_size = 0;
                return;
            }
            else
            {
                T* nodeToRemove = head;
                head = head->next;
                delete nodeToRemove;
            }
        }

        T* current = head->next;
        T* previous = head;

        while (current != head)
        {
            if (current->getName() == Name)
            {
                T* nodeToRemove = current;
                previous->next = current->next;
                if (current == tail) tail = previous;
                delete nodeToRemove;
                --size;
                current = previous->next;
                current->prev = previous;
            }
            else
            {
                previous = current;
                current = current->next;
            }
        }
    }

    void print()
    {
        if (head == NULL)
            return;

        T* current = head;

        for (int i = 0; i < m_size; i++)
        {
            std::cout << current->getName() << std::endl;
            current = current->next;
        }
        std::cout << std::endl;
    }

    MyListTemplate(MyListTemplate&& rv) : head(rv.head), tail(rv.tail), m_size(rv.m_size) // rvalue, перемещает данные из временного объекта
    {
        rv.head = nullptr;
        rv.tail = nullptr;
        rv.m_size = 0;
    }

    MyListTemplate& operator=(MyListTemplate& b)
    {
        if (this == &b)
            return *this;
        T* current = b.head;
        for (int i = 0; i < b.size; i++)
        {
            this->add(current->getName());
            current = current->next;
        }
        return *this;
    }

    MyListTemplate& operator=(MyListTemplate&& rv) 
    {
        if (this == &rv)
            return *this;

        freeMemory();

        head = rv.head;
        tail = rv.tail;
        m_size = rv.m_size;

        rv.head = nullptr;
        rv.tail = nullptr;
        rv.m_size = 0;

        return *this;
    }

    ~MyListTemplate()
    {
        freeMemory();
    }

    bool operator==(MyListTemplate& b)
    {
        if (this->m_size != b.m_size)
            return false;
        else
        {
            bool f = true;
            T* curra = this->head;
            T* currb = b.head;
            for (int i = 0; i < this->m_size; i++)
            {
                if (curra->getName() != currb->getName())
                {
                    f = false;
                    break;
                }
                curra = curra->next;
                currb = currb->next;
            }
            return f;
        }
    }
    bool operator!=(MyListTemplate& b)
    {
        return !operator==(b);
    }

    void swap(MyListTemplate& b)
    {
        int tsize = this->m_size;
        this->m_size = b.m_size;
        b.m_size = tsize;
        T* ahead = this->head;
        this->head = b.head;
        b.head = ahead;
    }
    void swap(MyListTemplate& a, MyListTemplate& b)
    {
        a.swap(b);
    }

    void Swap(MyListTemplate& b) noexcept
    {
        std::swap(this->head, b.head);
        std::swap(this->tail, b.tail);
        std::swap(this->m_size, b.m_size);
    }

    int size()
    {
        return this->m_size;
    }
    int max_size()
    {
        return 100;
    }

    bool empty()
    {
        if (this->m_size == 0)
            return true;
        else return false;
    }

    struct Iterator
    {
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = T;
        using pointer = T*;
        using reference = T&;

        Iterator(pointer ptr) : m_ptr(ptr) {}

        ~Iterator() {}

        reference operator*() const { return *m_ptr; }
        pointer operator->() { return m_ptr; }
        Iterator& operator++()
        {
            if (m_ptr == nullptr)
                return *this;
            else if (m_ptr->next == nullptr)
            {
                m_ptr = m_ptr->next;
                return *this;
            }
            else
            {
                m_ptr = m_ptr->next;
                while (m_ptr->next != nullptr)
                {
                    return *this;
                    m_ptr = m_ptr->next;
                }
            }
        }
        Iterator operator++(int) { Iterator tmp = *this; ++(*this); return tmp; }
        Iterator operator--(int) { Iterator tmp = *this; --(*this); return tmp; }
        bool operator== (const Iterator& b) { return m_ptr == b.m_ptr; };
        bool operator!= (const Iterator& b) { return m_ptr != b.m_ptr; };

    private:
        pointer m_ptr;
    };
    Iterator begin() { return Iterator(this->head); }
    Iterator end() { return Iterator(nullptr); }

    struct ConstantIterator
    {
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = const T;
        using pointer = T*;
        using reference = const T&;

        ConstantIterator(pointer ptr) : m_ptr(ptr) {}

        ~ConstantIterator() {}

        const reference operator*() const { return *m_ptr; }
        pointer operator->() const { return m_ptr; }
        ConstantIterator& operator++()
        {
            if (m_ptr == nullptr)
                return *this;
            else if (m_ptr->next == nullptr)
            {
                m_ptr = m_ptr->next;
                return *this;
            }
            else
            {
                m_ptr = m_ptr->next;
                while (m_ptr->next != nullptr)
                {
                    return *this;
                    m_ptr = m_ptr->next;
                }
            }
        }
        ConstantIterator operator++(int) { ConstantIterator tmp = *this; ++(*this); return tmp; }
        bool operator== (const ConstantIterator& b) { return m_ptr == b.m_ptr; };
        bool operator!= (const ConstantIterator& b) { return m_ptr != b.m_ptr; };

    private:
        pointer m_ptr;
    };
    ConstantIterator cbegin() const { return ConstantIterator(this->head); }
    ConstantIterator cend()   const { return ConstantIterator(nullptr); }
    using iterator = Iterator;
    using const_iterator = ConstantIterator;
};

class Person
{
protected:
    std::string Name;
public:
    Person* prev, * next;
    Person(std::string name)
    {
        this->Name = name;
        this->prev = this->next = nullptr;
    }
    Person(Person& a)
    {
        this->Name = a.Name;
        this->prev = a.prev;
        this->next = a.next;
    }
    std::string getName()
    {
        return Name;
    }
    void setName(std::string name)
    {
        this->Name = name;
    }
};

class Date
{
protected:
    std::string date;
public:
    Date* prev, * next;
    Date(std::string date)
    {
        this->date = date;
        this->prev = this->next = nullptr;
    }
    std::string getName()
    {
        return date;
    }
    void setName(std::string date)
    {
        this->date = date;
    }
};

class Episode
{
private:
    std::string Name;
    Date World_premiere();
public:
    Episode* prev, * next;
    Episode(std::string Name)
    {
        this->Name = Name;
        this->prev = this->next = nullptr;
    }
    Episode(Episode& a)
    {
        this->Name = a.Name;
        this->prev = a.prev;
        this->next = a.next;
    }
    std::string getName()
    {
        return Name;
    }
    void setName(std::string name)
    {
        this->Name = name;
    }
    Date getWorldPremiere()
    {
        return World_premiere();
    }
    void setWorldPremiere(Date premiere)
    {
        this->World_premiere() = premiere;
    }
    void printWorldPremiere()
    {
        std::cout << "\tWorld premiere: " << this->World_premiere().getName() << std::endl;

    }
};

class Product
{
private:
    string Name;
    int Year;
    MyListTemplate<Person> Directors;
    unsigned long Budget;
    unsigned long World_box_office;
    MPAA MPAA_rating;
    int Timing_in_mins;
    MyListTemplate<Person> Starring;
    int Grades_sum = 0;
    int Grades_size = 0;
    double Rating;

    void setRating()
    {
        this->Rating = Grades_sum / Grades_size;
    }
protected:
    MyListTemplate<Date> World_premiere;
public:
    Product* next;
    Product()
    {
        this->next = NULL;
    }
    std::string getName()
    {
        return Name;
    }
    void setName(std::string name)
    {
        this->Name = name;
    }
    MyListTemplate<Person> getDirector()
    {
        return Directors;
    }
    void printDirectors()
    {
        std::cout << "Directed by: " << std::endl;
        this->Directors.print();
    }
    void addDirectors(std::string name)
    {
        this->Directors.add(name);
    }
    unsigned long getBudget()
    {
        return Budget;
    }
    void setBudget(unsigned long budget)
    {
        this->Budget = budget;
    }
    unsigned long getWorldBoxOffice()
    {
        return World_box_office;
    }
    void setWorldBoxOffice(unsigned long boxOffice)
    {
        this->World_box_office = boxOffice;
    }
    virtual MyListTemplate<Date> getWorldPremiere() = 0;
    void printPremiere()
    {
        World_premiere.print();
    }
    MPAA getMPAA()
    {
        return MPAA_rating;
    }
    void setMPAA(MPAA mpaa)
    {
        this->MPAA_rating = mpaa;
    }
    int getTimingInMins()
    {
        return Timing_in_mins;
    }
    void setTimingInMins(int timing)
    {
        this->Timing_in_mins = timing;
    }
    MyListTemplate<Person> getStarring()
    {
        return Starring;
    }
    void printName()
    {
        std::cout << this->getName() << std::endl;
    }
    void printStarring()
    {
        std::cout << "Starring: " << std::endl;
        this->Starring.print();
    }
    void addStarring(std::string name)
    {
        this->Starring.add(name);
    }
    void addGrade(Grade grade)
    {
        ++Grades_size;
        int value = static_cast<int>(grade);
        Grades_sum += value;
        setRating();
    }
    double getRating()
    {
        return Rating;
    }
    ~Product()
    {
        Directors.head = nullptr;
        Starring.head = nullptr;
    }
};

class Movie : public Product
{
private:

public:
    virtual MyListTemplate<Date> getWorldPremiere()
    {
        return World_premiere;
    }
    void setWorldPremiere(std::string date)
    {
        this->World_premiere.freeMemory();
        this->World_premiere.add(date);
    }

};

class Series : public Product
{
private:
    int Episodes_number = 0;
    MyListTemplate<Episode> Episodes;
    MyListTemplate<Date> premieres;
    int Seasons_number;
    Status Series_status;
    void setEpisodesNumber(int episodesNumber)
    {
        this->Episodes_number = episodesNumber;
    }
public:
    int getEpisodesNumber()
    {
        return Episodes_number;
    }
    MyListTemplate<Episode> getEpisodes()
    {
        return Episodes;
    }
    void addEpisode(std::string Name)
    {
        this->Episodes.add(Name);
        setEpisodesNumber(Episodes.size());
    }

    virtual MyListTemplate<Date> getWorldPremiere()
    {
        return premieres;
    }
    Status getStatus()
    {
        return Series_status;
    }
    void setStatus(Status status)
    {
        this->Series_status = status;
    }
    void printEpisodes()
    {
        std::cout << "Episodes: " << std::endl;
        Episodes.print();
    }
    void setWorldPremiere(std::string date)
    {
        this->World_premiere.freeMemory();
        this->World_premiere.add(date);
    }
    ~Series()
    {
        Episodes.head = nullptr;
    }
};
#endif HEADER_H

Файл Kinopoisk

#include "Header.h"

int main()
{

}

Бизнес-модели на UML:
1.Модель на основе пользовательских сценариев (Use Case Model): позволяет описать взаимодействие пользователей (актеров) с системой, выявляя основные функции и требования.

2.     Модель бизнес-процессов (Business Process Model): описывает последовательности действий (процессы) и роли, участвующие в выполнении задач бизнеса, часто с помощью диаграмм активности (Activity Diagrams).

3.Модель классов (Class Model): описывает структуру системы, ее сущности (классы) и взаимосвязи между ними.

4.Модель состояний (State Machine Model): отображает жизненный цикл объектов системы и возможные состояния, в которых они могут находиться, а также переходы между ними.

5.Компонентная модель (Component Model): представляет систему как набор компонентов с четко определенными интерфейсами.

Можешь указать место (или местА) в ЖЦ (или процессы и их виды деятельности согласно ISO 12207), где эти модели уже можно построить?

(в  частности, такую модель области “Кинопоиск”)