About non-intrusive polymorphism

#include <stdio.h>
#include <ostream>
#include <iostream>
#include <vector>

void f(int i) {
    std::cout << "int: " << i << std::endl;
};

void f(const std::string& str) {
    std::cout << "std::string: " << str << std::endl;
}

struct Poly {
public:
    template<typename T>
    Poly(T&& data) :
        ptr(new derived<T>(std::forward<T>(data))) {
    }

    void f() {
        ptr->f();
    }

private:
    struct base {
        virtual void f() = 0;
        virtual ~base() = default;
    };

    template<typename T>
    struct derived : base {
        T data;

        derived(T&& data) :
            data(std::forward<T>(data)) {
        }

        void f() override {
            ::f(data);
        }
    };

    base* ptr;
};

int main(int argc, char** argv) {
    std::vector<Poly> objects;

    objects.emplace_back(1);
    objects.emplace_back("hello world!");

    for (Poly& o : objects) {
        o.f();
    }
}