友元类为模板类怎么声明

友元类对于模板类的声明允许一个类可以访问另一个模板类的私有和保护成员。在C++中，声明一个友元类通常是在模板类的定义中直接指定。这里有一个简单的例子来说明如何为模板类声明友元类：

template <typename T>
class TemplateClass; // 先前向声明模板类

class FriendClass {
public:
    void foo(TemplateClass<int>& obj);
};

template <typename T>
class TemplateClass {
    friend class FriendClass; // 声明FriendClass为友元类
    // ...
};

在这个例子中，`FriendClass` 被声明为 `TemplateClass<T>` 的友元类。这意味着无论 `TemplateClass` 的模板实例化为何种类型，`FriendClass` 都能够访问 `TemplateClass` 的所有成员，包括私有和保护成员。

需要注意的是，友元关系不是对称的，也不是传递的。即如果A是B的友元，B不自动成为A的友元；如果A是B的友元，B是C的友元，A也不自动成为C的友元。

相关问题

声明类模板的友元类

当我们声明一个类模板时，有时候我们需要让某个类能够访问到这个模板类的私有成员或保护成员。这时我们就可以使用友元类来实现。

下面是一个声明类模板的友元类的示例代码：

template<typename T>
class MyTemplateClass {
    friend class MyFriendClass;
public:
    MyTemplateClass(T value);
private:
    T m_value;
};

template<typename T>
MyTemplateClass<T>::MyTemplateClass(T value) : m_value(value) {}

class MyFriendClass {
public:
    template<typename T>
    void printValue(const MyTemplateClass<T>& obj) {
        std::cout << "The value is: " << obj.m_value << std::endl;
    }
};

int main() {
    MyTemplateClass<int> obj(42);
    MyFriendClass friendObj;
    friendObj.printValue(obj);
    return 0;
}

在这个示例代码中，我们声明了一个类模板`MyTemplateClass`，并且声明了一个友元类`MyFriendClass`。通过`friend class MyFriendClass;`语句，我们将`MyFriendClass`声明为`MyTemplateClass`的友元类，这意味着`MyFriendClass`可以访问到`MyTemplateClass`的私有成员或保护成员。

在`MyFriendClass`中，我们定义了一个模板函数`printValue`，该函数接受一个`MyTemplateClass`类型的对象作为参数，并打印出这个对象的私有成员`m_value`。在`main`函数中，我们实例化了一个`MyTemplateClass`对象，并创建了一个`MyFriendClass`对象`friendObj`，然后通过`friendObj.printValue(obj)`调用了`MyFriendClass`的`printValue`函数，输出了`MyTemplateClass`对象的私有成员值。

将一个类模板声明为另一个类模板的友元类

如果你想让一个类模板成为另一个类模板的友元类，你可以将该类模板的实例化版本作为友元类声明。当然，你也可以将该类模板本身作为友元类声明，这样将会允许该类模板的所有实例化版本都作为友元类。

下面是一个将一个类模板声明为另一个类模板的友元类的示例代码：

template<typename T>
class MyTemplateClass {
public:
    MyTemplateClass(T value);
    void printValue();
private:
    T m_value;
};

template<typename T>
MyTemplateClass<T>::MyTemplateClass(T value) : m_value(value) {}

template<typename T>
void MyTemplateClass<T>::printValue() {
    std::cout << "The value is: " << m_value << std::endl;
}

template<typename T>
class MyFriendClass {
public:
    void printValue(const MyTemplateClass<T>& obj) {
        std::cout << "The value is: " << obj.m_value << std::endl;
    }
};

int main() {
    MyTemplateClass<int> obj(42);
    MyFriendClass<int> friendObj;
    friendObj.printValue(obj);
    return 0;
}

在这个示例代码中，我们定义了一个类模板`MyTemplateClass`，和另一个类模板`MyFriendClass`。我们将`MyFriendClass`声明为`MyTemplateClass`的友元类，并在`MyFriendClass`中定义了一个成员函数`printValue`，该函数接受一个`MyTemplateClass`类型的对象作为参数，并打印出这个对象的私有成员`m_value`。

在`main`函数中，我们实例化了一个`MyTemplateClass`对象，并创建了一个`MyFriendClass`对象`friendObj`，然后通过`friendObj.printValue(obj)`调用了`MyFriendClass`的`printValue`函数，输出了`MyTemplateClass`对象的私有成员值。

需要注意的是，我们在实例化`MyFriendClass`的时候传入了模板参数`int`，这样才能够使`MyFriendClass`和`MyTemplateClass<int>`成为友元类。如果你想使用其他类型，你需要进行相应的实例化。