在使用递归的、基于概念的函数模板推导 'auto' 之前使用“auto [...]”

Question

我想创建一个 deep_flatten 函数模板，该模板将生成 range 个深度 join 的元素。例如，如果我们只考虑嵌套的 std::vectors，我可以有：

template <typename T>
struct is_vector : public std::false_type { };

template <typename T, typename A>
struct is_vector<std::vector<T, A>> : public std::true_type { };

template <typename T>
auto deepFlatten(const std::vector<std::vector<T>>& vec) {
    using namespace std::ranges;
    if constexpr (is_vector<T>::value) {
        auto range = vec | views::join;
        return deepFlatten(std::vector(range.begin(), range.end()));
    } else {
        auto range = vec | views::join;
        return std::vector(range.begin(), range.end());
    }
}

这使我能够做到：

std::vector<std::vector<std::vector<int>>> nested_vectors = {
        {{1, 2, 3}, {4, 5}, {6}},
        {{7},       {8, 9}, {10, 11, 12}},
        {{13}}
};

std::ranges::copy(
        deep_flatten(nested_vectors),
        std::ostream_iterator<int>(std::cout, " ")
);

它按预期将以下文本打印到控制台中：

1 2 3 4 5 6 7 8 9 10 11 12 13

但是，我不太喜欢这个解决方案。它不仅效率低下（创建许多临时向量），而且它也只适用于 std::vectors。我认为我可以使用更多 c++20 魔法并使用 std::ranges::range 概念：

namespace rng {
    template <std::ranges::range Rng>
    auto deep_flatten(Rng&& rng) {
        using namespace std::ranges;

        if constexpr (range<Rng>) {
            return deep_flatten(rng | views::join);
        } else {
            return rng | views::join;
        }
    }
}

这在我看来非常简单 - 我们有一个 std::ranges::range 并且我们检查它的值类型。根据它是否是嵌套范围，我们递归或简单地 return joined 元素。

遗憾的是，它不起作用。尝试后运行:

int main() {
    std::set<std::vector<std::list<int>>> nested_ranges = {
            {{1, 2, 3}, {4, 5}, {6}},
            {{7},       {8, 9}, {10, 11, 12}},
            {{13}}
    };

    std::ranges::copy(
            rng::deep_flatten(nested_ranges),
            std::ostream_iterator<int>(std::cout, " ")
    );
}

我收到一条错误消息：

In instantiation of 'auto rng::deep_flatten(Rng&&) [with Rng = std::ranges::join_view<std::ranges::ref_view<std::set<std::vector<std::__cxx11::list<int> > > > >]':
     required from 'auto rng::deep_flatten(Rng&&) [with Rng = std::set<std::vector<std::__cxx11::list<int> > >&]'
     required from here
     error: use of 'auto rng::deep_flatten(Rng&&) [with Rng = std::ranges::join_view<std::ranges::ref_view<std::set<std::vector<std::__cxx11::list<int> > > > >]' before deduction of 'auto'
     39 |             return deep_flatten(rng | views::join);
        |                    ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~

研究过类似的问题，实在搞不懂为什么会出现这个错误。

我正在使用 gcc version 10.1.0 (Rev3, Built by MSYS2 project)

Answer 1

这里有两个问题。

第一个问题是你的：

namespace rng {
    template <std::ranges::range Rng>
    auto deep_flatten(Rng&& rng) {
        using namespace std::ranges;

        if constexpr (range<Rng>) { // <==
            return deep_flatten(rng | views::join);
        } else {
            return rng | views::join;
        }
    }
}

这个函数是无限递归的。 deep_flatten 受约束 range<Rng>，因此那里的 if constexpr 检查始终为真，因此我们永远不会进入基本情况。这只是一个错误——我们正在检查错误的东西，这不是我们是否是一个范围，而是我们的基础值是否是一个范围。那是：

namespace rng {
    template <typename Rng>
    auto deep_flatten(Rng&& rng) {
        using namespace std::ranges;

        auto joined = rng | views::join;    
        if constexpr (range<range_value_t<decltype(joined)>>) {
            return deep_flatten(joined);
        } else {
            return joined;
        }
    }
}

这里我们进入第二个问题，这是标准库的问题。 rng | views::join 的意思是：

The name views::join denotes a range adaptor object ([range.adaptor.object]). Given a subexpression E, the expression views::join(E) is expression-equivalent to join_view{E}.

但是 join_view{E} 对于已经是 join_view 的特化的 E... 现在是 no-op 因为 class 模板参数推导(CTAD) - 复制推导候选是最佳候选，所以我们的嵌套 join 操作实际上变成了单个 join。您最初的实现解决了这个问题，因为它不是 join-ing a join_view，它总是 join-ing vectors.

我已经提交了LWG 3474。

与此同时，我们可以通过直接使用 join_view 并显式指定模板参数来解决 views::join 问题：

namespace rng {
    template <typename Rng>
    auto deep_flatten(Rng&& rng) {
        using namespace std::ranges;


        auto joined = join_view<views::all_t<Rng>>(rng);

        if constexpr (range<range_value_t<decltype(joined)>>) {
            return deep_flatten(joined);
        } else {
            return joined;
        }
    }
}

这有效。

在使用递归的、基于概念的函数模板推导 'auto' 之前使用“auto [...]”

Use of 'auto [...] 'before deduction of 'auto' with recursive, concept-based function template

c++

c++-concepts

c++20

std-ranges