如何推断迭代器模板类型或其模板的嵌套类型？

Question

此问题引出了更准备，所以我首先提供的码的一些比特，然后将确切问题

假设我有以下类型声明

template<typename T> 
struct some_type 
{ 
    T t_; 
}; 

这将与工厂函数来构造，像这样

typedef float numeric_type; 
std::vector<std::string> construction_material; 
//Push_back of strings in certain form... 
std::vector<std::unique_ptr<some_type<numeric_type>> instances; 
build_instances(construction_material.begin(), construction_material.end(), back_inserter(instances)); 

和建设中的作用将是像以下

template<typename input_iterator, typename output_iterator> 
output_iterator build_instances(input_iterator begin, input_iterator end, output_iterator out) 
{ 
    for(input_iterator iter = begin; iter != end; ++iter) 
    { 
     //This won't work, but to illustrate some ideas... 
     //build_instance<std::iterator_traits<output_iterator>::value_type>(*iter) 
    } 

    //[...] 

    return *out; 
} 

template<typename T> 
std::unique_ptr<some_type<T>> build_instance(std::string const& material) 
{ 
    static_assert(std::is_floating_point<T>::value == true, "The template type needs to be a floating point type."); 

    std::unique_ptr<some_instance<T>> instance(new some_instance<T>()); 
    //Some processing... 

    return instance; 
} 

我知道我可以改变函数返回一些容器（或者甚至模板化容器类型），像

template<typename input_iterator, typename T> 
std::vector<std::unique_type<T>> build_instances(input_iterator begin, input_iterator end,  
output_iterator out) 
{ 
    //Likewise code to the previous snippets... 
    return ... 
} 

我一直没能解决的问题是：

1. 使用back_inserter类似的方法有可能 - 或不可能吗？它看起来对于呼叫者来说是最灵活的？
2. 如何获得在build_instances体上numeric_type保持（如拥有它通过output_iterator），以便它可以在建设情况一个接一个被使用？
3. 如何确保调用者知道要等待包装在std :: unique_ptrs中的对象？另一种选择就像普通的指针一样，但我对此不感兴趣。

对于标题How can I make this template method more elegant? (or: less explicit template parameters required)，有一个类似的问题，它接受一个容器并将其转换为不同类型的容器。

编辑 作为评论到Jogojapan的评论，目前我将输入像这样

std::transform(construction_material.begin(), construction_material.end(), std::inserter(instances, instances.begin()), build_instance<numeric_type>); 

，但随后的函数调用需要提供的 numeric_type的typedef过，这是有点麻烦。我希望避免这种情况。 看起来我错了，但为了教育和所有的目的，是否可以进一步减少typedef数字类型的需求并从迭代器中推导出它？

Answer 1

一个管闲事的解决办法是让some_type暴露了它的类型参数，以同样的方式std::unique_ptr<T, D>通过element_type暴露了其第一个参数（我们将在以后需要）：

template<typename T> 
struct some_type 
{ 
    // give it an appropriate meaningful name 
    using value_type = T; 
    value_type t_; 
}; 

template<typename input_iterator, typename output_iterator> 
output_iterator build_instances(input_iterator begin, input_iterator end, output_iterator out) 
{ 
    using pointer_type = typename std::iterator_traits<output_iterator>::value_type; 
    using value_type = typename pointer_type::element_type::value_type; 
    return std::transform(begin, end, out, build_instance<value_type>); 
} 

您也可以以非侵入提取的第模板专业化的模板参数：

template<typename T> 
struct first; 

template<template<typename...> class Template, typename First, typename... Pack> 
struct first<Template<First, Pack...>>> { 
    using type = First; 
}; 

template<typename T> 
using First = typename first<T>::type; 

的value_type别名build_instances反而会成为

using value_type = First<typename pointer_type::element_type>; 

作为最后的一句话我觉得有些奇怪，build_instance采取T参数，但构建的some_type<T>实例。如果花费了T并构建了T的实例（其中T限制为some_type的专业化）。这也可以避免你的问题。