Запрограммировать класс "Однонаправленный список". Код к заданию имеется

#include <iostream>
#include <conio.h>
#include <vector>
#include <ctime>
#include <math.h>
using namespace std;
 
class List {
    int n;
    vector <char> list;
 
    void create(vector <char> &head, int &k) {
        srand(time(0));
        cout << "Enter array size: ";
        cin >> k;
        if (k >= 0 && k <= 100) {
            cout << "Array created" << endl;
            for (int i = 0; i < k; i++) {
                head.push_back(rand() % 127);
                cout << head[i] << " ";
            }
            cout << endl;
        }
        else cout << "Array size should be from 0 to 100" << endl << "Your array size: " << k << endl;
    }
 
    void printList(vector <char> list) {
        for (char i : list)
            cout << i << " ";
    }
 
    void getInd(vector <char> list, int k) {
        int choice;
        if (k != 0) {
            cout << "Select which index to refer to: ";
            cin >> choice;
            if (choice > 0 && choice < (k + 1)) {
                cout << "Element value by index " << choice << " = " << list.at(choice - 1) << endl;
            }
            else cout << "The selected value must be greater than 0 and less than " << k + 1 << endl << "Your value: " << choice;
        }
        else cout << "Cannot select an element from an empty array" << endl << "Size of your array = 0" << endl;
    }
 
    void insert(vector <char> list, int k) {
        int ind;
        char s;
        cout << "Select the index to which you want to add an item: ";
        cin >> ind;
        if (ind <= k) {
            cout << "Enter the value you want to add to the array: ";
            cin >> s;
 
            list.insert(list.begin() + ind - 1, s);
            printList(list);
        }
        else cout << "Your index should be less then " << k + 1 << endl << "Your index: " << ind << endl;
    }
 
    void delBegin(vector <char> list, int k) {
        if (k != 0) {
            cout << "New array:" << endl;
            list.erase(list.begin());
            printList(list);
        }
        else cout << "Cannot remove an element from an empty array" << endl << "Size of your array: " << k << endl;
    }
 
    void delEnd(vector <char> list, int k) {
        if (k != 0) {
            cout << "New array:" << endl;
            list.pop_back();
            printList(list);
        }
        else cout << "Cannot remove an element from an empty array" << endl << "Size of your array: " << k << endl;
    }
 
public:
    List() {
        create(list, n);
        if (n >= 0 && n <= 100) {
            int choice = 0;
            cout << "Select an array operation" << endl
                 << "1) Index access" << endl
                 << "2) Element addition" << endl
                 << "3) Removing an element from the beginning" << endl
                 << "4) Removing an element from the end" << endl;
            cin >> choice;
            if (choice >= 1 && choice <= 4) {
                switch (choice) {
                    case 1: {
                        getInd(list, n);
                        break;
                    }
                    case 2: {
                        insert(list, n);
                        break;
                    }
                    case 3: {
                        delBegin(list, n);
                        break;
                    }
                    case 4: {
                        delEnd(list, n);
                        break;
                    }
                }
            }
            else cout << "Cannot select this operation. Operations are available: 1-4" << endl
                     << "Your operation number: " << choice << endl;
        }
    }
};

int main() {
    List b;
    _getch();
}

#pragma once
#include <iostream>
#include <iomanip>
struct God {
    std::string name;
    std::string mythology;
    std::string transport;
    std::string weapon;
    God();
};
 
struct Node {
    std::string value;
    Node* prev;
    Node* succ;
    God* god;
    Node();
};
 
 
 
class List
{
private: 
    Node* first;
    Node* last;
    int size = 0;
public:
    List();
    List(const std::string& val);
    List(const std::string& val, const std::string& mith, const std::string& name_of_god, const std::string& trans, const std::string& god_weapon);
    ~List();
    //void add(std::string& name);
    void erase(int pos);
    void add(std::string name, int pos);
    void add(std::string name, int pos, God* god_data);
    Node* find(int pos);
};

#include "List.h"
 
Node::Node()
    :value{ "" }, prev{ nullptr }, succ{ nullptr } {}
God::God()
    :mythology{" "},name{" "},transport{" "},weapon{" "} {}
 
List::List()
{
    first = nullptr;
    last = nullptr;
    size = 0;
 
}
 
List::List(const std::string& val)
{
    first = last = new Node;
 
    first->value = val;
    first->succ = nullptr;
    first->prev = nullptr;
 
    first->god = new God;
    first->god->mythology = " ";
    first->god->name = " ";
    first->god->transport = " ";
    first->god->weapon = " ";
 
    size++;
    
}
 
List::List(const std::string& val, const std::string& name_of_god, const std::string& mith, const std::string& trans, const std::string& god_weapon)
{
    first = last = new Node;
 
    first->value = val;
    first->succ = nullptr;
    first->prev = nullptr;
 
    first->god = new God;
    first->god->name = name_of_god;
    first->god->mythology = mith;
    first->god->transport = trans;
    first->god->weapon = god_weapon;
 
    size++;
 
}
 
List::~List()
{
    while (first)
    {
        Node* p = first;
        first = first->succ;
        delete p->god;
        delete p;
    }
}
 
Node* List::find(int pos)
{
    if (pos > size)
        return nullptr;
    int i = 0;
    Node* p = first;
    while (i++ < pos)
        p = p->succ;
    return p;
}
 
void List::erase(int pos)
{
    if (pos > size || pos < 0)
    {
        std::cout << "Incorrect pos"<<std::endl;
        exit(-2);
    }
    Node* p = find(pos);
 
    if (p->succ)
        p->succ->prev = p->prev;
    if (p->prev)
        p->prev->succ = p->succ;
    else
        first = p->succ;
    size--;
    delete p->god;
    delete p;
}
 
 
void List::add(std::string name,int pos)
{
 
    Node* temp = new Node;
    temp->god = new God;
    if (pos > size + 1)
    {
        std::cout << "Error: pos>size+1";
        exit(-1);
    }
    temp->value = name;
    if (!size)
    {
        size ++;
        this->first = temp;
        this->last = temp;
        return;
    }
    size += 1;
    Node* p = find(pos);
    if (p)
    {
        temp->prev = p;
 
        if (p->succ)
            p->succ->prev = temp;
        else
            last = temp;
        temp->succ = p->succ;
        p->succ = temp;
    }
    else
    {   
        temp->prev = last;
        temp->prev->succ = temp;
        last = temp;
    }
}
 
void List::add(std::string name, int pos, God* god_data)
{
 
    Node* temp = new Node;
    temp->god = new God;
    if (pos > size + 1)
    {
        std::cout << "Error: pos>size+1";
        exit(-1);
    }
    temp->value = name;
    temp->god->mythology = god_data->mythology;
    temp->god->name = god_data->name;
    temp->god->transport = god_data->transport;
    temp->god->weapon = god_data->weapon;
    if (!size)
    {
        size++;
        this->first = temp;
        this->last = temp;
        return;
    }
    size += 1;
    Node* p = find(pos);
    if (p)
    {
        temp->prev = p;
 
        if (p->succ)
            p->succ->prev = temp;
        else
            last = temp;
        temp->succ = p->succ;
        p->succ = temp;
    }
    else
    {
        temp->prev = last;
        temp->prev->succ = temp;
        last = temp;
    }
}

#include <iostream>
using namespace std;
 
struct TNode{
    int val;
    TNode* next=nullptr;
};
using pNode = TNode*;
 
struct List{
    int val;
    List* next=nullptr;
    ~List(){
        // что то там мутим
    }
};
 
int main()
{
    pNode root = new TNode();
    // root, нода нашего списка, он остается нодой, его удалением,
    // delete root, и всех его последующих элементов, занимается объемлющий его код
    // в данном случаем функция main()
    // Это список - представленный одной нодой.
    
    List list_or_not_list; // не список, хоть и может работать при должном извращении
    
    return 0;
}

struct _Fwd_list_node_base{
 /// ....
       _Fwd_list_node_base* _M_next = nullptr;
}

template<typename _Tp, typename _Alloc>
    struct _Fwd_list_base
    { 
    _Fwd_list_node_base _M_head;

  template<typename _Tp, typename _Alloc>
    struct _Fwd_list_base
    {
    protected:
      typedef __alloc_rebind<_Alloc, _Fwd_list_node<_Tp>> _Node_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
 
      struct _Fwd_list_impl
      : public _Node_alloc_type
      {
    _Fwd_list_node_base _M_head;
         ...
      };
        _Fwd_list_impl _M_impl; 
      ....
};

struct Class{
   Class field;
};