#include <iostream>
#include <fstream>
#include <memory>
#include <vector>

    // dense boilerplate, obsolete in C++1y:
    template<unsigned...>struct indexes{typedef indexes type;};
    template<unsigned Max,unsigned...Is>struct make_indexes:make_indexes<Max-1,Max-1,Is...>{};
    template<unsigned...Is>struct make_indexes<0,Is...>:indexes<Is...>{};
    template<unsigned Max>using make_indexes_t=typename make_indexes<Max>::type;

    template<typename T>using type=T;

    template<typename... Args>
    struct up_maker {
      std::tuple<Args...> args;
      template<class T, class...Ds, unsigned...Is>
      std::unique_ptr<T,Ds...> helper( indexes<Is...> ) && {
        return std::unique_ptr<T,Ds...>( new T(std::forward<Args>( std::get<Is>(args) )...) );
      }
      template<class T, class...Ds>
      operator type<std::unique_ptr<T,Ds...>>() && {
        return std::move(*this).helper<T,Ds...>( make_indexes_t< sizeof...(Args) >{} );
      }
      explicit up_maker( Args&&... args_in ):args( std::forward<Args>(args_in)... ) {}
      up_maker( up_maker const& ) = delete;
      up_maker( up_maker && ) = default;
      up_maker& operator=( up_maker const& ) = delete;
      up_maker& operator=( up_maker && ) = default;
    };

    template<typename...Args>
    up_maker<Args...> make_up( Args&&... args ) {
      return up_maker<Args...>( std::forward<Args>(args)... );
    }



int main() {
    std::vector<std::unique_ptr<std::ofstream>> v;
    v.emplace_back(make_up("file1.txt"));
    v.emplace_back(make_up("file2.txt"));
    for (int i = 0, ilen = v.size(); i < ilen; ++i)
      (*v[i]) << "Test" << i << std::endl;
}