C++复习之模板（自己要验证，才能更好掌握）

布满荆棘的人生 2023-07-25 06:23 40阅读 0赞

### C++复习之模板 ###

*   *  友元函数
     *  友元类
     *  静态
     *  运算符重载
     *  函数模板
     *  类模板

## 友元函数 ##

#include <iostream>
    
    using namespace std;
    
    class Coordinate
    {
        
        friend void printXY(Coordinate &c);
    public:
        Coordinate(int x,int y);
    private:
        int m_iX;
        int m_iY;
    };
    Coordinate::Coordinate(int x,int y)
    {
        
        m_iX = x;
        m_iY = y;
    }
    void printXY(Coordinate &c)
    {
        
        cout<<c.m_iX<<","<<c.m_iY;
    }
    
    int main()
    {
        
        Coordinate coor(3,5);
        printXY(coor);
        return 0;
    }

## 友元类 ##

class Circle;
    class Coordinate
    {
        
        friend Circle;
        friend void printXY(Coordinate &c);
    public:
        Coordinate(int x,int y);
    private:
        int m_iX;
        int m_iY;
    };
    
    class Circle
    {
        
    public:
        void printXY()
        {
        
            cout<<m_coor.m_iX<<m_coor.m_iY;
        }
    private:
        Coordinate m_coor;
    };在这里插入代码片

友元关系不可传递；  
友元关系具有单向性；  
友元声明的形式和数量不受限制；  
友元只是封装的补充，设计巧妙可以避开就更好，不然会暴露数据。

## 静态 ##

#include <iostream>
    
    using namespace std;
    
    class Tank
    {
        
    public:
        Tank(){
        s_iCount++;}
        ~Tank(){
        s_iCount--;}
        static int getCount(){
        return s_iCount;}
        static int s_iCount;
    private:
        string m_strCode;
    };
    int Tank::s_iCount = 0;
    
    int main()
    {
        
        cout<<Tank::getCount()<<endl;
        cout<<Tank::s_iCount<<endl;
        Tank tank;
        cout<<tank.getCount()<<endl;
        cout<<tank.s_iCount<<endl;
        return 0;
    }

静态的成员函数只能操作静态数据。  
因为静态是随类存在，编译的。  
静态数据成员必须单独 初始化。  
静态数据成员只有一份，且不依赖对象而存在，求一个对象的大小时是不包含静态数据的。

## 运算符重载 ##

本质：函数重载  
关键字：operator  
**一元运算符的重载**

\-负号的重载：  
成员函数的重载：

#include <iostream>
    
    using namespace std;
    
    class Coordinate
    {
        
    public:
        Coordinate(int x, int y);
        Coordinate& operator-();
    private:
        int m_iX;
        int m_iY;
    };
    
    Coordinate::Coordinate(int x, int y)
    {
        
        m_iX = x;
        m_iY = y;
    }
    
    Coordinate& Coordinate::operator-()
    {
        
        m_iX = -m_iX;
        m_iY = -m_iY;
        return *this;
    }
    
    int main()
    {
        
        Coordinate coor1(3,5);
    
        -coor1;  //等价于coor1.operator-();
        return 0;
    }

友元函数重载：

#include <iostream>
    
    using namespace std;
    
    class Coordinate
    {
        
        friend Coordinate operator-(Coordinate &coor);
    public:
        Coordinate(int x, int y);
    private:
        int m_iX;
        int m_iY;
    };
    
    Coordinate::Coordinate(int x, int y)
    {
        
        m_iX = x;
        m_iY = y;
    }
    
    Coordinate operator-(Coordinate &coor)
    {
        
        coor.m_iX = -coor.m_iX;
        coor.m_iY = -coor.m_iY;
        return coor;
    }
    
    int main()
    {
        
        Coordinate coor1(3,5);
    
        -coor1;  //等价于operator-(coor1);
        return 0;
    }

**后置++重载**

#include <iostream>
    
    using namespace std;
    
    class Coordinate
    {
        
    public:
        Coordinate(int x, int y);
        Coordinate operator++(int);  //后置++，里面的int只是后置运算符的标志
    private:
        int m_iX;
        int m_iY;
    };
    Coordinate::Coordinate(int x, int y)
    {
        
        m_iX = x;
        m_iY = y;
    }
    Coordinate Coordinate::operator++(int)
    {
        
        Coordinate old(*this);
        m_iX++;
        m_iY++;
        return old;
    }
    
    int main()
    {
        
        Coordinate coor1(3,5);
        coor1++;  //coor1.operator++(0);
        return 0;
    }

**<<运算符重载**

#include <iostream>
    
    using namespace std;
    
    class Coordinate
    {
        
        friend ostream& operator<<(ostream &out, const Coordinate &coor);
    public:
        Coordinate(int x, int y);
    private:
        int m_iX;
        int m_iY;
    };
    
    Coordinate::Coordinate(int x, int y){
        
        m_iX = x;
        m_iY = y;
    }
    
    ostream& operator<<(ostream &out, const Coordinate &coor)
    {
        
        out<<coor.m_iX<<","<<coor.m_iY;
        return out;
    }
    
    int main()
    {
        
        Coordinate coor(3,5);
        cout<<coor;  //operator<<(cout,coor);
        return 0;
    }

## 函数模板 ##

#include <iostream>
    
    using namespace std;
    
    template <class T>
    T maxx(T a,T b)
    {
        
        return (a>b)?a:b;
    }
    
    int main()
    {
        
        int ival = maxx(100,99);
        char cval = maxx<char>('A','B');
        cout<<ival<<endl;
        cout<<cval<<endl;
        return 0;
    }

**变量作为函数模板**

template <int size>
    void display()
    {
        
        cout<<size<<endl;
    }
    int main(){
        
        display<10>();
    }

**多参数函数模板**

template <typename T, typename C>
    void display(T a, C b)
    {
        
        cout<<a<<" "<<b<<endl;
    }
    int main()
    {
        
        int a=1024;
        string str = "hello world!";
        display<int, string>(a,str);
        return 0;
    }

typename和class可以混用。

## 类模板 ##

模板代码暂时不能分离编译。  
得将所有代码都写在h文件里。