template<class T,int OTER_SIZE> friend class Stack<T, OTER_SIZE>;友元模板声明无效

如果在类中声明了友元模板类，那么它的模板参数列表需要与被声明类的模板参数列表完全一致，并且需要在类外部再次声明一遍。例如，如果我们在`Stack`类中声明了一个友元模板类`OtherStack`，那么我们需要这样写：

template<class T, int OTHER_SIZE>
class OtherStack;

template<class T, int SIZE>
class Stack {
public:
    // ...
private:
    // ...
    template<class T, int OTHER_SIZE>
    friend class OtherStack;
};

注意，这里的`OtherStack`类模板声明需要在类外部进行，而且模板参数列表需要与类内部声明的完全一致。

相关问题

template<int OTER_SIZE> Stack(const Stack<T,OTER_SIZE>& stac) { this->size = stac.size; this->p = new T[stac.size]; for (int i = 0; i < stac.size; ++i) { this->p[i] = stac.p[i]; } }这段代码显示无法访问private成员

这段代码无法访问`Stack`类的私有成员是因为在拷贝构造函数中，我们尝试访问`size`和`p`成员变量，但是这些成员变量是`Stack`类的私有成员，不能直接从类外部访问。

要解决这个问题，我们可以使用`friend`关键字来声明拷贝构造函数是`Stack`类的友元函数，从而允许它访问`Stack`类的私有成员。修改后的代码如下：

template<class T, int SIZE>
class Stack {
public:
    // 构造函数
    Stack() {
        this->size = SIZE;
        this->p = new T[SIZE];
        memset(this->p, 0, sizeof(T) * SIZE);
    }
    
    // 带参构造函数
    Stack(int n) {
        if (n <= 0)
            n = SIZE;
        this->size = n;
        this->p = new T[n];
        memset(this->p, 0, sizeof(T) * n);
    }
    
    // 拷贝构造函数
    template<int OTHER_SIZE>
    friend class Stack<T, OTHER_SIZE>;
    template<int OTHER_SIZE>
    Stack(const Stack<T, OTHER_SIZE>& stac) {
        this->size = stac.size;
        this->p = new T[stac.size];
        for (int i = 0; i < stac.size; ++i) {
            this->p[i] = stac.p[i];
        }
    }
    
    // 析构函数
    ~Stack() {
        delete[] this->p;
    }
    
private:
    T* p;
    int size;
};

在拷贝构造函数的模板参数列表中，我们添加了一个`friend`声明，将`Stack`类的所有实例都声明为`Stack<T, OTHER_SIZE>`的友元类，从而允许拷贝构造函数访问私有成员`size`和`p`。