友元、重载、模板、static

一、友元函数与友元类    
    1、友元关系的作用
        友元关系提供了便捷，程序运行的效率，但是友元关系也破坏了类的封装性，使得非成员函数也可以访问类的私有成员。
    
    2、友元函数的使用
        使用规则：
            友元函数使用friend关键字，可以定义在类的任意位置
            友元全局函数在类外全局定义，友元成员函数在另一个类中定义获声明
            友元函数本类不能访问
            友元关系是单向的，一个函数可以是多个类的友元函数
            友元全局函数
            void test(){
                ....
            }
            class A{
                    friend void test();
                public:
                    ....
                private:
                    ...
            }
            友元成员函数
            class B{
                public:
                    void test();
                private:
                    ...
            }
            class A{
                friend void B::test();
                public:
                    ....
                private:
                    ...
            }
    3、友元类
        class A;
        class B{
            friend A;
        public:
            ...
        private:
            ...
            int  x;
            int y;
        }
        class A{
        public:
            void print(B &b){
                cout b.x b,y
            }
        }    
        A是B的友元类，则A可以访问B的私有成员。
        
二、static关键字
    在面向过程中编程
    1、静态全局变量
        声明一个全局变量使其作用域和生命周期只在本文件中有效。其存储在程序的数据段中
    2、静态局部变量
        声明一个变量使其声明周期在本文件中，作用域在本函数中有效，其存储在程序的数据段中
    3、静态全局函数
        声明一个函数使其作用域只限于本文件有效
    在面向对象编程中
    静态成员变量/函数属于全局
    1、静态成员变量
        c++类中的静态成员变量属于类不属于对象，类声明静态变量已经存在。
        对象的this指针无法访问静态成员变量
        静态成员变量无法在类中或者对象进行初始化，只能在类外初始化，void A::x = 0；
        
    2、静态成员函数
        静态成员函数属于类不属于对象
        对静态成员函数的调用使用类名调用，而不能使用对象。
    
    
三、函数重载和运算符重载
    1、函数重载
        c++中允许出现同名的函数，但是函数的参数类型、参数个数、参数的个数必须不同。
    2、运算符重载
        运算符重载用于对象之间的运算，对已有的运算符在对象的运算之间重新定义他们的含义。
        运算符重载的本质就是函数重载
        运算符重载使用的三种形式：
            作为类的成员函数
            作为友元函数
            作为普通函数
        使用规则
            重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。
            Box operator+(const Box&);
        可重载运算符/不可重载运算符
        下面是可重载的运算符列表：

        双目算术运算符    + (加)，-(减)，*(乘)，/(除)，% (取模)
        关系运算符    ==(等于)，!= (不等于)，< (小于)，> (大于>，<=(小于等于)，>=(大于等于)
        逻辑运算符    ||(逻辑或)，&&(逻辑与)，!(逻辑非)
        单目运算符    + (正)，-(负)，*(指针)，&(取地址)
        自增自减运算符    ++(自增)，--(自减)
        位运算符    | (按位或)，& (按位与)，~(按位取反)，^(按位异或),，<< (左移)，>>(右移)
        赋值运算符    =, +=, -=, *=, /= , % = , &=, |=, ^=, <<=, >>=
        空间申请与释放    new, delete, new[ ] , delete[]
        其他运算符    ()(函数调用)，->(成员访问)，,(逗号)，[](下标)
        
        下面是不可重载的运算符列表：

        .：成员访问运算符
        .*, ->*：成员指针访问运算符
        ::：域运算符
        sizeof：长度运算符
        ?:：条件运算符
        #： 预处理符号
        
        
        注意：当运算符重载用作类的成员函数时候，其中一个操作数由对象给出（this指针），另一个操作数则有参数传递
               当用作普通函数时候，两个参数都需要传递。
        
四、模板函数和模板类            
    1、模板函数：由函数模板定义的函数，用以解决算法相同但是参数返回值不同的情况，故而模板函数是重载函数。
    使用格式：
    //////////////////////////1
        template
        T test(T t1,T t2){
            
        }
        
        int main(){
        test(1,2);
            
        }
        //////////////////2
        template
        T test(T t1,int t2){
            
        }
        
        int main(){
        test(1);
            
        }
        ////////////////////////3
        template
        T test(T t1,S s1){
            
        }
        
        int main(){
        test(1,'a');
            
        }
        函数模板也可以是类的成员函数    
            
    2、类模板
        使得对象可以产生不同类型的成员变量。解决不同变量需求相同接口操作的问题。
        使用方法：
        template
        class A{
        public:
            A(T a,T b){
                x = a;
                y = b;
            }
            T test(T t);
        private:
            T x;
            T y;    
        }
            
        成员函数的类外声明：
        template < calss T >
        T A::test(T t){
            cout << a << b<< endl;
        }
        //////////////调用
        int main(){
            Aa1(1,2);
        }

五、模板库
    向量（数组）和链表