首页 / 操作系统 / Linux / 用C#风格写C++程序（探索C#对象模型）

写C#程序就是在设计一个类先看一个C#程序（计算一个表达式）：

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace ConsoleApplicationCal  
7. {  
8.     class Program  
9.     {  
10.         private static char[,] Precede_Matrix = new char[7, 7]  
11.         {  
12.             {">", ">", "<", "<", "<", ">", ">",},  
13.             {">", ">", "<", "<", "<", ">", ">",},  
14.             {">", ">", ">", ">", "<", ">", ">",},  
15.             {">", ">", ">", ">", "<", ">", ">",},  
16.             {"<", "<", "<", "<", "<", "=", "0",},  
17.             {">", ">", ">", ">", "0", ">", ">",},  
18.             {"<", "<", "<", "<", "<", "0", "=",}  
19.         };  
20.   
21.         public static char Precede（char a, char b）  
22.         {  
23.             int i = 0;  
24.             int j = 0;  
25.             switch （a）  
26.             {  
27.                 case "+": i = 0; break;  
28.                 case "-": i = 1; break;  
29.                 case "*": i = 2; break;  
30.                 case "/": i = 3; break;  
31.                 case "（": i = 4; break;  
32.                 case "）": i = 5; break;  
33.                 case "#": i = 6; break;  
34.                 default: break;  
35.             }  
36.             switch （b）  
37.             {  
38.                 case "+": j = 0; break;  
39.                 case "-": j = 1; break;  
40.                 case "*": j = 2; break;  
41.                 case "/": j = 3; break;  
42.                 case "（": j = 4; break;  
43.                 case "）": j = 5; break;  
44.                 case "#": j = 6; break;  
45.                 default: break;  
46.             }  
47.   
48.             return （Precede_Matrix[i, j]）;  
49.         }  
50.   
51.         public static double Operate（double a, char oper, double b）  
52.         {  
53.             switch （oper）  
54.             {  
55.                 case "+": return a + b;  
56.                 case "-": return a - b;  
57.                 case "*": return a * b;  
58.                 case "/": return a / b;  
59.                 default: return -1;  
60.             }  
61.         }  
62.   
63.         public static bool IsOperand（char c）  
64.         {  
65.             if （（"0" <= c && c <= "9"） || c == "."）   //  c是数字或小数点   
66.                 return true;  
67.             else  
68.                 return false;  
69.         }  
70.   
71.         static void Main（string[] args）  
72.         {  
73.             string str;  
74.             while （（str = Console.ReadLine（）） ！= null）  
75.             {  
76.                 str += "#";                     //  最后是#（结束标志）   
77.   
78.                 double a;  
79.                 double b;  
80.                 char x;  
81.                 char theta;  
82.   
83.                 Stack<char> OPTR = new Stack<char>（）;  
84.                 OPTR.Push（"#"）;  
85.                 Stack<double> OPND = new Stack<double>（）;  
86.   
87.                 int i = 0;  
88.                 char c = str[i++];  
89.                 double operand = 0;  
90.                 while （！（c == "#" && OPTR.Peek（） == "#"））  
91.                 {  
92.                     if （IsOperand（c））   // c是数字或小数点（这里一定是数字），小数点已在下面转换掉了   
93.                     {  
94.                         int startIndex = i - 1;  
95.                         int length = 1; // c是数字，故初始一定是1   
96.                         while （IsOperand（str[i]））  
97.                         {  
98.                             i++;  
99.                             length++;  
100.                         }  
101.   
102.                         string doubleString = str.Substring（startIndex, length）;  
103.                         //     operand = atof（&str[i - 1]）; //  把从c开头的数转化成double   
104.                         OPND.Push（double.Parse（doubleString））;  
105.   
106.   
107.                         c = str[i++];  
108.                     }  
109.                     else                            // c is operator or delimiter   
110.                     {  
111.                         switch （Precede（OPTR.Peek（）, c））  
112.                         {  
113.   
114.                             case "<":  
115.                                 OPTR.Push（c）;  
116.                                 c = str[i++];  
117.                                 break;  
118.   
119.                             case "=":  
120.                                 x = OPTR.Pop（）;  
121.   
122.                                 c = str[i++];  
123.                                 break;  
124.   
125.                             case ">":  
126.                                 theta = OPTR.Pop（）;  
127.                                 b = OPND.Pop（）;  
128.                                 a = OPND.Pop（）;  
129.                                 OPND.Push（Operate（a, theta, b））;  
130.                                 break;  
131.   
132.                             default:  
133.                                 break;  
134.                         }  
135.                     }  
136.                 }  
137.                 //  OPTR栈的栈顶元素和当前读入的字符均为“#”   
138.                 //  即“#”=“#”时整个表达式求值完毕   
139.                 Console.WriteLine（OPND.Peek（））;  
140.             }       
141.         }  
142.     }  
143. }  

下面是用C++改写的：

1. #include <iostream>   
2. #include <stack>   
3. #include <string>   
4. using namespace std;  
5.   
6. // 因为在定义类时不能对数据成员直接初始化，   
7. // 故下面这个全局数组定义在类（命名空间）的外面，待解决   
8. char Precede_Matrix[7][7] =  
9. {  
10.     {">", ">", "<", "<", "<", ">", ">",},  
11.     {">", ">", "<", "<", "<", ">", ">",},  
12.     {">", ">", ">", ">", "<", ">", ">",},  
13.     {">", ">", ">", ">", "<", ">", ">",},  
14.     {"<", "<", "<", "<", "<", "=", "0",},  
15.     {">", ">", ">", ">", "0", ">", ">",},  
16.     {"<", "<", "<", "<", "<", "0", "=",}  
17. };  
18.   
19. namespace ConsoleApplicationCal  
20. {  
21.     class Program  
22.     {  
23.         // 写这个构造函数是因为想在main函数中创建Program对象时   
24.         // 就自动调用Main（）了，符合C#的运行规则   
25.     public: Program::Program（void）  
26.             {  
27.                 Main（）;  
28.             }  
29.   
30.     public: static char Precede（char a, char b）  
31.             {  
32.                 int i = 0;  
33.                 int j = 0;  
34.                 switch （a）  
35.                 {  
36.                 case "+": i = 0; break;  
37.                 case "-": i = 1; break;  
38.                 case "*": i = 2; break;  
39.                 case "/": i = 3; break;  
40.                 case "（": i = 4; break;  
41.                 case "）": i = 5; break;  
42.                 case "#": i = 6; break;  
43.                 default: break;  
44.                 }  
45.                 switch （b）  
46.                 {  
47.                 case "+": j = 0; break;  
48.                 case "-": j = 1; break;  
49.                 case "*": j = 2; break;  
50.                 case "/": j = 3; break;  
51.                 case "（": j = 4; break;  
52.                 case "）": j = 5; break;  
53.                 case "#": j = 6; break;  
54.                 default: break;  
55.                 }  
56.   
57.                 return （Precede_Matrix[i][j]）;  
58.             }  
59.   
60.     public: static double Operate（double a, char oper, double b）  
61.             {  
62.                 switch （oper）  
63.                 {  
64.                 case "+": return a + b;  
65.                 case "-": return a - b;  
66.                 case "*": return a * b;  
67.                 case "/": return a / b;  
68.                 default: return -1;  
69.                 }  
70.             }  
71.   
72.     public: static bool IsOperand（char c）  
73.             {  
74.                 if （（"0" <= c && c <= "9"） || c == "."）   //  c是数字或小数点   
75.                     return true;  
76.                 else  
77.                     return false;  
78.             }  
79.   
80.     public: void Main（void）  
81.             {  
82.                 string str;  
83.                 while （cin >> str）  
84.                 {  
85.                     str += "#";                     //  最后是#（结束标志）   
86.   
87.                     double a;  
88.                     double b;  
89.                     char x;  
90.                     char theta;  
91.   
92.                     stack<char> OPTR;  
93.                     OPTR.push（"#"）;  
94.                     stack<double> OPND;  
95.   
96.                     int i = 0;  
97.                     char c = str[i++];  
98.                     double operand = 0;  
99.                     while （！（c == "#" && OPTR.top（） == "#"））  
100.                     {  
101.                         if （IsOperand（c））   // c是数字或小数点（这里一定是数字），小数点已在下面转换掉了   
102.                         {  
103.                             int startIndex = i - 1;  
104.                             int length = 1; // c是数字，故初始一定是1   
105.                             while （IsOperand（str[i]））  
106.                             {  
107.                                 i++;  
108.                                 length++;  
109.                             }  
110.   
111.                             string doubleString = str.substr（startIndex, length）;  
112.                             //     operand = atof（&str[i - 1]）; //  把从c开头的数转化成double   
113.                             char **endPtr = NULL;   // 没什么用，只是为了strtod的传参   
114.                             OPND.push（strtod（doubleString.c_str（）, endPtr））;  
115.   
116.   
117.                             c = str[i++];  
118.                         }  
119.                         else                            // c is operator or delimiter   
120.                         {  
121.                             switch （Precede（OPTR.top（）, c））  
122.                             {  
123.   
124.                             case "<":  
125.                                 OPTR.push（c）;  
126.                                 c = str[i++];  
127.                                 break;  
128.   
129.                             case "=":  
130.                                 x = OPTR.top（）;  
131.                                 OPTR.pop（）;  
132.   
133.                                 c = str[i++];  
134.                                 break;  
135.   
136.                             case ">":  
137.                                 theta = OPTR.top（）;  
138.                                 OPTR.pop（）;  
139.   
140.                                 b = OPND.top（）;  
141.                                 OPND.pop（）;  
142.   
143.                                 a = OPND.top（）;  
144.                                 OPND.pop（）;  
145.   
146.                                 OPND.push（Operate（a, theta, b））;  
147.                                 break;  
148.   
149.                             default:  
150.                                 break;  
151.                             }  
152.                         }  
153.                     }  
154.                     //  OPTR栈的栈顶元素和当前读入的字符均为“#”   
155.                     //  即“#”=“#”时整个表达式求值完毕   
156.                     cout << OPND.top（） << endl;  
157.                 }  
158.   
159.             }  
160.     };  
161. }  
162.   
163. int main（int argc, char **argv）  
164. {  
165.     // 仿照Winform中的Main函数new一个窗体对象   
166.     // Application.Run（new Form1（））;   
167.     ConsoleApplicationCal::Program objForm;  
168.   
169.     return 0;  
170. }  

可以看到，上面的C++程序主体就是在设计一个类，而C#将这种特点发挥到了极致，C#程序是从Main（）开始执行的，完全在类中进行一切。另外，上面的C++程序开头的全局变量初始化之所以不能定义在类里面，是因为这是在设计一个类！不能在类中直接对数据成员初始化，只有静态常量整型数据成员才可以在类中初始化。