Question

作为练习，我正在尝试在C ++中实现Python的join()方法。我最终将该函数添加为std::string类的方法，但我认为让它工作更为重要。我已经将函数定义如下：

template<typename Iterable>
std::string join(const std::string sep, Iterable iter);

有什么方法可以确保Iterable类型实际上是可迭代的？例如。我不希望收到int或char ..

Answer 1

在C ++中，我们将迭代器（几乎是指针）传递给范围的前端和末尾，而不是只有一个Files.deleteIfExists(outputFile.toPath());：

Iterable

请注意，template<typename Iter> std::string join(const std::string &sep, Iter begin, Iter end);应作为const 引用传递，因为您不需要复制它。

但是，您不必担心sep实际上是否是迭代器。这是因为如果代码不起作用，代码将无法编译。

例如，假设你是这样实现的（这是一个糟糕的实现）：

Iter

然后，作为template<typename Iter> std::string join(const std::string &sep, Iter begin, Iter end) { std::string result; while (begin != end) { result += *begin; ++begin; if (begin != end) result += sep; } return result; }传递的类型必须有Iter，operator++和operator!=才能工作，这是一个很好理解的迭代器合约。

Answer 2

您可以使用模板模板语法，如果需要，可以使用SFINAE来确保存在适当的类成员：

#include <vector>
#include <list>
#include <string>
#include <map>
#include <ostream>

//! Single value containers.
template< template<class> class L, class T,
    class EntryT = typename L<T>::value_type>
std::string my_join(const std::string_view sep, const L<T>& anyTypeIterable)
{
    std::stringstream ss;
    bool first = true;
    for (const EntryT& entry : anyTypeIterable)
    {
        if (first) first = false;
        else ss << sep;
        ss << entry;
    }
    return ss.str();
}

//! std::map specialization - SFINAE used here to filter containers with pair value_type
template< template<class, class> class L, class T0, class T1,
    class EntryT = typename L<T0, T1>::value_type,
    class FirstT = typeof(EntryT::first),
    class SecondT = typeof(EntryT::second)>
std::string my_join(const std::string_view sep, const L<T0, T1>& anyTypeIterable)
{
    std::stringstream ss;
    bool first = true;
    for (const EntryT& entry : anyTypeIterable)
    {
        if (first) first = false;
        else ss << sep;
        ss << entry.first << sep << entry.second;
    }
    return ss.str();
}

int main()
{
    std::cout << my_join("; ", std::vector<int>({1, 2, 3, 4})) << std::endl;
    std::cout << my_join("; ", std::list<int>({1, 2, 3, 4})) << std::endl;
    std::cout << my_join("; ", std::string("1234")) << std::endl;
    std::cout << my_join("; ", std::map<int, int>({ {1, 2}, {3, 4} })) << std::endl;
    return 0;
}

// Output:
// 1; 2; 3; 4
// 1; 2; 3; 4
// 1; 2; 3; 4
// 1; 2; 3; 4

Answer 3

所有标准c ++集合都有begin()和end()个成员函数。您可以利用这一事实来确保传递的参数实际上是一些SFINAE（在您的术语中是可迭代的）（c ++ 11示例）：

#include <array>
#include <list>
#include <vector>
#include <map>
#include <string>

template <class Iterable>
auto join(const std::string sep, const Iterable& iterable) -> decltype(iterable.begin(), iterable.end(), std::string{}) {
    (void)sep; // to suppress warning that sep isn't used
    // some implementation
    return {};
}

int main() {
    join(";", std::array<int, 5>{});
    join(";", std::list<int>{});
    join(";", std::vector<float>{});
    join(";", std::string{});
    join(";", std::map<int, float>{});
    //join(";", int{}); // does not compile as int is not a collection
}

[live demo]

Answer 4

来自https://devblogs.microsoft.com/oldnewthing/20190619-00/?p=102599：

template<typename C, typename T = typename C::value_type>
auto do_something_with(C const& container)
{
  for (int v : container) { ... }
}

或者如果容器未实现value_type：

template<typename C, typename T = std::decay_t<decltype(*begin(std::declval<C>()))>>
auto do_something_with(C const& container)
{
  for (int v : container) { ... }
}

或者，如果您只希望包含可转换为int类型的容器：

template<typename C, typename T = std::decay_t<decltype(*begin(std::declval<C>()))>,
    typename = std::enable_if_t<std::is_convertible_v<T, int>>>
auto do_something_with(C const& container)
{
  for (int v : container) { ... }
}

但是请参阅该博客文章中的评论以进行更多改进。

C ++：如何将任何可迭代类型作为函数参数传递

4 个答案: