day4 特殊运算符重载

#include <stdio.h>
#include <string.h>


class A{
	public:
		A()
		{
			printf("A()\n");
			p = new char [10];
			strcpy(p, "hello");

			printf("p:%s\n", p);
			printf("p:%s\n", this->p);
		}

		/*复制构造函数*/
		A(const A &x)
		{
			printf("A(const A &x)\n");
			p = new char[10];
			strcpy(p, x.p);
		}

		~A()
		{
			printf("~A()\n");

			//释放p指向的内存
			delete [] p;
		}

		/*赋值运算符重载函数*/
		A &   operator=(A &x)
		{
			printf("operator=\n");

			//创建一个新的char 数组
			p = new char[10];

			//将 x的p 指向的内存复制到新数组中
			strcpy(p, x.p);

			return *this;
		}

	private:
		char *p;

};

int main()
{
	//创建一个 A 类型的对象 x
	A x;

	//将 x 复制给 y ,并且创建一个 A 类型的对象 y
	A y = x;

	//将 x 的值赋给y, 并使用赋值运算符重载函数
	y = x;

}

#include <iostream>

using namespace std;

class Converter{
	public:
		Converter(double rate)
		{
			this->rate = rate;
		}
	
		double operator()(double rmb)
		{
			return rmb * rate;
		}
	private:
		double rate;
};

double RMBto(double rmb, double rate)
{
	return rmb * rate;
}

int main()
{
	Converter RMBtoUS(6.4);
	cout << RMBtoUS(10) << endl;	
	cout << RMBtoUS(10) << endl;
	cout << RMBtoUS(10) << endl;

	Converter RMBtoE(8.4);
	cout << RMBtoE(100) << endl;
	cout << RMBtoE(100) << endl;
	cout << RMBtoE(100) << endl;
}

#include <stdio.h>
#include <unistd.h>
#include <iostream>

using namespace std;

// 定义计时器 Timer 类
class Timer{
public:
    Timer() // 默认构造函数，将计时器初始化为 00:00:00
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {

    }

    // 增加指定的秒数
    void addtimer(int sec=1)
    {
        // 秒数加传入的秒数，每加 60 秒，分钟加 1
        this->min += (this->sec+sec)/60; 
        this->sec = (this->sec+sec)%60; // 秒数取模 60
    }

    // 显示时间
    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }

    // 定义加法运算符重载函数，支持 Timer 类型和 int 类型的 + 运算
    Timer operator+(int sec)
    {
        Timer tem;
        tem.sec = this->sec+sec;
        return tem;
    }

    // 定义加法运算符重载函数，支持 Timer 类型和 Timer 类型的 + 运算
    Timer operator+(Timer &x)
    {
        Timer tem;
        tem.sec = sec+x.sec; // 秒数相加
        tem.min = min+x.min; // 分钟相加
        tem.hour = hour+x.hour; // 小时相加
        return tem;
    }

    // 定义后缀自增运算符重载函数，每次执行将秒数加 1
    Timer operator++(int)
    {
        Timer tem = *this; // 备份当前对象
        sec++; // 秒数加 1
        return tem; // 返回备份对象
    }

    // 定义前缀自增运算符重载函数，每次执行将秒数加 1
    Timer operator++()
    {
        sec++; // 秒数加 1
        return *this;
    }

    // 定义相等运算符重载函数，比较两个 Timer 对象的 hour、min 和 sec 成员变量是否相等
    bool operator==(Timer &x)
    {
        if(sec==x.sec && min==x.min && hour==x.hour)
            return true;
        return false;
    }

    // 定义下标运算符重载函数，通过下标访问 hour、min 和 sec 成员变量
    int &operator[](int i)
    {
        switch(i)
        {
        case 0: 
            return hour;
        case 1: 
            return min;
        case 2: 
            return sec;
        }
    }

    // 友元函数，定义输出流插入运算符重载函数，用于输出 Timer 对象的各个成员变量的值
    friend ostream &operator<<(ostream &out, const Timer &t);
private:
    int hour; // 小时
    int min; // 分钟
    int sec; // 秒数
};

// 定义输出流插入运算符重载函数，用于输出 Timer 对象的各个成员变量的值
ostream &operator<<(ostream &out, const Timer &t)
{
    out << "hour: "<< t.hour << " min: "<< t.min << " sec: "<< t.sec << endl;
}

int main()
{
    Timer t; // 定义计时器对象 t
    t.addtimer(3); // t 增加 3 秒
    Timer t1; // 定义计时器对象 t1
    t1.addtimer(5); // t1 增加 5 秒
    Timer t2; // 定义计时器对象 t2
    t2 = t+t1; // 将 t 和 t1 相加，将结果赋给 t2
    t2.show(); // 显示 t2 对象的值
    t2 = t2+5; // 将 t2 加 5 秒，将结果赋给 t2
    t2.show(); // 显示 t2 对象的值
    Timer t3 = ++t2; // 将 t2 自增 1 秒，将结果赋给 t3
    t3.show(); // 显示 t3 对象的值
    t2.show