C++ 析构器，重载运算符

析构器：一个类对象需要作善后处理
相当于拆除楼房了，剩下的善后处理
什么时候来执行：当类对象被释放时候，系统会通知对象
~类名()  不带形参，对象都已经释放了，传递值没有意义
1.只有一种析构器（不能重载）
2.默认添加析构函数（空函数体）
3.堆区必须由delete  来释放。 
定义的是先全局，在动态   释放是先释放动态在全局
释放空间
动态数组：链表 ， 函数结束后对象释放了，但是它的链表的空间没有释放,所以此时
就需要析构器来帮助释放空间、

友元函数：就是全局函数作为类的朋友
        作用：友元函数可以访问该类的非公有成员
class 类名
{
    friend 返回类型   函数名（....）  
    
}
返回类型  函数名(....)
{

}
友元类  但是这样会破坏类的封装性
若类A 需要取方法类B 的非公有成员， 需要A声明为B的友元类
class B
{
        friend class A;
private:
        int a

};
class A
{
 //访问B的成员

}

重载运算符：
运算符：就是提供运算操作。
运算表达式：运算结果
1.运算符的数据可以对基本类型进行操作
 被操作数，操作数
 b 为this 
 
     重载输入输出流：
    输出：<<
    输入：>>
    两个标准输出输出流：cout/cin分别是类ostream/istream的对象
    重载：
    1全局函数
        void operator<<(ostream&,对象);    
    2、不能为成员方法
    
    
注：1、下列运算符不能重载：
        sizeof  对象->成员   new   *  &   对象.成员
        2、规定：对复杂类型重载运算符的结果类型必须保持与运算的表达式结果一致。
        3、语法规则：运算符的操作数目不能改变

    算术运算符：
        1、全局函数
            返回值 operator运算符（形参1，形参2）
        2、成员方法
            friend 返回值 operator运算符（形参1）
    2、判断运算符： >  < !=  >=  <=  ==
        结果： 真  假
        1、成员方法：
        2、全局函数：
    3、下标运算符 []
        1、成员方法:
    4、自增/自减：
        1、全局函数
            类 operator++(类);  前自增
            类 operator++(类，int)
        2成员方法
            类 operator++()    //前自增
            类 operator++(int)        
 
 
 
 
 动态变量：栈区变量，所有的动态变量存储在栈区，

 

重载运算符   +  >  <  [ ]

#include<iostream>
#include<stdarg.h>
#include<string.h>
using namespace std;
class String
{
public:
        String(int,...);
        void show();
        String operator+(String& );
        bool   operator>(String& );
        int operator[](int);
private:
        int ilen;
        int buf[100];



};
String::String(int num,...)
{
        this->ilen=num;;
        va_list ap;
        va_start(ap,num);
        int i=0;
        for(i=0;i<ilen;i++)
        {
                buf[i]=va_arg(ap,int);
        }
        va_end(ap);

}
void String::show()
{
        int i=0;
        for(i=0;i<ilen;i++)
        {
                cout<<buf[i]<<" ";
        }
        cout<<endl;
}
String String::operator+(String& a)
{
        String result(0);
        result.ilen=this->ilen+a.ilen;
        memcpy(result.buf,this->buf,sizeof(int)*(this->ilen));
        memcpy(result.buf+this->ilen,a.buf,sizeof(int)*(a.ilen));
        return result;
}
bool String::operator>(String& a)
{
        int num1=0,num2=0;
        int i;
        for(i=0;i<this->ilen;i++)
        {
                num1+=this->buf[i];
        }
        for(i=0;i<a.ilen;i++)
        {
                num2+=a.buf[i];
        }
        if(num1>num2)
                return true;
        else
                return false;

}
int String:: operator[](int index)
{
        return this->buf[index];

}
int main()
{
        String s1(4,1,2,3,4);
        s1.show();
        String s2(5,5,6,7,8,9);
        s2.show();
        cout<<"****+****"<<endl;
        String r=s1+s2;
        r.show();
        cout<<"***>*****"<<endl;
        if(s1>s2)
        {
                cout<<"s1>s2"<<endl;
        }
        else
                cout<<"s1<=s2"<<endl;
        cout<<"***[]*****"<<endl;
        cout<<s2[1]<<endl;
        return 0;
}
     

自增 自减  输入 输出     ++i  i++    <<   >> 输入 

#include<iostream>
#include<time.h>
using namespace std;
class Time
{
public:
        friend istream& operator>>(istream& intput,Time& t);  友元   输入
        friend ostream& operator<<(ostream& output,Time& t);         输出
        Time()
        {

        }
        Time(int,int,int);
//       friend Time operator++(Time&);                       前自增
        void show();
        Time operator++();
         operator int();
protected:
        int hours;
        int minute;
        int second;
public:
        time_t T;
};
Time ::Time(int h,int m,int s):hours(h),minute(m),second(s)
{

}
void Time::show()
{
        cout<<hours<<":"<<minute<<":"<<second<<endl;

}
/*
Time  operator++(Time& t)
{
        t.second++;
        return t;
}
*/
Time Time:: operator++()
{
        this->hours++;

}
Time ::operator int()
{
        return T;

}
ostream& operator<<(ostream& output,Time& t)
{
        output<<t.hours<<":"<<t.minute<<":"<<t.second;
        return output;


}
istream& operator>>(istream& intput,Time& t)
{
        intput>>t.hours>>t.minute>>t.second;
        return intput;

}
int main()
{
        Time t1(11,33,44);
        t1.show();
//      Time r= ++t1;
//      r.show();
        t1.operator++();
        t1.show();
        Time t;
        t.T=time(NULL);
        cout<<(int)t.T<<endl;
        cout<<t1<<endl;
        Time t6;
        cin>>t6;
        t6.show();
        return 0;




}