EduCoder：C#类（二）：继承和多态——运算符的重载

任务描述

大学中各个社团有时候会联合举办活动，那么参加的人数将会是各个社团人数的总和。

任务要求：使用重载运算符+，直接根据已定义好的社团类实例对象计算总人数。

相关知识

运算符的重载

我们已经学了使用运算符处理简单类型，当我们学习类概念之后，我们可运用运算符的重载处理类实例化的对象。

简单类型的运算符处理，例如：

1. namespace K3
2. {
3. public class Person {
4. int age;
5.  
6. public int updateAge() {
7. return age+1;
8. }
9. public void setAge(int _age) {
10. age = _age;
11. }
12. }
13.  
14. class myCaller {
15. public static void Main(string[] agrs) {
16.  
17. Person p1 = new Person();
18. Person p2 = new Person();
19.  
20. int pTemp1 = Convert.ToInt32(Console.ReadLine());
21. int pTemp2 = Convert.ToInt32(Console.ReadLine());
22. p1.setAge(pTemp1);
23. p2.setAge(pTemp2);
24.  
25. if (p1.updateAge() > p2.updateAge()){ //使用>操作符
26. //处理代码
27. }else {
28. //处理代码
29. }
30. }
31. }
32. }

我们从通过键盘读取几个数字作为变量p1和p2中age属性的值，通过比较运算符>的处理结果运行不同的处理代码。

若使用运算符的重载，将符号>重载为能够处理类对象的操作符，便可隐式的提供对两个int型变量的处理逻辑，直接使用对象进行比较，例如：

1. if (p1 > p2){ //使用>操作符
2. //处理代码
3. }else {
4. //处理代码
5. }

这种情况下，使用Person类型直接进行比较。我们使用关键字operator对运算符进行重定义，使用结构如下：

1. public static <返回值类型> operator <操作符>(<操作对象参数1>，<操作对象参数2>...){
2. //逻辑处理
3. //...
4. return <返回值>
5. }

其中运算符需要用静态修饰符static限定；返回值类型与实际操作符有关；操作数对象作为传参，传参数目与操作符相关，例如+操作符为二元操作符，那么参数需要两个操作对象。下面我们对符号<进行重载：

1. public static bool operator <(Person p1, Person p2){
2. if(p1.updateAge() < p2.updateAge()){
3. return true;
4. }else{
5. return false;
6. }
7. }

此段代码中，由于<操作符为二元操作符，且操作结果为bool类型，所以参数数目为两个，且返回值为bool类型。

我们将原来那段代码补全如下：

1. namespace K3
2. {
3. public class Person {
4. int age;
5.  
6. public int updateAge() {
7. return age+1;
8. }
9. public void setAge(int _age) {
10. age = _age;
11. }
12. //重载操作符>
13. public static bool operator >(Person p1, Person p2)
14. {
15. if (p1.updateAge() > p2.updateAge()){
16. return true;
17. }
18. else{
19. return false;
20. }
21. }
22. //重载操作符<
23. public static bool operator <(Person p1, Person p2){
24. if (p1.updateAge() < p2.updateAge()){
25. return true;
26. }
27. else{
28. return false;
29. }
30. }
31. }
32. //调用类myCaller
33. class myCaller {
34. public static void Main(string[] agrs) {
35.  
36. Person p1 = new Person();
37. Person p2 = new Person();
38.  
39. int pTemp1 = Convert.ToInt32(Console.ReadLine());
40. int pTemp2 = Convert.ToInt32(Console.ReadLine());
41. p1.setAge(pTemp1);
42. p2.setAge(pTemp2);
43.  
44. if (p1 > p2){ //重载过后，直接使用对象进行处理
45. //处理代码
46. Console.WriteLine("the return value is true");
47. }else {
48. //处理代码
49. Console.WriteLine("the return value is false");
50. }
51. }
52. }

补全完整后，我们将操作符>也进行了重载。需要注意，符号>和符号<须保持一致，不能够一个重载，而另一个没有重载：

1. //重载操作符>
2. public static bool operator >(Person p1, Person p2)
3. {
4. if (p1.updateAge() > p2.updateAge()){
5. return true;
6. }
7. else{
8. return false;
9. }
10. }

重载之后使用类Person对象实例直接进行比较操作:

1. if (p1 > p2){ //重载过后，直接使用对象进行处理
2. //处理代码
3. Console.WriteLine("the return value is true");
4. }else {
5. //处理代码
6. Console.WriteLine("the return value is false");
7. }

运行结果如下：

运算符重载表

并非所有运算符都可通过operator关键字定义重载，如下表所示：

图中的比较运算符，必须成对的进行重载，如我们已接触到的<、>;再比如==进行重载，那么!=也必须重载。

编程要求

本关的编程任务是补全右侧代码片段中Begin至End中间的代码，具体要求如下：

• 补全社团类Community，重载操作符+，使之能够在Community实例对象之间进行运算；
• 程序运行正常，输出结果与预期结果相符。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace K3
{
    public class Community
    {
        private int number; //人数

        public Community(int number)
        {
            this.number = number;
        }

        /********** Begin *********/
        //重载+运算符
		public static int operator +(Community a, Community b)
        {
            return a.number+b.number;
        }
        /********** End *********/
    }
    public class myCaller
    {
        public static void Main(string[] args)
        {
            Community violin = new Community(50);   //小提琴社
            Community cello = new Community(27);    //大提琴社

            int total = violin + cello;
            Console.WriteLine("The number of participants in this event is:" + total);
        }
    }
}