Список переменных через шаблон

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
 
 
class list {
private:
    size_t lenght = 0;
    size_t tempPosition = 0;
    
protected:
    template <typename type> struct Node {
        struct Node<void> * prev = nullptr;
        type var;   // Any variable carrier (except for other STL lists)
        struct Node<void> * next = nullptr;
    };
    
    Node<void> * head = nullptr;
    Node<void> * tail = nullptr;
    Node<void> * temp = nullptr;
    
public:
    template <typename type> inline void insert(type var) { //Inserting element
        if (this->head == nullptr) { // check if list is empty
            this->head = new Node<void>(); // If so, allocate the head
            this->head->var = var; // Fill the head
            this->temp = this->head; //Define pointers
            this->tail = this->head;
        } else {
            this->tail->next = new Node<void>(); //If no, allocate the next
            this->tail->next->var = var; // Fill the next
            this->tail->next->prev = this->tail; //Make prev of next to current
            this->tail = this->tail->next; //Move tail to next
        }
        this->lenght++; // Increase size of list var
        return;
    }
    
    inline void print_list(void) {
        Node<void> * ptr = this->head; // Make iteratable pointer
        while (ptr != this->tail) { // Iterated untill end
            std::cout << ptr->var; // Print value
            ptr = ptr->next;
        }
    }
    
    inline bool empty(void) { // Return bool if list is empty
        if (this->head == nullptr)
            return true;
        return false;
    }
    
    inline size_t size(void) { // Return size of list
        return this->lenght;
    }
};
 
int main(void) {
    list array;
    array.insert(5);
    array.insert("World");
    array.insert('?');
    array.print_list();
    return EXIT_SUCCESS;
}

std::list<std::variant<тут_перечислить_типы>> array;

#include <iostream>
#include <string>
#include <vector>
#include <variant>
 
 
int main() 
{
    std::vector<std::variant<int, char, std::string>> vct{'g', 56, "gh"};
    for (auto const& var : vct)
    {
        if(std::holds_alternative<int>(var))
            std::cout << std::get<int>(var) << " ";
        else if (std::holds_alternative<char>(var))
            std::cout << std::get<char>(var) << " ";
        else
            std::cout << std::get<std::string>(var) << " ";
    }
}

if(std::holds_alternative<int>(var))
    std::cout << std::get<int>(var) << " ";
else if (std::holds_alternative<char>(var))
    std::cout << std::get<char>(var) << " ";
else if (std::holds_alternative<std::string>(var))
    std::cout << std::get<std::string>(var) << " ";
else if (std::holds_alternative<long int>(var))
    std::cout << std::get<long int>(var) << " ";
else if (std::holds_alternative<long long int>(var))
    std::cout << std::get<long long int>(var) << " ";
и так далее

for(auto const& var : std::list<std::variant<char, int, std::string>>{'1', 'a', "hello world", 3991})
  std::visit([](auto const& val){ std::cout << val << " | "; }, var);

int main(void) {
    std::deque<std::variant<
    int,
    short int,
    unsigned int,
    unsigned short int,
    long int,
    long long int,
    unsigned long int,
    unsigned long long int,
    const long int,
    const long long int,
    size_t,
    ssize_t,
    double,
    float,
    const double,
    const float,
    std::string,
    char,
    int *,
    char *,
    const int,
    const double,
    const float,
    const char,
    const unsigned int,
    const unsigned long int,
    const unsigned long long int,
    const unsigned short int,
    user_size_t,
    const std::string,
    const size_t,
    const ssize_t,
    const user_size_t,
    int64_t,
    int32_t,
    int8_t,
    int16_t,
    intmax_t,
    intptr_t,
    const int64_t,
    const int32_t,
    const int8_t,
    const int16_t,
    const intmax_t,
    const intptr_t,
    const char *,
    const int *,
    double *,
    float *,
    const double *,
    const float *,
    std::fstream,
    std::ofstream,
    std::streambuf,
    std::streampos,
    std::streamoff>> d;
     
    return EXIT_SUCCESS;
}

struct lambda {
  template<class T>
  auto operator()(T const& val) { std::cout << val << " | "; }
};
 
//...
 
std::visit(lambda{}, var);