时间戳

首页 > 解决方案 > 将“提取器”传递给也采用可迭代对象的 C++ 方法

c++ - 将“提取器”传递给也采用可迭代对象的 C++ 方法

问题描述

我写了一个实用函数，它允许我将 a 的元素写入 astd::vector并std::ostream用分隔符分隔。（我知道关于实现这一目标还有另一个问题，但这个问题是关于为什么我的实现不起作用。）

template<typename I, typename S>
struct Joiner {
    const I &iterable;
    const S &separator;
};

template<typename I, typename S>
inline auto join(const I &iterable, const S &separator) -> const Joiner<I, S> {
    return Joiner<I, S>{iterable, separator};
}

template<typename I, typename S>
std::ostream &operator<<(std::ostream &stream, const Joiner<I, S> &joiner) {
    auto i = joiner.iterable.begin();
    auto end = joiner.iterable.end();
    if (i != end) {
        stream << *i++;
        while (i != end) {
            stream << joiner.separator << *i++;
        }
    }
    return stream;
}

这里没有什么不寻常的。

但有时里面vector的东西不是我想要输出的东西。例如，它可能是 avector<int *>并且我想输出int值，而不是指针。

所以我想，与其假设要打印的值是*i，不如传入一个“提取器”，以便在vector<int *>I 的情况下可以指定**i.

我尝试了几种方法来做到这一点，但并没有真正走到一起。我目前的想法是模板参数X是 eXtracted 类型，并且该join方法应该采用std::function返回该类型的 a 。提取器函数的参数类型为I::iterator.

template<typename I, typename S, typename X>
struct Joiner {
    const I &iterable;
    const S &separator;
    const std::function<X(typename I::iterator)> extract;
};

template<typename I, typename S, typename X>
inline auto join(const I &iterable, const S &separator, std::function<X(typename I::iterator)> extract) -> const Joiner<I, S, X> {
    return Joiner<I, S, X>{iterable, separator, extract};
}

然后，在operator <<实现中，我使用joiner.extract(i++)而不是*i++.

但是，这不起作用。我写了这个测试程序：

int main(int argc, char *argv[]) {
    int a = 5;
    int b = 20;
    int c = 25;
    std::vector<int *> v{&a, &b, &c};
    std::cout << join<std::vector<int *>, std::string, int>(v, ",", [](std::vector<int *>::iterator i) { return **i; }) << std::endl;
}

编译时出现如下错误：

/Users/wboyce/git/mathias/util.hpp:31:19: error: no matching function for call to object of type 'const std::function<int (typename vector<int *, allocator<int *> >::iterator)>' (aka 'const function<int (__wrap_iter<int **>)>')
    stream << joiner.extract(i++);
              ^~~~~~~~~~~~~~
/Users/wboyce/git/mathias/scratch.cpp:19:15: note: in instantiation of function template specialization 'operator<<<std::__1::vector<int *, std::__1::allocator<int *> >, std::__1::basic_string<char>, int>' requested here
    std::cout << join<std::vector<int *>, std::string, int>(v, ",", [](const std::vector<int *>::iterator i) { return **i; }) << std::endl;
              ^
/usr/local/opt/llvm/bin/../include/c++/v1/functional:2255:9: note: candidate function not viable: no known conversion from '__wrap_iter<int *const *>' to '__wrap_iter<int **>' for 1st argument
    _Rp operator()(_ArgTypes...) const;

我认为我的麻烦的根源是可迭代类型，I但我正在使用它，const I &这意味着迭代器将返回类似const I::iterator但这里的东西对我来说变得模糊的地方。

这甚至是正确的方法吗？我最初认为这X将是提取器函数本身的类型......但我也无法做到这一点。

标签： c++templatesstd

解决方案

使用的主要原因（或主要原因之一）std::function是需要类型擦除时。

这里不需要类型擦除。

#include <iostream>
#include <functional>
#include <vector>

template<typename I, typename S, typename E>
struct Joiner {
    const I &iterable;
    const S &separator;
    E e;
};

template<typename I, typename S, typename E>
inline auto join(const I &iterable, const S &separator,
         E &&e) -> const Joiner<I, S, E> {
    return Joiner<I, S, E>{iterable, separator, std::forward<E>(e)};
}

template<typename I, typename S, typename E>
std::ostream &operator<<(std::ostream &stream, const Joiner<I, S, E> &joiner) {
    auto i = joiner.iterable.begin();
    auto end = joiner.iterable.end();
    if (i != end) {
        stream << joiner.e(*i++);
        while (i != end) {
            stream << joiner.separator << joiner.e(*i++);
        }
    }
    return stream;
}

int main(int argc, char *argv[]) {
    int a = 5;
    int b = 20;
    int c = 25;
    std::vector<int *> v{&a, &b, &c};

    std::cout << join(v, ",", [](int *p) { return *p; }) << std::endl;

}

推荐阅读