Dependency injection

jinject.cpp

#include <iostream>
#include <type_traits>
#include <tuple>
#include <memory>

template <typename T, typename ...Args>
T inject(Args ...args) {
    if constexpr (!std::is_pointer_v<T>) {
        return T{std::forward<Args>(args)...};
    } else {
        using type = typename std::pointer_traits<T>::element_type;

        return new type{std::forward<Args>(args)...};
    }
}

template <typename ...Args>
struct get {
    get(Args ...args): mArgs{args...} {
    }

    template <typename T>
    operator T () {
        return std::apply(::inject<T, Args...>, mArgs);
    }

    template <typename T>
    operator std::shared_ptr<T> () {
        T *value = std::apply(::inject<T*, Args...>, mArgs);

        std::shared_ptr<T> valuePtr{value};

        return valuePtr;
    }

    template <typename T>
    operator std::unique_ptr<T> () {
        T *value = std::apply(::inject<T*, Args...>, mArgs);

        std::unique_ptr<T> valuePtr{value};

        return valuePtr;
    }

    private:
        std::tuple<Args...> mArgs;
};

// ----------------------- tests

struct DefaultConstructor {
    DefaultConstructor() {
        std::cout << "DefaultConstructor\n";
    }
};

struct NoDefaultConstructor {
    NoDefaultConstructor(int i, char const *s) {
        std::cout << "NoDefaultConstructor: " << i << ", " << s << "\n";
    }
};

template <>
NoDefaultConstructor inject(int i, char const *s) {
    std::cout << "inject<custom injection>: " << i << ", " << s << "\n";

    return {i*i, s};
}

void sample(int primitiveType = get{42}, DefaultConstructor defaultConstructor = get{}, NoDefaultConstructor noDefaultConstructor = get{42, "jeff"}) {
}

void sample_ptr(int *primitiveType = get{42}, DefaultConstructor *defaultConstructor = get{}, NoDefaultConstructor *noDefaultConstructor = get{42, "jeff"}) {
}

void sample_shared(std::shared_ptr<int> primitiveType = get{42}, std::shared_ptr<DefaultConstructor> defaultConstructor = get{}, std::shared_ptr<NoDefaultConstructor> noDefaultConstructor = get{42, "jeff"}) {
}

void sample_unique(std::unique_ptr<int> primitiveType = get{42}, std::shared_ptr<DefaultConstructor> defaultConstructor = get{}, std::shared_ptr<NoDefaultConstructor> noDefaultConstructor = get{42, "jeff"}) {
}

int main() {
    sample();
    sample_ptr();
    sample_shared();
}