运算符重载

(🗒️)
<a class="category-link" href="/categories/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/">学习笔记</a>

今天5月28日，老师说大概还有一个月就会搞那个上机考试，回顾我这半年来的学习，感觉没能坚持每天敲代码成了唯一的遗憾，是啊，还有一个月，我还是每天练练手感吧，这不，C++也快学完了，把作业里面的代码写一写。前几天重写了博客的搭建教程,我觉得还算详细吧。有兴趣可以看看👀。

C++ 运算符重载

  • 在C++中分数不是预先定义的，需要建立一个分数类，使之具有下述功能：能防止分母为0,当分数不是最简形式时进行约分以及避免分母为负数，用重载运算符完成加法、减法、乘法以及除法等四则运算。

  • 在第一问的基础上，用重载关系符==判断两个分数是否相等。

写一个交换的函数：

1
2
3
4
5
6
7
8
9
10
void Swap(int &Num_u,int &Num_d)
{
	if(Num_u>Num_d)                 //确保Num_d>=Num_u
	{
		int temp=Num_u;
		Num_u=Num_d;
		Num_d=temp;
	}

}

首先，定义下分数类。

  • 在类中重载操作符时，为了使运算符函数能够访问类中的私有成员，那么运算符函数就必须重载为非静态成员函数或者友元函数
  • 由于类成员函数this指针的缘故，运算符函数重载为类的成员函数时，所需的参数个数总比它的操作数少1.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
//分数类的定义
class fraction
{
public:
	int MaxNum(int a,int b);
	fraction(int u_,int d_){num_u=u_;num_d=d_;}
	fraction(){num_u=0;num_d=0;}
	void Display();
	void Sample();

	//运算符重载
	int operator == (fraction a1);
	friend fraction operator + (fraction a1,fraction a2);
	friend fraction operator - (fraction a1,fraction a2);
	friend fraction operator * (fraction a1,fraction a2);
	friend fraction operator / (fraction a1,fraction a2);

private:
	int num_u;                 //分子
	int num_d;				   //分母
};

int fraction::MaxNum(int a,int b)
{
	Swap(a,b);
	if(a==0) return b;
	return MaxNum(b-a,a);
}

void fraction::Display()
{
	Sample();
	if(num_u==0) cout << "0" << endl;
	else
	{
		if(num_d==1&&num_u!=0) cout << num_u << endl;
		else cout << num_u << "/" << num_d << endl;
	}
	
}

void fraction::Sample()
{
	int b=MaxNum(num_u,num_d);
	num_u=num_u / b;
	num_d=num_d /b;
}


int fraction::operator == (fraction a1)
{
	int d;
	d=MaxNum(num_d,num_u);
	num_u=num_u / d;
	num_d=num_d / d;
	d=MaxNum(a1.num_d,a1.num_u);
	a1.num_u=a1.num_u / d;
	a1.num_d=a1.num_d / d;
	if(a1.num_u==num_u&&a1.num_d==num_d) return 1;
	return 0;
}

fraction operator + (fraction a1,fraction a2)
{
	fraction c;
	c.num_d=a1.num_d * a2.num_d;
	c.num_u=a1.num_u * a2.num_d + a2.num_u *a1.num_d;
	return c;
}

fraction operator - (fraction a1,fraction a2)
{
	fraction c;
	c.num_d=a1.num_d * a2.num_d;
	c.num_u=a1.num_u * a2.num_d - a2.num_u *a1.num_d;
	return c;
}

fraction operator * (fraction a1,fraction a2)
{
	fraction c;
	c.num_d=a1.num_d * a2.num_d;
	c.num_u=a1.num_u * a2.num_u;
	return c;
}

fraction operator / (fraction a1,fraction a2)
{
	fraction c;
	c.num_d=a1.num_d * a2.num_u;
	c.num_u=a1.num_u * a2.num_d;
	return c;
}


int main()
{
	fraction c(12,72);
	c.Display();
	int d=c.MaxNum(12,72);
	cout << d << endl;

	fraction m(1,6);
	if(m==c) cout << "相等\n";

	fraction e;
	e=m + c;
	e.Display();
	e=m - c;
	e.Display();
	e=m * c;
	e.Display();
	e=m / c;
	e.Display();



	return 0;
}

完整代码

数据结构-二叉树

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include<iostream>
#include<cstdio>
using namespace std;

//定义状态代码
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

//类型定义
typedef int Status;
typedef char TElemType;

//树的结构体定义
typedef struct BiNode{
	TElemType data;
	struct BiNode *lchild,*rchild;
}BiNode,*BiTree;

//创建一棵树🌲
void CreateTree(BiTree &T)
{
	char ch;
	scanf("%c",&ch);
	if(ch==' ') T=NULL;
	else{
		if(!(T=(BiTree)malloc(sizeof(BiNode)))) exit(OVERFLOW);
		T->data=ch;
		CreateTree(T->lchild);
		CreateTree(T->rchild);
	}
}

//先序遍历二叉树
void Pre(BiTree T)
{
	if(T)
	{
		cout << T->data;
		Pre(T->lchild);
		Pre(T->rchild);
	}
}

//树的深度

int Leaves(BiTree T)
{
	static int count=0;
	if(T){
	
		if(!T->lchild&&!T->rchild) count++;
		Leaves(T->lchild);
		Leaves(T->rchild);
	}

	return count;
}

int depth(BiTree T)
{
	int level;
	if(T==NULL) level=0;
	else{
		level=1+(depth(T->lchild)>depth(T->rchild)?depth(T->lchild):depth(T->rchild));
	}
	return level;
}

//主函数
int main()
{
	BiTree T;
	cout << "输入二叉树中的结点：\n";
	CreateTree(T);
	cout << "\n先序遍历二叉树：\n";
	Pre(T);
	cout << "\n二叉树叶子个数：";
	cout << Leaves(T);
	cout << "\n树的层次为：\n" << depth(T);


	return 0;
}

11点了，今天太晚了，立个目标，下次继续复习。