对专用模板成员的未定义引用
Undefined reference to specialized template member
我有一个 class 由带有静态成员函数的模板模板 class 参数化:
template <template <typename> class F>
struct A {
static int foo();
};
此 class 没有 foo
的默认定义,必须专门针对不同的类型。
我还有另一个 class 由带有嵌套模板 class 的模板模板 class 参数化:
template <template <typename> class F>
struct B {
template <typename T>
struct C {};
};
我希望 C
专门化 A
任何已经专门化 A
的模板模板 class F
:
template <template <typename> class F>
struct A<B<F>::template C> {
static int foo();
};
template <template <typename> class F>
int A<B<F>::template C>::foo() {
return A<F>::foo() / 2;
}
所以,如果我有一个 class 专门 A
:
template <typename T>
struct E {};
template <>
int A<E>::foo() {
return 42;
}
我希望能够像这样使用专业化(和 return 21):
int bar() {
return A<B<E>::template C>::foo();
}
但是,这无法 link - 它找不到对 A<B<E>::C>::foo()
的引用。
(请注意,所有这些都在一个文件中 - 这里的 headers 没有发生任何奇怪的事情)
看来编译器正在尝试使用 A
的主模板而不是特化,这意味着 foo
未定义。为什么在这种情况下不使用专业化?
完整示例
template <template <typename> class F>
struct A {
static int foo();
};
template <template <typename> class F>
struct B {
template <typename T>
struct C {};
};
template <template <typename> class F>
struct A<B<F>::template C> {
static int foo();
};
template <template <typename> class F>
int A<B<F>::template C>::foo() {
return A<F>::foo() / 2;
}
template <typename T>
struct E {};
template <>
int A<E>::foo() {
return 42;
}
int bar() {
// Link fails - error: undefined reference to 'A<B<E>::C>::foo()'
return A<B<E>::template C>::foo();
}
template<class T>
struct A {};
template<class T>
struct B {
using type=T;
};
template<class T>
struct A<typename B<T>::type> {};
这基本相同,但少了 1 个模板层。
这也不行。
问题是 B<T>::type
或 B<T>::template Z
或其他任何东西,在一般情况下,是一个任意的编译时函数。
为了对其进行模式匹配,我们需要反转这个任意编译时函数。
标准说 "compilers don't have to do that",这是您可以在这里做的为数不多的理智的事情之一。它肯定是针对类型说的;对于模板,嗯,模板模板参数的标准措辞通常缺少细节,所以如果缺少措辞我不会感到惊讶。但如果不是,那将是标准中的错误。
为了从
template<class T>
struct A<typename B<T>::type> {};
要查看 A<foo>
是否匹配它,它必须测试所有类型 T
以查看其中哪些类型的 B<T>::type
等于 foo
。
这可能不是您打算要问的,但这就是您要问的。
您的模板示例也是如此。
template <template <typename> class F>
struct A<B<F>::template C> {
static int foo();
};
你要求编译器检查每个类型 F
这样如果你将它传递给任意模板 B<>
然后在其中计算 ::C
,模板匹配什么你正在通过 A
.
第一个有趣的案例:
template<class X>
struct C0 {};
template <template <typename> class F>
struct B {
template <typename T>
using C=C0<X>:
};
现在,A<C0>
中的 F
是什么?每个 F
都符合条件。
template<class X>
struct C0 {};
template <template <typename> class F, class=void>
struct B {
template <typename T>
using C=C0<X>:
};
template<class X>
struct C1 {};
template <template <typename> class F, class=void>
struct B<
F,
std::enable_if_t<
proves_collatz_conjecture( F<int>::value )
>
> {
template <typename T>
using C=C1<T>;
};
现在要模式化 mach A<C0>
,编译器必须生成 F
,这样 F<int>::value
是一个编译时类型,当传递给 proves_collatz_conjecture
returns true
在编译时。
那会有用。
模板专业化是模式匹配。在 C++ 中,您不能对依赖类型(可能还有模板)进行模式匹配,因为类型和模板都没有超出其值的标识。
您无法检查定义变量、类型或模板的范围。因此您也无法对其进行模式匹配。
如果你想做你想做的事,模板 C
本身必须有一个 属性 你可以检查和测试。
我有一个 class 由带有静态成员函数的模板模板 class 参数化:
template <template <typename> class F>
struct A {
static int foo();
};
此 class 没有 foo
的默认定义,必须专门针对不同的类型。
我还有另一个 class 由带有嵌套模板 class 的模板模板 class 参数化:
template <template <typename> class F>
struct B {
template <typename T>
struct C {};
};
我希望 C
专门化 A
任何已经专门化 A
的模板模板 class F
:
template <template <typename> class F>
struct A<B<F>::template C> {
static int foo();
};
template <template <typename> class F>
int A<B<F>::template C>::foo() {
return A<F>::foo() / 2;
}
所以,如果我有一个 class 专门 A
:
template <typename T>
struct E {};
template <>
int A<E>::foo() {
return 42;
}
我希望能够像这样使用专业化(和 return 21):
int bar() {
return A<B<E>::template C>::foo();
}
但是,这无法 link - 它找不到对 A<B<E>::C>::foo()
的引用。
(请注意,所有这些都在一个文件中 - 这里的 headers 没有发生任何奇怪的事情)
看来编译器正在尝试使用 A
的主模板而不是特化,这意味着 foo
未定义。为什么在这种情况下不使用专业化?
完整示例
template <template <typename> class F>
struct A {
static int foo();
};
template <template <typename> class F>
struct B {
template <typename T>
struct C {};
};
template <template <typename> class F>
struct A<B<F>::template C> {
static int foo();
};
template <template <typename> class F>
int A<B<F>::template C>::foo() {
return A<F>::foo() / 2;
}
template <typename T>
struct E {};
template <>
int A<E>::foo() {
return 42;
}
int bar() {
// Link fails - error: undefined reference to 'A<B<E>::C>::foo()'
return A<B<E>::template C>::foo();
}
template<class T>
struct A {};
template<class T>
struct B {
using type=T;
};
template<class T>
struct A<typename B<T>::type> {};
这基本相同,但少了 1 个模板层。
这也不行。
问题是 B<T>::type
或 B<T>::template Z
或其他任何东西,在一般情况下,是一个任意的编译时函数。
为了对其进行模式匹配,我们需要反转这个任意编译时函数。
标准说 "compilers don't have to do that",这是您可以在这里做的为数不多的理智的事情之一。它肯定是针对类型说的;对于模板,嗯,模板模板参数的标准措辞通常缺少细节,所以如果缺少措辞我不会感到惊讶。但如果不是,那将是标准中的错误。
为了从
template<class T>
struct A<typename B<T>::type> {};
要查看 A<foo>
是否匹配它,它必须测试所有类型 T
以查看其中哪些类型的 B<T>::type
等于 foo
。
这可能不是您打算要问的,但这就是您要问的。
您的模板示例也是如此。
template <template <typename> class F>
struct A<B<F>::template C> {
static int foo();
};
你要求编译器检查每个类型 F
这样如果你将它传递给任意模板 B<>
然后在其中计算 ::C
,模板匹配什么你正在通过 A
.
第一个有趣的案例:
template<class X>
struct C0 {};
template <template <typename> class F>
struct B {
template <typename T>
using C=C0<X>:
};
现在,A<C0>
中的 F
是什么?每个 F
都符合条件。
template<class X>
struct C0 {};
template <template <typename> class F, class=void>
struct B {
template <typename T>
using C=C0<X>:
};
template<class X>
struct C1 {};
template <template <typename> class F, class=void>
struct B<
F,
std::enable_if_t<
proves_collatz_conjecture( F<int>::value )
>
> {
template <typename T>
using C=C1<T>;
};
现在要模式化 mach A<C0>
,编译器必须生成 F
,这样 F<int>::value
是一个编译时类型,当传递给 proves_collatz_conjecture
returns true
在编译时。
那会有用。
模板专业化是模式匹配。在 C++ 中,您不能对依赖类型(可能还有模板)进行模式匹配,因为类型和模板都没有超出其值的标识。
您无法检查定义变量、类型或模板的范围。因此您也无法对其进行模式匹配。
如果你想做你想做的事,模板 C
本身必须有一个 属性 你可以检查和测试。