대화형 모드의 진법(radix) 변환 예제 with C++

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 C++ 소스 코드이다.
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환을 하는 핵심 함수 convertAtoI()와 convertItoA()의 소스가 자체 제작되어 포함되어 있다. 이를 이용하는 부분은 157~158째 줄에 있는

         val = convertAtoI(s, srcRdx);
         convertItoA((char *) ret, val, destRdx);

이다. 지원되는 진법은 2진법에서 36진법 까지이다.

1. /*
2.  *  Filename: convertRadixCPP.cpp
3.  *            Convert radix in a interactive mode.
4.  *
5.  *  Compile: cl /EHsc convertRadixCPP.cpp
6.  *  Execute: convertRadixCPP
7.  *
8.  *      Date:  2008/03/25
9.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  */
12. #include <iostream>
13. #include <string>
14. #include <cmath>
16. using namespace std;
18. #define MAX_BUF 300
20. enum { FALSE, TRUE };
22. struct _TOKEN {
23.     char a[81];
24.     char b[81];
25. };
27. void println(char s[]) {
28.     cout << s << endl;
29. }
31. void print(char s[]) {
32.     cout << s;
33. }
35. void printUsage() {
36.     println("Usage: convertRadixCPP");
37.     println("Convert radix in a interactive mode, where the maximum radix is 36.");
38. }
40. void printAbout() {
41.     println("    About: Convert radix in a interactive mode.");
42. }
44. void printMainMenu() {
45.     println("  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it");
46. }
48. void printMainPrompt() {
49.     print("  Prompt> ");
50. }
52. void printSubMenu(int srcRadix, int destRadix) {
53.     char sbuf[MAX_BUF];
54.     sprintf(sbuf, "    Convert Radix_%d to Radix_%d", srcRadix, destRadix);
55.     println(sbuf);
56.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit");
57. }
59. void printSubPrompt() {
60.     print("    Input Value>> ");
61. }
63. char BASE36[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
65. void convertItoA(char *pstr, long num, int radix) {
66.    char tmp[2];
67.    char ret[MAX_BUF];
68.    char arr[MAX_BUF];
69.    long q, r;
70.    int i, n;
71.    int isNegative = FALSE;
73.    if (num < 0L) {
74.       isNegative = TRUE;
75.       num = -num;
76.    }
78.    arr[0] = '\0';
79.    q = num;
80.    r = 0L;
82.    while (q >= (long) radix) {
83.       r = q % (long) radix;
84.       q = q / (long) radix;
85.       tmp[0] = BASE36[r];
86.       tmp[1] = '\0';
87.       strcat(arr, tmp);
88.    }
90.    tmp[0] = BASE36[q];
91.    tmp[1] = '\0';
92.    strcat(arr, tmp);
93.    if (isNegative) {
94.       strcat(arr, "-");
95.    }
96.     n = strlen(arr);
97.     for (i = 0; i < n; i++) {
98.         ret[i] = arr[n - i - 1];
99.     }
100.     ret[n] = '\0';
101.     strcpy(pstr, (char *) ret);
102. }
104. long convertAtoI(const char *pstr, int radix) {
105.     char tmp[2];
106.     long ret = 0L;
107.     char arr[MAX_BUF];
108.     long q, r;
109.     int isNegative = FALSE;
110.     int len = strlen(pstr);
111.     char c;
112.     int i;
113.     long val;
115.     c = pstr[0];
116.     if (c == '-') {
117.         isNegative = TRUE;
118.     }
119.     else if (c >= '0' && c <= '9') {
120.         ret = (long) (c - '0');
121.     }
122.     else if (c >= 'A' && c <= 'Z') {
123.         ret = (long) (c - 'A') + 10L;
124.     }
125.     else if (c >= 'a' && c <= 'z') {
126.         ret = (long) (c - 'a') + 10L;
127.     }
128.     if (ret >= (long) radix) {
129.         println("        Invalid character!");
130.         return ret;
131.     }
133.     for (i = 1; i < len; i++) {
134.         c = pstr[i];
135.         ret *= radix;
136.         if (c >= '0' && c <= '9') {
137.             val = (long) (c - '0');
138.         }
139.         else if (c >= 'A' && c <= 'Z') {
140.             val = (long) (c - 'A') + 10L;
141.         }
142.         else if (c >= 'a' && c <= 'z') {
143.             val = (long) (c - 'a') + 10L;
144.         }
145.         if (val >= (long) radix) {
146.             println("        Invalid character!");
147.             return ret;
148.         }
149.         ret += val;
150.     }
151.     return ret;
152. }
154. void convertRadix(char *pstr, char s[],  int srcRdx, int destRdx) {
155.     long val;
156.     char ret[MAX_BUF];
157.     val = convertAtoI(s, srcRdx);
158.     convertItoA((char *) ret, val, destRdx);
159.     strcpy(pstr, ret);
160. }
162. void readLine(char *pdata) {
163.     scanf("%s", pdata);
164. }
166. void readTwo(struct _TOKEN *ptoken) {
167.     scanf("%s", ptoken->a);
168.     scanf("%s", ptoken->b);
169. }
171. void tokenize(struct _TOKEN *ptoken, const char *line, char c) {
172.     int len = strlen(line);
173.     int i;
174.     int from, to;
176.     i = 0;
177.     while (line[i] != c) {
178.         i++;
179.     }
180.     from = i;
181.     while (line[i] == c) {
182.         i++;
183.     }
185.     to = i;
186.     strncpy(ptoken->a, line, to - from);
187.     ptoken->a[to - from] = '\0';
188.     while (line[i] != c) {
189.         i++;
190.     }
192.     from = i;
193.     while (line[i] == c) {
194.         i++;
195.     }
197.     to = i;
198.     strncpy(ptoken->b, line, to - from);
199.     ptoken->b[to - from] = '\0';
200. }
202. void doConvert(int srcRadix, int destRadix) {
203.     char sbuf[MAX_BUF];
204.     char line[MAX_BUF];
205.     char cmd[MAX_BUF];
206.     char srcStr[MAX_BUF], destStr[MAX_BUF];
207.     long tmp;
208.     println("");
209.     printSubMenu(srcRadix, destRadix);
210.     do {
211.         printSubPrompt();
212.         readLine((char *)cmd);
213.         while (strlen(cmd) <= 0) {
214.             readLine((char *)cmd);
215.         }
216.         if (strcmp("main()", cmd) == 0) {
217.             return;
218.         }
219.         else if (strcmp("exit()", cmd) == 0 || strcmp("quit()", cmd) == 0) {
220.             exit(0);
221.         }
222.         tmp = convertAtoI(cmd, srcRadix);
223.         strcpy(srcStr, cmd);
224.         convertRadix(destStr, srcStr, srcRadix, destRadix);
225.         sprintf(sbuf, "        ( %s )_%d   --->   ( %s )_%d", srcStr, srcRadix, destStr, destRadix);
226.         println(sbuf);
227.         println("");
228.     } while (TRUE);
229. }
231. void doStart() {
232.     char line[MAX_BUF];
233.     char cmd[MAX_BUF];
234.     int srcRadix = 10, destRadix = 10;
235.     char srcStr[MAX_BUF], destStr[MAX_BUF];
236.     struct _TOKEN st;
237.     int onlyOnce = TRUE;
239.     do {
240.         println("");
241.         if (onlyOnce) {
242.             println("  The supported maximum radix is 36.");
243.             onlyOnce = FALSE;
244.         }
245.         printMainMenu();
246.         printMainPrompt();
248.         readLine((char *)cmd);
249.         while (strlen(cmd) <= 0) {
250.             readLine((char *)cmd);
251.         }
253.         if (strstr("qQxX", cmd) != NULL && strlen(cmd) == 1) {
254.             exit(0);
255.         }
256.         else if (strstr("aA", cmd) != NULL && strlen(cmd) == 1) {
257.             printAbout();
258.         }
259.         else if (strstr("sS", cmd) != NULL && strlen(cmd) == 1) {
260.             print("  Input the source and target radices (say, 16 2): ");
261.             readTwo((struct _TOKEN *) &st);
262.             srcRadix = convertAtoI(st.a, 10);
263.             destRadix = convertAtoI(st.b, 10);
264.             doConvert(srcRadix, destRadix);
265.         }
266.     } while (TRUE);
267. }
269. void main(int argc, char *argv[]) {
270.     if (argc > 1 && strcmp("-h", argv[1]) == 0) {
271.         printUsage();
272.         exit(1);
273.     }
274.     doStart();
275. }

컴파일> cl /EHsc convertRadixCPP.cpp

실행> convertRadixCPP

  The supported maximum radix is 36.
  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 4 2

    Convert Radix_4 to Radix_2
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 321
        ( 321 )_4   --->   ( 111001 )_2

    Input Value>> main()

  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 2 4

    Convert Radix_2 to Radix_4
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 111001
        ( 111001 )_2   --->   ( 321 )_4

    Input Value>> quit()






이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.