C#重载运算符, 工厂模式

　　练习重载, 举了一个例子, 比如复数的运算, 用工厂模式实现加减乘除

　　练习工厂模式之前, 先练习一下重载, 实现了复数plu1和plu2的加法运算

 1  using System;
 2  using System.Collections.Generic;
 3  using System.Linq;
 4  using System.Text;
 5  using Microsoft.VisualBasic;
 6  
 7  namespace CSharp_Test
 8  {
 9      struct plural                 //定义复数的结构体
10      {
11          public double x, y;
12          public plural(double x, double y)      //构造复数方法1
13          {
14              this.x = x;
15              this.y = y;
16          }
17          public plural(plural plu)              //构造复数方法2
18          {
19              x = plu.x;
20              y = plu.y;
21          }
22          public override string ToString()       //重载ToString()方法
23          {
24              string a = (y>0)? (x + "+" + y + "i"):(x +""+ y + "i");
25              return a;
26          }
27          public static plural operator + (plural lhs, plural rhs)//重载+号运算
28          {
29              plural result = new plural(lhs);
30              result.x += rhs.x;
31              result.y += rhs.y;
32              return result;
33          }
34  
35          static void Main()
36          {
37              plural plu1, plu2, plu3;    //定义了三个复数
38              plu1 = new plural(1, 1);    //复数1赋值
39              plu2 = new plural(2, -3);   //复数2赋值
40              plu3 = plu1 + plu2;         //复数3 = 复数1 + 复数2
41              Console.WriteLine("plu1 = " + plu1.ToString());
42              Console.WriteLine("plu2 = " + plu2.ToString());
43              Console.WriteLine("plu3 = " + plu3.ToString());
44          }
45      }
46 }

　　在C#的三目运算符中有一个注意的地方:

24             string a = (y>0)? (x + "+" + y + "i"):(x +""+ y + "i");

　　在C#中三目运算符不能单独构成语句，这点是和C语言不同的，所以要和三目运算符构成赋值语句, 如果这样写就是错误的:

22         public override string ToString()       //重载ToString()方法
23         {
24             (y>0)? (return x + "+" + y + "i"):(return x +""+ y + "i");   //错误
25         }

运行结果是:

---------------------------------------------------------------------------------------------------

下面弄了个加减乘除运算的练习, 使用工厂模式(问题随之而来)复数的运算法则如下:

　　加:（a＋bi）＋（c＋di）＝（a＋c）＋（b＋d）i

　　减:（a＋bi）－（c＋di）＝（a－c）＋（b－d）i

　　乘:（a＋bi）•（c＋di）＝（ac－bd）＋（bc＋ad）i

　　除:（a＋bi）÷（c＋di）＝[(ac+bd) / (c^2+d^2)]＋[(bc－ad) / (c^2+d^2)] i) //c与d不同时为零且c+di不等于0

使用工厂模式进行的加减乘除运算代码:

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5 using Microsoft.VisualBasic;
  6 
  7 namespace CSharp_Test
  8 {
  9     public struct plural                 //定义复数的结构体
 10     {
 11         public double x, y;
 12         public plural(double x, double y)      //构造复数方法1
 13         {
 14             this.x = x;
 15             this.y = y;
 16         }
 17         public plural(plural plu)              //构造复数方法2
 18         {
 19             x = plu.x;
 20             y = plu.y;
 21         }
 22         public override string ToString()       //重载ToString()方法
 23         {
 24             string result = (y>=0)? (x + "+" + y + "i"):(x +""+ y + "i");
 25             return result;
 26         }
 27         public static plural operator + (plural lhs, plural rhs)   //重载+号运算 就在这边出现疑问了(不是错误)
 28         {
 29             plural result = new plural(lhs);
 30             result.x += rhs.x;
 31             result.y += rhs.y;
 32             return result;
 33         }
 34         public static plural operator - (plural lhs, plural rhs)     //重载-号运算
 35         {
 36             plural result = new plural(lhs);
 37             result.x -= rhs.x;
 38             result.y -= rhs.y;
 39             return result;
 40         }
 41         public static plural operator * (plural lhs, plural rhs)     //重载*号运算
 42         {
 43             plural result = new plural(lhs);
 44             result.x = lhs.x * rhs.x - lhs.x * rhs.y;
 45             result.y = lhs.y * rhs.x + lhs.x * rhs.y;
 46             return result;
 47         }
 48 
 49         public static plural operator / (plural lhs, plural rhs)     //重载/号运算
 50         {
 51             plural result = new plural(lhs);
 52             result.x = (lhs.x * rhs.x + lhs.y * rhs.y) / (rhs.x * rhs.x + rhs.y * rhs.y);
 53             result.y = (lhs.y * rhs.x - lhs.x * rhs.y) / (rhs.x * rhs.x + rhs.y * rhs.y);
 54             return result;
 55         }
 56     }                                      //到此结构体定义结束
 57     
 58     public class Operation                      //在这个类中操作,操作方法进行虚拟
 59     {
 60         private plural lhs = new plural(0,0);
 61         private plural rhs = new plural(0,0);
 62         public plural A
 63         {
 64             get{return lhs;}
 65             set{this.lhs = value;}
 66         }
 67         public plural B
 68         {
 69             get{return rhs;}
 70             set{this.rhs = value;}
 71         }
 72         public virtual plural GetResult()       //操作的方法
 73         {
 74             plural result = new plural(0, 0);
 75             return result;
 76         }
 77     }
 78     public class OperationAdd : Operation       //operation类中有个加法操作
 79     {
            //为什么上面红色标记的部分不能写在这边?????????????
 80         public override plural  GetResult()     //重载操作方法,加法是如何实现
 81         {
 82              plural result;
 83             result = A + B;
 84             return result;
 85         }
 86     }
 87     public class OperationSub : Operation       //operation类中有个减法操作
 88     {
 89         public override plural GetResult()      //重载操作方法,减法是如何实现
 90         {
 91             plural result;
 92             result = A - B;
 93             return result;
 94         }
 95     }
 96     public class OperationMul : Operation       //operation类中有个乘法操作
 97     {
 98         public override plural GetResult()      //重载操作方法,乘法是如何实现
 99         {
100             plural result;
101             result = A * B;
102             return result;
103         }
104     }
105     public class OpetationDiv : Operation       //operation类中有个除法操作
106     {
107         public override plural GetResult()      //重载操作方法,除法是如何实现
108         {
109             if ((B.x == 0) && (B.y == 0))                    //c与d不同时为零且c+di不等于0
110                 throw new Exception("The second plural error!");
111             plural result;
112             result = A / B;
113             return result;
114         }
115     }
116 
117 
118     public class OperationFactory              //简单的操作工厂,判断进行何种运算
119     {
120         public static Operation createOperate(string operate)
121         {
122             Operation oper = null;
123             switch (operate)
124             {
125                 case "+":
126                     oper = new OperationAdd();
127                     break;
128                 case "-":
129                     oper = new OperationSub();
130                     break;
131                 case "*":
132                     oper = new OperationMul();
133                     break;
134                 case "/":
135                     oper = new OpetationDiv();
136                     break;
137             }
138             return oper;
139         }
140     }
141 
142     class main
143     {
144         static void Main()
145         {
146             plural C;
147             Operation oper = new Operation();
148             oper = OperationFactory.createOperate("+");        //加法
149             oper.A = new plural(1, 1);
150             oper.B = new plural(2, -4);
151             Console.WriteLine("A = " + oper.A.ToString());
152             Console.WriteLine("B = " + oper.B.ToString());
153             C = oper.GetResult();
154             Console.WriteLine("A+B= " + C.ToString());
155 
156             oper = OperationFactory.createOperate("-");        //减法
157             oper.A = new plural(1, 1);
158             oper.B = new plural(2, -4);
159             C = oper.GetResult();
160             Console.WriteLine("A-B= " + C.ToString());
161 
162             oper = OperationFactory.createOperate("*");        //乘法
163             oper.A = new plural(1, 1);
164             oper.B = new plural(2, -4);
165             C = oper.GetResult();
166             Console.WriteLine("A*B= " + C.ToString());
167 
168             oper = OperationFactory.createOperate("/");        //除法
169             oper.A = new plural(1, 1);
170             oper.B = new plural(2, -4);
171             C = oper.GetResult();
172             Console.WriteLine("A/B= " + C.ToString());
173             Console.ReadLine();
174         }
175     }
176 }

运行结果:

----------------------------------------------------------------------------------------------------

显然在结构体内把所有可能的运算方式都重载一下, 势必提高耦合度! 这样子的工厂模式写法就有些半调子了

但讨论之后发现: 重载结构体的运算符一定要在结构体内完成...