Как реализовать стек, хранящий разные типы данных одновременно?

#include <cstdlib>
#include <cmath>
#include <ctime>
#include <iostream>
 
template<class T>
class Stack {
 private:
  struct Node {
    T data;
    Node *prev;  
    Node(const T &data, Node *prev) : data(data), prev(prev) {}
  };
 
  int size;
  Node *head;
 public:
  class Iterator {
   public:
    Iterator(Node *node) : node(node) {}
    Iterator &operator++(int) {
      node = node->prev;
      return *this;
    }
    Iterator operator++() {
      Iterator result = Iterator(node);
      node = node->prev;
      return result;
    }
    const T &operator*() {
      return node->data;
    }
    bool operator!=(const Iterator &o) {
      return node != o.node;
    }
   private:
    Node *node;
  };
 
  Stack() : size(0), head(0) {}
  ~Stack() {
    clear();
  }
  const T &peek() const {
    return head.data;
  }
  T pop() {
    T data = head->data;
    Node *first = head;
    head = first->prev;
    delete first;
    size--;
    return data;
  }
  void push(const T &data) {
    size++;
    head = new Node(data, head);
  }
  int getSize() const {
    return size;
  }
  void clear() {
    while (size > 0) {
      pop();
    }
  }
  Iterator begin() {
    return Iterator(head);
  }
  Iterator end() {
    return Iterator(0);
  }
};
 
int main(int, char**) {
/*
  // так правильно
  Stack<int> stack;
  stack.push(1);
  stack.push(2);
  stack.push(3);
  std::cout << "Size: " << stack.getSize() << std::endl;
 
  for (Stack<int>::Iterator i = stack.begin(); i != stack.end(); ++i) {
    std::cout << *i << std::endl;
  }
  while (stack.getSize() > 0) {
    std::cout << stack.pop() << std::endl;
  }
*/
  // так неправильно
  Stack<void*> voidStack;
 
  voidStack.push(new std::string("text"));
  voidStack.push(new int(9));
 
  int *x = (int*)voidStack.pop();
  std::cout << *x << std::endl;
  delete x;
 
  std::string *y = (std::string*)voidStack.pop();
  std::cout << *y << std::endl;
  delete y;
 
  return 0;
}

#include <boost/any.hpp>
#include <iostream>
#include <stack>
 
 
using stack = std::stack<boost::any>;
 
void view(const stack&);
 
int main()
{
    std::cout << "Hello, world!\n";
    
    stack mystack;
    
    mystack.emplace(10);
    mystack.emplace( std::string( "afefearg") );
    
    view(mystack);
}
 
void view(const stack& src)
{
    stack s = src;
    while(!s.empty())
    {
        const auto el = s.top();
        s.pop();
        
        if( el.type() == typeid(int) )
            std::cout << boost::any_cast<int>(el) 
                << std::endl;
        else if (el.type() == typeid(std::string))
            std::cout << boost::any_cast<std::string>(el) 
                << std::endl;
    }
}