C++ 在模板函数中强制进行二次名称查找

Question

有什么方法可以强制 C++ 编译器在模板实例化期间（而不是之前）对给定符号执行名称查找？

给定以下代码：

template <class T>
auto wrapper( T t ) -> decltype( f( t ) )
{
    return f( t );
}

unsigned char f( int x ) { return x % 256; }
unsigned char f( unsigned char x ) { return x; }

int main( int, char ** )
{
    auto x = wrapper( 3100 );
    return 0;
}

有什么我可以做的（除了将 f 的定义移动到顶部之外）以使该代码编译并给出相同的结果，就好像 f 的所有定义都是在定义wrapper?

之前可用

我找不到任何东西，可能是因为我不知道如何正确地表达这个问题。如果有帮助，f 的所有参数类型都可以假定为用户定义的类型。

Answer 1

这适用于模板专业化。请注意，您必须决定默认功能是什么，因为我看不出有问题。

// default function
template <class T>
unsigned char f( T x ) { return x; }

// specialization for int
template <>
unsigned char f( int x ) { return x % 256; }

int main( int, char ** )
{
    auto x = f( 3100 );
    return 0;
}

Answer 2

下面的代码不是很干净，但说明了如何使用 class 模板特化来解决问题。它保持了原来的界面（即 f 和 wrapper 可以像以前一样使用）。

感谢您给我正确的提示。我愿意接受一个不那么冗长的解决方案。

#include <type_traits>

template <class ...>
struct F;

template <class T>
auto wrapper( T t )
    -> decltype( F<typename std::decay<T>::type>::f( t ) )
{
    return F<typename std::decay<T>::type>::f( t );
}

template <>
struct F<unsigned char>
{
    static unsigned char f( unsigned char x ) { return x; }
};

template <>
struct F<int>
{
    static unsigned char f( int x ) { return x % 256; }
};

template <class T>
auto f( T t )
    -> decltype( F<typename std::decay<T>::type>::f( t ) )
{
    return F<typename std::decay<T>::type>::f( t );
}

int main( int, char ** )
{
    auto x = wrapper( 3100 );
    return 0;
}

Answer 3

Is there some way to force C++ compilers to perform name lookup for a given symbol during template instantiation (and not before)?

是的。首先，名称必须是依赖的。 wrapper 中的名称 f 当用作 f(t) 时是依赖的，因为 t 是类型依赖的。 [temp.dep]/1:

In an expression of the form:

postfix-expression ( expression-list _opt )

where the postfix-expression is an unqualified-id, the unqualified-id denotes a dependent name if

any of the expressions in the expression-list is a pack expansion (14.5.3),

any of the expressions in the expression-list is a type-dependent expression (14.6.2.2), or

if the unqualified-id is a template-id in which any of the template arguments depends on a template parameter.

问题是在模板本身之后声明的名称，即仅在实例化而非定义上下文中，只能使用参数相关名称查找 找到。您的 f 重载仅采用基本类型，但根据 [basic.lookup.argdep]/2:

，这些重载没有与之关联的全局命名空间

If T is a fundamental type, its associated sets of namespaces and classes are both empty.

因此，如果参数与参数的类型相同，则永远找不到您声明的 f。一个小技巧可以帮助：

template <typename T>
struct refwrap
{
    T&& t;
    refwrap(T&& t) : t(std::forward<T>(t)) {}
    operator T&&() {return std::forward<T>(t);}
};

template <typename T>
auto make_refwrap( T&& t ) -> refwrap<T> // making use of reference collapsing
{ return {std::forward<T>(t)}; }         // inside refwrap to get forwarding

当在全局命名空间中声明此模板时，ADL 会考虑它。重写wrapper如下：

template <class T>
auto wrapper( T t ) -> decltype( f( make_refwrap(t) ) )
{
    return f( make_refwrap(t) );
}

Demo。但这不是正确的方法，因为在更复杂的情况下它会失败。

C++ 在模板函数中强制进行二次名称查找

C++ enforce second-pass name lookup in template function

c++

templates

name-lookup