Question

我对模板上下文中的函数名查找感到困惑。我知道编译器会在模板化代码中延迟依赖于参数的标识符查找，直到模板被实例化。这意味着您有时会在模板化代码中出现语法错误或调用不存在的函数，除非您实际实例化模板，否则编译器不会抱怨。

但是，我发现不同的编译器之间存在差异，我很想知道标准本身需要什么。

请考虑以下代码：

#include <iostream>

class Foo
{
    public:

    template <class T>
    void bar(T v)
    {
        do_something(v);
    }
};

void do_something(std::string s)
{
    std::cout << "do_something(std::string)" << std::endl;
}

void do_something(int x)
{
    std::cout << "do_something(int)" << std::endl;
}

int main()
{
    Foo f;
    f.bar("abc");
    f.bar(123);
}

请注意，模板成员函数Foo::bar调用名为do_something的非参数依赖的全局函数，其中 甚至未被声明爱好。

然而，GCC 4.6.3将很乐意编译上述程序。运行时，输出为：

do_something(std::string)
do_something(int)

Here's an ideone link

因此，看起来好像编译器延迟了标识符查找，直到模板被实例化之后，此时它才能找到do_something。

相反，GCC 4.7.2将不编译上述程序。它会产生以下错误：

test.cc: In instantiation of ‘void Foo::bar(T) [with T = const char*]’:
test.cc:27:13:   required from here
test.cc:10:3: error: ‘do_something’ was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation [-fpermissive]
test.cc:19:6: note: ‘void do_something(int)’ declared here, later in the translation unit

因此，GCC 4.7.2知道稍后声明do_something，但拒绝编译程序，因为do_something不依赖于参数。

所以，我假设GCC 4.7.2在这里可能是正确的，而GCC 4.6.3是不正确的。因此，我可能需要在定义do_something之前声明Foo::bar。这个问题是假设我想允许我的班级Foo的用户通过实现他们自己的Foo::bar重载来扩展do_something的行为。我需要写一些类似的东西：

#include <iostream>

template <class T>
void do_something(T v)
{
    std::cout << "do_something(T)" << std::endl;
}

class Foo
{
    public:

    template <class T>
    void bar(T v)
    {
        do_something(v);
    }
};

void do_something(int x)
{
    std::cout << "do_something(int)" << std::endl;
}

int main()
{
    Foo f;
    f.bar("abc");
    f.bar(123);
}

这里的问题是do_something的重载在Foo::bar内是不可见的，因此从未被调用过。因此，即使我致电do_something(int)，它也会调用do_something(T)而不是int的重载。因此，对于GCC 4.6.3和GCC 4.7.2，上述程序输出：

do_something(T)
do_something(T)

那么这里有什么解决方案？如何通过实现Foo::bar？

的重载来允许用户扩展do_something

Answer 1

就重载do_something而言，您需要专门化原始模板：

template<>
void do_something<int>(int x) {
    std::cout << "do_something(int)" << std::endl;
}

编辑：@MatthieuM。指出，如果你还需要重载函数，函数模板特化可以产生奇怪的结果（并且在某些时候你可能需要，因为函数模板不能部分专门化）。有关完整说明，请参阅Matthieu与Herb Sutter的文章Why Not Specialize Function Templates?的链接。

建议使用包含在结构中的静态函数，它允许部分特化并删除重载函数模板附带的名称解析问题。

template<typename T>
struct DoSomething {
    static void do_something(T v) {
        std::cout << "do_something(T)" << std::endl;
    }
};

struct Foo
{
    template <class T>
    void bar(T v) {
        DoSomething<T>::do_something(v);
    }
};

// Now you can specialize safely
template<>
struct DoSomething<int> {
    static void do_something(int v) {
        std::cout << "do_something(int)" << std::endl;
    }
};

模板中依赖于参数的查找

1 个答案: