21

考虑一个接受一个或多个参数（例如文件名）的函数。为了使其具有通用性，将其编写为通用迭代器范围是有利的：

template<class Iter>
void function(Iter first, Iter last)
{
  // do something
}

现在我们可以通过以下方式调用它，与我们如何存储参数无关：

WhateverContainer container;
function(std::begin(container), std::end(container));

例如，STL 严重依赖这种范式。

现在，假设我们想要使用未存储在容器中的单个参数调用该函数。我们当然可以写：

const int value = 5;
std::vector<int> vec(1, value);
function(std::begin(vec), std::end(vec));

但是这个解决方案对我来说似乎很笨拙和浪费。

问题：是否有更好的低开销方法来创建单个变量的迭代器范围兼容表示？

4

4 回答 4

33

您可以一次性使用指针：

function(&value, &value + 1);

在通用代码中，根据您的偏执程度，std::addressof而不是一元运算符更安全一些。&

您当然可以将其包装在重载中以便于使用：

template <class T>
decltype(auto) function (T &&e) {
    auto p = std::addressof(e);
    return function(p, p + 1);
}
于 2018-05-04T11:28:34.700 回答
13

您可以将其视为每个[expr.unary.op]/3一个元素的数组：

function(&value, &value + 1);

出于指针算术 ([expr.add]) 和比较 ([expr.rel], [expr.eq]) 的目的，不是以这种方式获取地址的数组元素的对象被认为属于数组有一个类型为 T 的元素。

于 2018-05-04T11:28:35.027 回答
6

您还可以为单元素范围重载函数模板：function

template<typename Iter>
void function(Iter first) {
    return function(first, std::next(first)); // calls your original function
}

这样，您的原始函数function仍然与迭代器范围兼容。但是请注意，将此重载与空范围一起使用将导致未定义的行为。

对于单个元素，value您可以使用上面的重载：

function(&value); // calls overload

由于运算符&可能会重载，因此请考虑使用std::addressof而不是，如本答案&中已经提到的那样。

对于由单个元素组成的范围，您也可以使用上面的重载，它只需要一个迭代器而不是迭代器对：

const int value = 5;
std::vector<int> vec(1, value); // single-element collection
function(std::begin(vec)); // <-- calls overload
于 2018-05-04T11:38:33.937 回答
2

我想我会分两步做到这一点：

  1. 定义一个使用容器的模板函数的重载，以迭代器版本的形式编写。

  2. 定义一个代理类，它将对象引用视为大小为 1 的数组。

c++17 示例：

#include <iterator>
#include <type_traits>
#include <vector>
#include <iostream>

// proxy object
template<class T>
struct object_as_container
{
    using value_type = T;
    using iterator = T*;
    using const_iterator = std::add_const_t<T>;

    object_as_container(value_type& val) : object_(val) {}

    const_iterator begin() const { return std::addressof(object_); }
    iterator begin() { return std::addressof(object_); }

    const_iterator end() const { return std::next(begin()); }
    iterator end() { return std::next(begin()); }

private:
    value_type& object_;
};

// our function in terms of iterators    
template<class Iter> void func(Iter first, Iter last)
{
    while(first != last)
    {
        std::cout << *first++;
    }
}

// our function in terms of containers
template<class Container> void func(Container&& cont)
{
    func(cont.begin(), cont.end());
}

int main()
{
    const int value = 5;
    func(object_as_container(value));
    func(std::vector { 1,2,3,4,5 });
}
于 2018-05-04T11:41:35.323 回答