模板好友语法

Template Friending syntax

本文关键字：语法 好友      更新时间：2023-10-16

>假设我有两个模板类。

template<class T>
class baseclass1
{
template<class> friend class baseclass2;
}
template<class D>
class baseclass2
{
template<class T> void foo( D& x, T& y)
{
...
}
}

上面的代码允许所有类型的baseclass1与所有类型的baseclass2成为朋友，一种多对多的关系。我有两个问题，

允许 baseclass1 只与函数交朋友的语法是什么

baseclass2<class D>::foo<class T>( D& x, T& y).

而且，允许baseclass1只与函数交朋友的语法是什么

baseclass2<class D>::foo<class T>( D& x, T& y)来自baseclass1的T与函数foo中的T匹配

。编辑

对于那些一直声称你不能与模板专业化成为朋友的人。 此代码有效

template<class cake>
class foo
{
public:
static void bar(cake x)
{
cout << x.x;
}
};

class pie
{
public:
void set( int y){ x = y; }
private:
int x;
friend void foo<pie>::bar(pie x);
};
class muffin
{
public:
void set( int y){ x = y; }
private:
int x;
friend void foo<pie>::bar(pie x);
};
int main
{
pie x;
x.set(5);
foo<pie>::bar(x);
muffin y;
y.set(5);
//foo<muffin>::foo(y); //Causes a compilation Error because I only friended the pie specialization
}

即使注意到松饼朋友哪里错了foo，仍然会导致编译错误。 这适用于函数和类。我完全愿意接受这在我的特定情况下是不可能的(实际上看起来越来越这样)，我只是想了解为什么。

与baseclass2<D>::foo的所有可能专业交朋友相当容易：

template<class T> class baseclass1;
template<class D>
class baseclass2{
public:
template<class T>
void foo(D&, T&){ baseclass1<T> x; x.priv_foo(); }
};
template<class T>
class baseclass1{
template<class D>
template<class U>
friend void baseclass2<D>::foo(D&, U&);
void priv_foo(){}
};
template<class T>
class baseclass1{
template<class D>
template<class U>
friend void baseclass2<D>::foo(D&, U&);
};

活生生的例子。

baseclass2的前向声明(因此baseclass1知道baseclass2存在并且是一个模板)和两个模板，一个用于类，一个用于函数。对于类模板的函数模板的类外定义，它看起来也是这样。:)

但是，baseclass2<D>::foo<T>专门交朋友是不可能的，或者我找不到 它的正确语法。

解决方法可能是一些转发访问的全局函数以及密钥模式，但呃，这是一团糟(恕我直言)：

template<class D> class baseclass2;
template<class D, class T>
void baseclass2_foo(baseclass2<D>& b, D&, T&);
template<class D, class T>
class baseclass2_foo_key{
baseclass2_foo_key(){} // private ctor
friend void baseclass2_foo<>(baseclass2<D>&, D&, T&);
};
template<class T>
class baseclass1{
public: // public access, but only baseclass2_foo can create the key
template<class D>
void priv_foo(baseclass2_foo_key<D, T> const&){}
};
template<class D, class T>
void baseclass2_foo(baseclass2<D>&, D&, T&){
baseclass1<T> x;
x.priv_foo(baseclass2_foo_key<D, T>());
}
template<class D>
class baseclass2{
public:
template<class T>
void foo(D& d, T& t){ baseclass2_foo(*this, d, t); }
};

活生生的例子。

AFAIK 您可以将foo的所有实例化指定为好友，但不能指定特定的实例化：

template< class T >
class C1 {
public:
template< class Q > void foo( T& x, Q& y ) {
}
};
template< class T >
class C2 {
template< class Y > 
template< class Q > friend void C1<Y>::foo( Y&, Q& );
};
相关文章：