c++ 模板类的 友元函数

 #pragma once
 #include <iostream>

 template <class T>
 class stack
 {
     template <class Ty>
     friend std::ostream& operator<<(std::ostream& os, const stack<Ty>& s);
 public:
     explicit stack<T>(int maxSize);
     stack<T>(const stack<T>& s);
     stack<T>(stack<T>&&) = delete;
     stack<T>& operator=(const stack& s);
     stack<T>& operator=(stack<T>&&) = delete;
     ~stack<T>();

     void push(T e);
     bool pop(T& e);
     bool getTop(T& e) const;

     bool isEmpty() const;
     int getNumElems() const;

 private:
     T* elems;
     int top;
     int maxSize;
     void overflowProcess();
 };

 template <class T>
 std::ostream& operator<<(std::ostream& os,const stack<T>& s)
 {
     for (int i = ; i <= s.top; i++)
     {
         std::cout << s.elems[i] << " ";
     }
     return os;
 }

 template <class T>
 stack<T>::stack(int maxSize_): top(-), maxSize(maxSize_)
 {
     this->elems = new T[this->maxSize];
 }

 template <class T>
 stack<T>::stack(const stack<T>& s)
 {
     this->top = s.top;
     this->maxSize = s.maxSize;
     this->elems = new T[this->maxSize];
     memcpy_s(this->elems, sizeof(T) * maxSize, s.elems, sizeof(T) * maxSize);
 }

 template <class T>
 stack<T>& stack<T>::operator=(const stack& s)
 {
     if (this == &s) return *this;
     if (this->elems != nullptr)delete[] elems;
     this->top = s.top;
     this->maxSize = s.maxSize;
     this->elems = new T[maxSize];
     memcpy_s(this->elems, sizeof(T) * maxSize, s.elems, sizeof(T) * maxSize);
     return *this;
 }

 template <class T>
 stack<T>::~stack()
 {
     if (this->elems != nullptr)
         delete[] elems;
 }

 template <class T>
 void stack<T>::push(T e)
 {
     if (this->top == maxSize - )
     {
         overflowProcess();
     }
     this->elems[++top] = e;
 }

 template <class T>
 bool stack<T>::pop(T& e)
 {
     if (!isEmpty())
     {
         e = this->elems[top--];
         return true;
     }
     return false;
 }

 template <class T>
 bool stack<T>::getTop(T& e) const
 {
     if (!isEmpty())
     {
         e = elems[top];
         return true;
     }
     return false;
 }

 template <class T>
 bool stack<T>::isEmpty() const
 {
     return top == - ? true : false;
 }

 template <class T>
 int stack<T>::getNumElems() const
 {
     return top + ;
 }

 template <class T>
 void stack<T>::overflowProcess()
 {
     T* new_elems = new T[maxSize + maxSize / ];
     memcpy_s(new_elems, sizeof(T) * maxSize, this->elems, sizeof(T) * maxSize);
     delete[] elems;
     this->elems = new_elems;
 }

代码长；懒得剪。。。。一个具备基本功能的栈类；可以直接使用

里面用到了：  模板友元函数   在类外定义的前面要加上template<class Ty> 以示区分

因此：  模板友元函数：类内定义       无需 template<class Ty>  /////其实这个还不确定，下次试试就知道了

类内声明，类外定义：需要tempalte<class Ty>