模板类型的约束 假设，我想在C++中实现一个通用的高级代码 map 函数。code>Map应该使用容器和转换函数，并返回相同类型的容器，但可能包含不同类型的项

让我们以向量为例：

template <typename InT, typename OutT, typename Tr>
vector<OutT> Map(vector<InT> cont, Tr tr)
{
    OutCont out(cont.size());
    auto oit = out.begin();
    for (auto it = cont.cbegin(); it != cont.cend(); ++it, ++ot)
    {
        *oit = tr(*it);
    }
}

---

你可以这样写：

template <typename InT, typename Tr>
auto Map(std::vector<InT> cont, Tr tr) -> std::vector<decltype(tr(cont[0]))>
{
    std::vector<decltype(tr(cont[0]))> out(cont.size());
    auto oit = out.begin();
    for (auto it = cont.cbegin(); it != cont.cend(); ++it, ++oit)
    {
        *oit = tr(*it);
    }
    return out;
}

模板
自动映射（std:：vector cont，Tr Tr）->std:：vector
{
标准：：矢量输出（cont.size（））；
auto oit=out.begin（）；
对于（自动it=cont.cbegin（）；it！=cont.cend（）；++it，++oit）
{
*oit=tr（*it）；
}
返回；
}

导出了输出类型

[编辑] 对于具有更多容器的更通用的函数：

template <template<typename, typename...> class Container, typename InT, typename Tr, typename... Args>
auto Map(const Container<InT, Args...>& cont, Tr tr) -> Container<decltype(tr(cont[0])), Args...>
{
    Container<decltype(tr(cont[0])), Args...> out(cont.size());
    auto oit = out.begin();
    for (auto it = cont.cbegin(); it != cont.cend(); ++it, ++oit)
    {
        *oit = tr(*it);
    }
    return out;
}

模板
自动映射（const容器和cont，Tr）->Container
{
集装箱出口（续尺寸（））；
auto oit=out.begin（）；
对于（自动it=cont.cbegin（）；it！=cont.cend（）；++it，++oit）
{
*oit=tr（*it）；
}
返回；
}

---

请注意所需的

typename…

，因为

std:：vector

也可以使用分配器

不相关，但是命名函数

map

有点混乱，因为

std:：map

。函数编程

map

=

std:：transform

。迭代器实际上是允许您在C++中通过容器进行泛型编程的方法：使用它们。我将其更改为

Map

。应该消除混淆。您应该使用迭代器顺便说一句，您可以使用

decltype

指定输出类型谢谢。这就是我需要的。仍然存在一个问题，就是如何将其用于泛型类型，而不仅仅是向量。

template <typename Cont<InT>, typename Cont<OutT>, typename Tr<InT, OutT>>
Cont<OutT> Map(Cont<InT> cont, Tr<InT, OutT> tr)
{
    // Implementation
}

template <typename InT, typename Tr>
auto Map(std::vector<InT> cont, Tr tr) -> std::vector<decltype(tr(cont[0]))>
{
    std::vector<decltype(tr(cont[0]))> out(cont.size());
    auto oit = out.begin();
    for (auto it = cont.cbegin(); it != cont.cend(); ++it, ++oit)
    {
        *oit = tr(*it);
    }
    return out;
}

template <template<typename, typename...> class Container, typename InT, typename Tr, typename... Args>
auto Map(const Container<InT, Args...>& cont, Tr tr) -> Container<decltype(tr(cont[0])), Args...>
{
    Container<decltype(tr(cont[0])), Args...> out(cont.size());
    auto oit = out.begin();
    for (auto it = cont.cbegin(); it != cont.cend(); ++it, ++oit)
    {
        *oit = tr(*it);
    }
    return out;
}