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

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;

build_instances 中的 value_type 别名将改为

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

最后，我觉得 build_instance 采用 T 参数但构造 some_type<T> 的实例有点奇怪。如果它使用T 并构造了T 的实例（其中T 可能被限制为some_type 的特化。）这也可以避免你的问题。