假设我有以下 Data 类:

struct Data {
   char foo[8];
   char bar;
};

和以下函数，my_algorithm，它采用一对 char *(类似于 STL 算法):

void my_algorithm(char *first, char *last);

对于 Data 的 foo 数据成员，而不是像这样调用 my_algorithm():

Data data;
my_algorithm(data.foo, data.foo + 8);

我可以使用 std::begin()和 std::end()便捷功能模板:

my_algorithm(std::begin(data.foo), std::end(data.foo));

我想实现类似于Data 的bar 数据成员的东西。也就是说，而不是写:

my_algorithm(&data.bar, &data.bar + 1);

我想写这样的东西:

my_algorithm(begin(data.bar), end(data.bar));

因此，我为这种情况定义了以下两个普通(非模板)函数:

char* begin(char& c) { return &c; }
char*   end(char& c) { return &c + 1; }

这样我就可以编写如下代码:

Data data;

using std::begin;
using std::end;

my_algorithm(begin(data.foo), end(data.foo)); // ok - std::begin()/std::end()
my_algorithm(begin(data.bar), end(data.bar)); // Error!!!

使用上面的 using 声明我会期望 std::begin()/std::end() 和 ::begin()/::end() 分别在同一个重载集中。由于函数 ::begin() 和 ::end() 是后一个调用的完美匹配并且它们不是模板，所以我希望最后一次调用my_algorithm() 来匹配它们。但是，根本不考虑普通功能。结果编译失败，因为 std::begin() 和 std::end() 与调用不匹配。

基本上，后一个调用就像我写的一样:

my_algorithm(begin<>(data.bar), end<>(data.bar));

也就是说，只有函数模板(即 std::begin()/std::end())被重载决议过程考虑，而不是普通函数(即不是 ::begin()/::end())。

如果我完全限定对 ::begin()/::end() 的调用，它只会按预期工作:

my_algorithm(::begin(data.bar), ::end(data.bar));

我在这里错过了什么？

最佳答案

让我们得到一个完整的、可重现的例子:

#include <iterator>

char* begin(char& c) { return &c; }
char*   end(char& c) { return &c + 1; }

namespace ns {
    void my_algorithm(char *first, char *last);

    void my_function() {
        using std::begin;
        using std::end;

        char c = '0';
        my_algorithm(begin(c), end(c));
    }
}

当您对begin(c) 和end(c) 进行非限定调用时，编译器会经历unqualified name lookup 的过程。 (在 Argument-dependent lookup page of cppreference 中描述)。

对于常规的非限定名称查找，该过程大致从您当前所在的命名空间开始——在本例中为 ::ns——并且只有在找不到具体名称。

如果函数调用是不合格的，如此处的 begin(c) 和 end(c)，argument dependent lookup可以发生，它通过查找“关联的命名空间”扩展重载集的过程，找到在与函数参数类型相同的命名空间中声明的自由函数。

然而，在这种情况下，char 是一种基本类型，因此依赖于参数的查找不允许我们找到全局 ::begin 和 : :end 函数。

For arguments of fundamental type, the associated set of namespaces and classes is empty

^{cppreference: argument dependent lookup}

相反，因为我们已经有了 using std::begin;使用 std::end;，编译器已经看到了 begin(...) 和 end(...) 的可能函数——即定义在命名空间 ::std——无需将命名空间从 ::ns 移出到 ::。因此，编译器使用这些函数，编译失败。

值得注意的是 using std::begin;使用 std::end; 还会阻止编译器找到自定义的 ::begin 和 ::end ，即使您将它们放在 中也是如此::ns.

您可以改为编写自己的begin 和end:

#include <iterator>

namespace ns {
    char* begin(char& c) { return &c; }
    char*   end(char& c) { return &c + 1; }

    template <typename T>
    auto begin(T&& t) {
        using std::begin;
        // Not unbounded recursion if there's no `std::begin(t)`
        // or ADL `begin(t)`, for the same reason that our
        // char* begin(char& c); overload isn't found with
        // using std::begin; begin(c);
        return begin(t);
    }

    template <typename T>
    auto end(T&& t) {
        using std::end;
        return end(t);
    }

    void my_algorithm(char *first, char *last);

    void my_function() {
        char c = '0';
        my_algorithm(ns::begin(c), ns::end(c));
    }
}

关于c++ - 为非数组重载 std::begin() 和 std::end()，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56432036/