Контейнеры, способные хранить данные произвольных (различных) типов

std::vector<std::pair<ElementType, void*>>

//Title of this code
//Compiler Version 18.00.21005.1 for x86
 
#include <iostream>
#include <vector>
#include <boost/any.hpp> //<--- позиционируется, как "безопасный контейнер любых типов"
                                          // хотят тот ещё тормоз
int main()
{
    std::cout << "Hello, world!\n";
    
    typedef ::std::vector<::boost::any>
        container;
    
    
    container example;
    
    example.emplace_back(10);
    example.emplace_back(true);
    example.emplace_back("hello");
    
    for(const auto& i: example)
        ::std::cout<<"type of element: '"<<i.type().name()<<"'\n";
}

...
 
void foo(int){}
 
struct bar
{
   void work(){}
};
 
...
 
int main()
{
    typedef std::vector<connector>
        connectors;
 
    connectors con;
 
    con.emplace_back(&foo); //<--- нацеливание на свободную функцию
 
    bar obj;
 
    con.emplace_back(obj, &bar::work); //<--- нацеливание на метод класса
 
    con[0](10); // <--- эквивалент foo(10);
    con[1]();    // <--- эквивалент obj.work();
}

class Stack
{
private:
    struct Node
    {
        Node* prev = nullptr;
        unsigned char* data = nullptr;
    } *last = nullptr;
 
public:
    Stack() {}
 
    ~Stack()
    {
        while (last) pop();
    }
 
    template<typename T>
    void push(const T &data)
    {
        static_assert(!std::is_pointer<T>::value, "Type should not be a pointer");
        Node* tmp = new Node;
        tmp->prev = last;
        T* ptr = new T;
        *ptr = data;
        tmp->data = (unsigned char*) ptr;
        last = tmp;
    }
 
    void pop()
    {
        if (!last) return;
        delete last->data;
        Node* tmp = last->prev;
        delete last;
        last = tmp;
    }
 
    template<typename T>
    const T& peek() const
    {
        if (!last) throw("Stack is empty");
        return *((T*) last->data);
    }
};

#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <functional>
 
template<typename F>
class holder;
 
class connector
{
    std::shared_ptr<connector> mPtr;
public:
    connector() = default;
    virtual ~connector() = default;
 
    template<typename F, typename... Args>
    explicit connector(const F& f, Args&&... args) : mPtr(new holder<F>(f, std::forward<Args>(args)...)) {}
 
    virtual void call() const { mPtr->call(); }
 
    void operator ()() const {call();}
};
 
template<typename F>
class holder : public connector
{
    std::function<void()> func;
public:
    template <typename... Args>
    holder(const F& f, Args&&... args) : func(std::bind(f, std::forward<Args>(args)...)) {}
 
    virtual void call() const override { func(); }
};
 
////////////////////////////////////////////////////////////////////////////////
 
void foo() {std::cout << "void foo()\n";}
 
void foo1(const std::string& s, int val)
{
   std::cout << s << " " << val << "\n";
}
 
int foo2(const std::string& s, int val, double d)
{
   std::cout << s << " " << val << " " << d << "\n";
   return val;
}
 
struct Foo {
   void operator ()(int val) const {std::cout << "Foo::operator(int)\n";}
};
 
int main()
{
   std::vector<connector> con;
   con.emplace_back(foo);
   con.emplace_back(foo1, "Hello", 42);
   con.emplace_back(foo2, "world", 84, 12.2);
   con.emplace_back(std::bind(Foo(), 42));
 
   for (auto &f : con) f();
}