可能之前有人问过,但这一切已经接近我对C++的理解和认知的极限,所以我在理解正在谈论的内容和到底发生了什么方面有点慢。让我直接跳到代码。这有效:
template <typename T>
class Foo
{
struct Bar
{
Bar() {}
~Bar() noexcept {}
Bar(Bar&& b) : Bar() { swap(*this, b); }
friend void swap(Bar& b1, Bar& b2) { /* ... */ }
};
};
template class Foo<int>; // explicit instantiation of Foo with int type
但是我该如何移动 swap
的定义呢?在Bar
之外结构体?如果我这样做:
template <typename T>
class Foo {
struct Bar {
// ...
Bar(Bar&& b) : Bar() { swap(*this, b); } // line 16
// ...
template <typename V>
friend void swap(typename Foo<V>::Bar&, typename Foo<V>::Bar&);
};
};
template <typename T>
void swap(typename Foo<T>::Bar& b1, typename Foo<T>::Bar& b2) {} // line 26
template class Foo<int>; // line 31
g++(4.7.1,标志:-Wall -std=c++11)报告:
main.cpp: In instantiation of ‘Foo<T>::Bar::Bar(Foo<T>::Bar&&)
[with T = int; Foo<T>::Bar = Foo<int>::Bar]’:
main.cpp:31:16: required from here
main.cpp:16:28: error: no matching function for call to
‘swap(Foo<int>::Bar&, Foo<int>::Bar&)’
main.cpp:16:28: note: candidate is:
main.cpp:26:6: note: template<class T> void swap(typename Foo<T>::Bar&,
typename Foo<T>::Bar&)
main.cpp:26:6: note: template argument deduction/substitution failed:
main.cpp:16:28: note: couldn't deduce template parameter ‘T’
我猜 swap
的代码显式实例化时也需要创建 Foo
,这是有道理的,但为什么编译器不能弄清楚 swap(Foo<int>::Bar&...)
需要创建?为什么模板替换失败?还是我都弄错了?
更新 1
与:
template <typename T> class Foo;
template <typename T>
void swap(typename Foo<T>::Bar& b1, typename Foo<T>::Bar& b2);
template <typename T>
class Foo {
struct Bar {
Bar(Bar&& b) : Bar() { swap(*this, b); } // line 19
friend void swap<>(Foo<T>::Bar& b1, Foo<T>::Bar& b2); // line 20
};
};
template <typename T>
void swap(typename Foo<T>::Bar& b1, typename Foo<T>::Bar& b2) {} // line 26
template class Foo<int>; // line 29
g++(4.7.1,标志:-Wall -std=c++11)报告:
main.cpp: In instantiation of ‘struct Foo<int>::Bar’:
main.cpp:29:16: required from here
main.cpp:20:17: error: template-id ‘swap<>’ for ‘void swap(Foo<int>::Bar&, Foo<int>::Bar&)’ does not match any template declaration
main.cpp: In instantiation of ‘Foo<T>::Bar::Bar(Foo<T>::Bar&&) [with T = int; Foo<T>::Bar = Foo<int>::Bar]’:
main.cpp:29:16: required from here
main.cpp:19:24: error: no matching function for call to ‘Foo<int>::Bar::Bar()’
main.cpp:19:24: note: candidate is:
main.cpp:19:5: note: Foo<T>::Bar::Bar(Foo<T>::Bar&&) [with T = int; Foo<T>::Bar = Foo<int>::Bar]
main.cpp:19:5: note: candidate expects 1 argument, 0 provided
main.cpp:19:28: error: no matching function for call to ‘swap(Foo<int>::Bar&, Foo<int>::Bar&)’
main.cpp:19:28: note: candidate is:
main.cpp:26:8: note: template<class T> void swap(typename Foo<T>::Bar&, typename Foo<T>::Bar&)
main.cpp:26:8: note: template argument deduction/substitution failed:
main.cpp:19:28: note: couldn't deduce template parameter ‘T’
更新 2
好的,所以这是不可能的。 Piotr 已链接到 Output a nested class inside a template ,但我不明白答案。为什么不能swap
在其声明之外定义?据我(错误)理解,为什么编译器不能为 swap(Foo<int>::Bar&...)
创建代码并在代码中链接到它以显式实例化 Foo<int>
?我完全误解了发生了什么吗?有什么问题?
更新 3
好的,这不能完成,因为如果有模板特化,编译器不能保证调用swap
。在 Foo
之外定义自 Foo<some_class>::Bar
以来是明确的在特定专业中可能是完全不同的东西。我希望我做对了。但是,为什么在我创建 Foo
的显式实例化之前 g++ 不警告我这一点? ?
template <typename T>
class Foo {
struct Bar {
// ...
Bar(Bar&& b) : Bar() { swap(*this, b); }
// ...
template <typename V>
friend void swap(typename Foo<V>::Bar&, typename Foo<V>::Bar&);
};
};
template <typename T>
void swap(typename Foo<T>::Bar& b1, typename Foo<T>::Bar& b2) {}
//template class Foo<int>; // let's comment this explicit instantiation out.
此代码编译良好(g++ 4.7.1,标志:-Wall -std=c++11)。但是,它不应该警告我这段代码可能会导致问题吗?当我添加 Foo
的显式实例化时,问题不在于该行本身,而在于 swap
在 Foo
之外实现的代码.
最佳答案
问题不在于 friend
.
问题出在这个函数本身:
template <typename T>
void swap(typename Foo<T>::Bar& b1, typename Foo<T>::Bar& b2) {} // line 26
推导模板参数T
来自嵌套类是不可能的,请参阅:Output a nested class inside a template甚至更好的答案是:https://stackoverflow.com/a/4092248/1463922
举例说明为什么它不能完成,考虑这个函数:
template <class T>
void foo(typename A<T>::Bar);
还有这个 A 定义:
template <class T>
struct A { typedef int Bar; };
这个电话:
int a;
foo(a);
什么是 T
在这个例子中?是int
因为A<int>::Bar
是int
, 或 float
因为
A<float>::Bar
是int
太或任何你想要的......问题是你正在调用什么功能foo<int>(int)
或 foo<float>(int)
或者……
或者举个更接近问题的例子:
template <class T>
struct Foo {
struct Bar {};
};
看来编译器在解决这个问题上应该没有问题:
template <class T>
void resolve(typename Foo<T>::Bar*);
但编译器即使在这里也有问题,因为它不确定某些其他类的特化是否不会使用其他类的内部结构,如下所示:
template <class T>
struct Foo<T*> {
typedef Foo<T>::Bar Bar;
};
因此:
Foo<void>::Bar b;
resolve(&b);
编译器没有机会知道调用哪个版本:
resolve<void>(Foo<void>::Bar*);
// or
resolve<void*>(Foo<void>::Bar*);
// ^
我能给你什么建议 - 使用内联 friend - 但用其他一些模板类来实现它。这行得通 - 但我确信这有点过度设计:
template <class S>
class ImplementSwap;
template <typename T>
class Foo {
public:
struct Bar {
int a;
Bar() {}
~Bar() {}
friend class ImplementSwap<Foo<T>>;
friend void swap(Foo<T>::Bar& b1, Foo<T>::Bar& b2)
{ ImplementSwap<Foo<T>>::doSwap(b1, b2); }
Bar(Bar&& b) { swap(*this, b); }
};
};
template <class T>
class ImplementSwap<Foo<T>> {
public:
static void doSwap(typename Foo<T>::Bar&,typename Foo<T>::Bar&);
};
template <class T>
void ImplementSwap<Foo<T>>::doSwap(typename Foo<T>::Bar&,typename Foo<T>::Bar&)
{
// this one is not inline....
}
我公开了 Bar 来做这个测试:
Foo<int>::Bar a = Foo<int>::Bar(); // move constructor
int main() {
swap(a,a); // explicit swap
}
<罢工> [老的] 我之前的回答是完全错误的,第一条评论引用它。 罢工>
<罢工>friend void swap<>(typename Foo<T>::Bar&, typename Foo<T>::Bar&);
// ^^
罢工><罢工>[/OLD] 罢工>
关于c++ - 如何显式实例化具有友元函数嵌套类的模板类 (C++),我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/12875679/