Script Programming(스크립트 프로그래밍)

다음은 초등학교에서 배우는 나눗셈 계산표를 만들어주는 C++ 소스 코드이다.
나눗셈 계산표를 완성하고 나서 약수, 배수 관계를 알려준다.

1. /*
2.  *  Filename: makeDivisionTableCPP.cpp
3.  *
4.  *  Purpose:  Make a division table in a handy written form.
5.  *
6.  *  Compile: cl /GX makeDivisionTableCPP.cpp
7.  *
8.  *  Execute: makeDivisionTableCPP 12345 32
9.  *           makeDivisionTableCPP 500210 61
10.  *
11.  *     Date:  2008/05/15
12.  *   Author:  PH Kim   [ pkim ((AT)) scripts.pe.kr ]
13.  */
15. #include <iostream>
16. #include <string>
17. #include <cmath>
18. #include <memory>
20. using namespace std;
22. enum { FALSE, TRUE };
24. void println(char s[]) {
25.     cout << s << endl;
26. }
28. void print(char s[]) {
29.     cout << s;
30. }
32. void printUsage() {
33.     // println("Using: makeDivisionTable [numerator] [denominator]");
34.     // println("Make a division table in a handy written form.");
35.     println("사용법: makeDivisionTable [피제수] [제수]");
36.     println("손으로 작성한 형태의 나눗셈 표를 만들어준다.");
37. }
39. // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
    // 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
40. char *simplify(double v, int width) {
41.     int n, len;
42.     static char t[] = "                               ";
43.     char tmp[] = "                               ";
44.     sprintf(t, "%g", v);
45.     n = strlen(t);
46.     if ((n > 2) && (t[n - 2] == '.') && (t[n - 1] == '0'))
47.         t[n-2] = '\0';
48.     len = strlen(t);
49.     strcpy(tmp, t);
50.     if (len < width) {
51.         strncpy(t, "               ", width - len);
52.         t[width - len] = '\0';
53.         strcat(t, tmp);
54.     }
56.     return (char *) t;
57. }
59. // 발음상 숫자에 맞는 주어 조사 "은", "는"을 결정한다.
60. void getSuffix(char *buf, long v) {
61.     long t = v % 10L;
62.     char suffix[3];
63.     char tbuf[2];
64.     char suf[2][3] = { "은",  "는"};
65.     strcpy(suffix, suf[0]);
66.     sprintf(tbuf, "%d", t);
67.     if (strchr("2459", tbuf[0]) != NULL) {
68.         strcpy(suffix, suf[1]);
69.     }
70.     strcpy(buf, suffix);
71. }
73. long makeTable(long numer, long denom, long quotient) {
74.     char sbuf[81];
75.     char strNumer[40];
76.     char strDenom[40];
77.     char strQuotient[40];
78.     char strTmpR[40];
79.     char whiteChars[] = "                                                                                 ";
80.     char underbarChars[]  = "_________________________________________________________________________________";
81.     char barChars[]  = "---------------------------------------------------------------------------------";
82.     char offsetSpaces[81];
83.     char biasSpaces[81];
84.     char spaces[81];
85.     char uline[81];
86.     char sline[81];
87.     int i;
88.     int lenN;
89.     int lenD;
90.     int lenQ;
91.     int offsetLeft;
92.     int bias;
93.     long tmpR;
94.     long tmpSub;
95.     char oneDigit;
97.     sprintf(strNumer, "%ld", numer);
98.     sprintf(strDenom, "%ld", denom);
99.     sprintf(strQuotient, "%ld", quotient);
100.     lenN = strlen(strNumer);
101.     lenD = strlen(strDenom);
102.     lenQ = strlen(strQuotient);
103.     offsetLeft = 3 + lenD + 3;
104.     bias = lenN - lenQ;
105.     strncpy(offsetSpaces, whiteChars, offsetLeft);
106.     offsetSpaces[offsetLeft] = '\0';
107.     strncpy(biasSpaces, whiteChars, bias);
108.     biasSpaces[bias] = '\0';
109.     strncpy(uline, underbarChars, lenN + 2);
110.     uline[lenN + 2] = '\0';
111.     strncpy(sline, barChars, lenN);
112.     sline[lenN] = '\0';
114.     printf("%s%s%ld\n", offsetSpaces, biasSpaces, quotient);
115.     sprintf(sbuf, offsetSpaces);
116.     sbuf[offsetLeft - 2] = '\0';
117.     printf("%s%s\n", sbuf, uline);
118.     printf("   %s ) %s", strDenom, strNumer);
120.     strncpy(strTmpR, strNumer, bias + 1);
121.     strTmpR[bias + 1] = '\0';
122.     tmpR = atoi(strTmpR);
123.     tmpSub = 0L;
125.     for (i = 0; i < lenQ; i++) {
126.         if (strQuotient[i] == '0') {
127.             if (i + 1 < lenQ) {
128.                 oneDigit = strNumer[bias + i + 1];
129.                 printf("%c", oneDigit);
130.                 sprintf(sbuf, "%c", oneDigit);
131.                 strcat(strTmpR, sbuf);
132.                 tmpR = atoi(strTmpR);
133.             }
134.         }
135.         else {
136.             println("");
137.             tmpSub = (long)(strQuotient[i] - '0') * denom;
138.             printf("%s%s\n", offsetSpaces, simplify(tmpSub, bias + i + 1));
139.             printf("%s%s\n", offsetSpaces, sline);
140.             tmpR = tmpR - tmpSub;
141.             if (tmpR == 0L && i + 1 < lenQ) {
142.                 strncpy(sbuf, whiteChars, bias + i + 1);
143.                 sbuf[bias + i + 1] = '\0';
144.                 printf("%s%s", offsetSpaces, sbuf);
145.             }
146.             else {
147.                 printf("%s%s", offsetSpaces, simplify(tmpR, bias + i + 1));
148.             }
149.             sprintf(strTmpR, "%ld", tmpR);
150.             if (i + 1 < lenQ) {
151.                 oneDigit = strNumer[bias + i + 1];
152.                 printf("%c", oneDigit);
153.                 sprintf(sbuf, "%c", oneDigit);
154.                 strcat(strTmpR, sbuf);
155.                 tmpR = atoi(strTmpR);
156.             }
157.         }
158.     }
160.     println("");
161.     return tmpR;
162. }
164. // C/C++/Ch 언어의 실행 시작 지점
165. int main(int argc, char *argv[]) {
166.     int i;
167.     int SIZE = argc - 2;
168.     long a, b, q, r, k;
169.     char mbuf[3];
170.     if (argc < 3) {
171.         printUsage();
172.         exit(1);
173.     }
175.     a = atoi(argv[1]);
176.     b = atoi(argv[2]);
178.     if (a <= 0L) {
179.         printf("피제수: %ld\n", a);
180.         println("피제수는 양의 정수라야 합니다.");
181.         exit(1);
182.     }
184.     if (b <= 0L) {
185.          printf("제수: %ld\n", b);
186.          println("제수는 양의 정수라야 합니다.");
187.          exit(1);
188.     }
190.     q = a / b;
191.     r = a % b;
193.     printf("나눗셈 %ld ÷ %ld 의 결과: ", a, b);
194.     printf("몫: %ld, ", q);
195.     printf("나머지: %ld\n", r);
196.     println("");
198.     k = makeTable(a, b, q);
200.     if (k == r) {
             printf("\n나머지: %ld\n", k);
201.     }
203.     if (k == 0L) {
204.         printf("%ld = %ld x %ld\n", a, b, q);
205.         getSuffix(mbuf, a);
206.         printf("%ld%s %ld의 배수(mupltiple)이다.\n", a, mbuf, b);
207.         getSuffix(mbuf, b);
208.         printf("%ld%s %ld의 약수(divisor)이다.\n", b, mbuf, a);
209.     }
210.     else {
211.         getSuffix(mbuf, a);
212.         printf("%ld = %ld x %ld + %ld\n", a, b, q, r);
213.         printf("%ld%s %ld의 배수(mupltiple)가 아니다.\n", a, mbuf, b);
214.     }
215.     return 0;
216. }

실행> makeDivisionTableCPP 500210 61

나눗셈 500210 ÷ 61 의 결과: 몫: 8200, 나머지: 10

          8200
      ________
   61 ) 500210
        488
        ------
         122
         122
        ------
            10

나머지: 10
500210 = 61 x 8200 + 10
500210은 61의 배수(mupltiple)가 아니다.

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

C++ 소스는 한 개의 파일에 여러 개의 클래스가 존재해도 된다.

다음은 두 개의 클래스로 구성되어 있다.
Parent는 부모 클래스이고 Child는 Parent에서 상속 받은 자식 클래스이다.



// Filename: testSubclassing.cpp
#include <iostream>

using namespace std;

class Parent {
    private:
        char name[21];
    public:
        Parent(const char *);        // 생성자
        ~Parent() {   }                 // 소멸자
        void sayName();
};

class Child : public Parent {
    private:
        char name[21];
    public:
        Child(const char *);           // 생성자
        ~Child() {   }                    // 소멸자
        void sayName();
};

Parent :: Parent(const char *sname) {
    strcpy(name, sname);
}

void Parent :: sayName() {
    cout << "I am Parent, " << name << endl;
}

Child :: Child(const char *sname) : Parent(sname) {
    strcpy(name, sname);
}

void Child :: sayName() {
    cout << "I am a child, named as " << name << endl;
}

void main(void) {
    Child obj("Dooly");
    obj.sayName();
}




Visual C++ 6 로 컴파일할 경우 컴파일 명령은

     cl -GX testSubclassing.cpp

이다.


실행> testSubclassing
I am a child, named as Dooly




Linux/Unix 플랫폼에서 g++로 컴파일 하려면 main() 함수를 다소 수정해야 한다.

int main(void) {
    Child obj("Dooly");
    obj.sayName();
    return 0;
}

그리고 저장되는 소스 파일명도 testSubClassing.cc 로 한다.



컴파일> g++ testSubclassing.cc

실행> ./a.out
I am a child, named as Dooly


또는

컴파일> g++ -o testSubclassing testSubclassing.cc

실행> ./testSubclassing
I am a child, named as Dooly






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

ASCII(애스키)란 American Standard Code for Information Interchange의 줄임글로서, 영문자에 기초한 문자 인코딩이다.  이 문자 인코딩에는 C0 제어문자(C0 control character)도 포함되어 있다.  ( 참고:  ASCII - Wikipedia, the free encyclopedia )

다음은  7bit ASCII 코드표를 만들어 보여주는 자바 소스 코드이다. 소스 코드 중에 진법변환에 필요한 함수

        convertAtoI()
        convertItoA()

의 구현도 포함되어 있다.

1. /*
2.  *  Filename: makeAsciiTableCPP.cpp
3.  *            Make a table of ascii codes.
4.  *
5.  *  Compile: cl /GX makeAsciiTableCPP.cpp
6.  *  Execute: makeAsciiTable
7.  *
8.  *      Date:  2008/03/27
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 81
20. enum { FALSE, TRUE };
22. void println(char s[]) {
23.     cout << s << endl;
24. }
26. void print(char s[]) {
27.     cout << s;
28. }
30. void printUsage() {
31.     println("Usage: makeAsciiTable");
32.     println("Make a table of ascii codes.");
33. }
35. char BASE36[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
37. void convertItoA(char *pstr, long num, int radix) {
38.     char tmp[2];
39.     char ret[MAX_BUF];
40.     char arr[MAX_BUF];
41.     long q, r;
42.     int i, n;
43.     int isNegative = FALSE;
44.     if (num < 0L) {
45.         isNegative = TRUE;
46.         num = -num;
47.     }
48.     arr[0] = '\0';
50.     q = num;
51.     r = 0L;
53.     while (q >= (long) radix) {
54.         r = q % (long) radix;
55.         q = q / (long) radix;
56.         tmp[0] = BASE36[r];
57.         tmp[1] = '\0';
58.         strcat(arr, tmp);
59.     }
60.     tmp[0] = BASE36[q];
61.     tmp[1] = '\0';
62.     strcat(arr, tmp);
64.     if (isNegative) {
65.         strcat(arr, "-");
66.     }
68.     n = strlen(arr);
69.     for (i = 0; i < n; i++) {
70.         ret[i] = arr[n - i - 1];
71.     }
72.     ret[n] = '\0';
73.     strcpy(pstr, (char *) ret);
74. }
76. long convertAtoI(const char *pstr, int radix) {
77.     char tmp[2];
78.     long ret = 0L;
79.     char arr[MAX_BUF];
80.     long q, r;
81.     int isNegative = FALSE;
82.     int len = strlen(pstr);
83.     char c;
84.     int i;
85.     long val;
87.     c = pstr[0];
88.     if (c == '-') {
89.        isNegative = TRUE;
90.     }
91.     else if (c >= '0' && c <= '9') {
92.         ret = (long) (c - '0');
93.     }
94.     else if (c >= 'A' && c <= 'Z') {
95.         ret = (long) (c - 'A') + 10L;
96.     }
97.     else if (c >= 'a' && c <= 'z') {
98.         ret = (long) (c - 'a') + 10L;
99.     }
101.     if (ret >= (long) radix) {
102.         println("        Invalid character!");
103.         return ret;
104.     }
106.     for (i = 1; i < len; i++) {
107.         c = pstr[i];
108.         ret *= radix;
109.         if (c >= '0' && c <= '9') {
110.             val = (long) (c - '0');
111.         }
112.         else if (c >= 'A' && c <= 'Z') {
113.             val = (long) (c - 'A') + 10L;
114.         }
115.         else if (c >= 'a' && c <= 'z') {
116.             val = (long) (c - 'a') + 10L;
117.         }
119.         if (val >= (long) radix) {
120.             println("        Invalid character!");
121.             return ret;
122.         }
123.         ret += val;
124.     }
126.     return ret;
127. }
129. char asc[33][4]  = {
130.      "NUL", "SOH", "STX", "ETX", "EOT",
131.      "ENQ", "ACK", "BEL", "BS", "HT",
132.      "LF", "VT", "FF", "CR", "SO",
133.      "SI", "DLE", "DC1", "DC2", "DC3",
134.      "DC4", "NAK", "SYN", "ETB", "CAN",
135.      "EM", "SUB", "ESC", "FS", "GS",
136.      "RS", "US", "Spc"
137.  };
139. char control[33][36]  = {
140.         "NUL (null)",
141.         "SOH (start of heading)",
142.         "STX (start of text)",
143.         "ETX (end of text)",
144.         "EOT (end of transmission)",
145.         "ENQ (enquiry)",
146.         "ACK (acknowledge)",
147.         "BEL (bell)",
148.         "BS  (backspace)",
149.         "TAB (horizontal tab)",
150.         "LF  (line feed, NL new line)",
151.         "VT  (vertical tab)",
152.         "FF  (form feed, NP new page)",
153.         "CR  (carriage return)",
154.         "SO  (shift out)",
155.         "SI  (shift in)",
156.         "DLE (data link escape)",
157.         "DC1 (device control 1)",
158.         "DC2 (device control 2)",
159.         "DC3 (device control 3)",
160.         "DC4 (device control 4)",
161.         "NAK (negative acknowledge)",
162.         "SYN (synchronous idle)",
163.         "ETB (end of trans. block)",
164.         "CAN (cancel)",
165.         "EM  (end of medium)",
166.         "SUB (substitute, EOF end of file)",
167.         "ESC (escape)",
168.         "FS  (file separator)",
169.         "GS  (group separator)",
170.         "RS  (record separator)",
171.         "US  (unit separator)",
172.     };
174. void makeTable() {
175.     char sbuf[MAX_BUF];
176.     char abuf[MAX_BUF/2];
177.     char tbuf[MAX_BUF/2];
178.     int i, j;
179.     unsigned char c;
181.     print("    ");
182.     for (i = 0; i < 8; i++) {
183.         print("+----");
184.     }
185.     print("+");
186.     println("");
188.     print("    ");
189.     print("| 0- ");
190.     print("| 1- ");
191.     print("| 2- ");
192.     print("| 3- ");
193.     print("| 4- ");
194.     print("| 5- ");
195.     print("| 6- ");
196.     print("| 7- ");
197.     print("|");
198.     println("");
200.     print("+---");
201.     for (i = 0; i < 8; i++) {
202.         print("+----");
203.     }
204.     print("+");
205.     println("");
207.     for (i = 0; i < 16; i++) {
208.         tbuf[0] = '\0';
209.         convertItoA(sbuf, (long) i, 16);
210.         strcat(tbuf, "| ");
211.         strcat(tbuf, sbuf);
212.         strcat(tbuf, " ");
213.         for (j = 0; j < 8; j++) {
214.             if (j*16 + i <= 32) {
215.                 sprintf(abuf, "| %-3s", asc[j*16 + i]);
216.             }
217.             else if (j*16 + i == 127) {
218.                 sprintf(abuf, "| %-3s", "DEL");
219.             }
220.             else {
221.                 c = (char) (j*16 + i);
222.                 sprintf(abuf, "| %2c ", c);
223.             }
224.             strcat(tbuf, abuf);
225.         }
226.         strcat(tbuf, "|");
227.         println(tbuf);
228.     }
230.     print("+---");
231.     for (i = 0; i < 8; i++) {
232.         print("+----");
233.     }
234.     print("+");
235.     println("");
236.     println("");
238.     for (i = 0; i < 16; i++) {
239.         sprintf(sbuf, "%-30s",  control[i]);
240.         sprintf(tbuf, "  %-34s",  control[i+16]);
241.         print(sbuf);
242.         println(tbuf);
243.     }
244. }
246. void main(int argc, char *argv[]) {
247.     if (argc > 1 && strcmp("-h", argv[1]) == 0) {
248.         printUsage();
249.         exit(1);
250.     }
251.     makeTable();
252. }

컴파일> cl /GX makeAsciiTableCPP.cpp

실행> makeAsciiTableCPP

    +----+----+----+----+----+----+----+----+
    | 0- | 1- | 2- | 3- | 4- | 5- | 6- | 7- |
+---+----+----+----+----+----+----+----+----+
| 0 | NUL| DLE| Spc|  0 |  @ |  P |  ` |  p |
| 1 | SOH| DC1|  ! |  1 |  A |  Q |  a |  q |
| 2 | STX| DC2|  " |  2 |  B |  R |  b |  r |
| 3 | ETX| DC3|  # |  3 |  C |  S |  c |  s |
| 4 | EOT| DC4|  $ |  4 |  D |  T |  d |  t |
| 5 | ENQ| NAK|  % |  5 |  E |  U |  e |  u |
| 6 | ACK| SYN|  & |  6 |  F |  V |  f |  v |
| 7 | BEL| ETB|  ' |  7 |  G |  W |  g |  w |
| 8 | BS | CAN|  ( |  8 |  H |  X |  h |  x |
| 9 | HT | EM |  ) |  9 |  I |  Y |  i |  y |
| A | LF | SUB|  * |  : |  J |  Z |  j |  z |
| B | VT | ESC|  + |  ; |  K |  [ |  k |  { |
| C | FF | FS |  , |  < |  L |  \ |  l |  | |
| D | CR | GS |  - |  = |  M |  ] |  m |  } |
| E | SO | RS |  . |  > |  N |  ^ |  n |  ~ |
| F | SI | US |  / |  ? |  O |  _ |  o | DEL|
+---+----+----+----+----+----+----+----+----+

NUL (null)                      DLE (data link escape)
SOH (start of heading)          DC1 (device control 1)
STX (start of text)             DC2 (device control 2)
ETX (end of text)               DC3 (device control 3)
EOT (end of transmission)       DC4 (device control 4)
ENQ (enquiry)                   NAK (negative acknowledge)
ACK (acknowledge)               SYN (synchronous idle)
BEL (bell)                      ETB (end of trans. block)
BS  (backspace)                 CAN (cancel)
TAB (horizontal tab)            EM  (end of medium)
LF  (line feed, NL new line)    SUB (substitute, EOF end of file)
VT  (vertical tab)              ESC (escape)
FF  (form feed, NP new page)    FS  (file separator)
CR  (carriage return)           GS  (group separator)
SO  (shift out)                 RS  (record separator)
SI  (shift in)                  US  (unit separator)

컴퓨터 프로그래밍에서 꼭 알아두어야 할 주요 진법은 당연히 10진법, 2진법, 8진법, 16진법이다.
다음은  0 에서 15 까지의 정수를 10진법, 2진법, 8진법, 16진법의 표로 만들어 보여주는 C++ 소스 코드이다. 진법 변환에 필요한 함수

        convertAtoI(string, radix)
        convertItoA(long, radix)

를 C++ 코드로 자체 작성하여 사용하였다.

1. /*
2.  *  Filename: makeRadixTableCPP.cpp
3.  *            Show the radix table with 10-, 2-, 8-, 16-radices.
4.  *
5.  *  Compile: cl /EHsc makeRadixTableCPP.cpp
6.  *  Execute: makeRadixTable
7.  *
8.  *      Date:  2008/03/27
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 81
20. enum { FALSE, TRUE };
22. void println(char s[]) {
23.     cout << s << endl;
24. }
26. void print(char s[]) {
27.     cout << s;
28. }
30. void printUsage() {
31.     println("Usage: makeRadixTableCPP");
32.     println("Show the radix table with 10-, 2-, 8-, 16-radices.");
33. }
35. char BASE36[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
37. void convertItoA(char *pstr, long num, int radix) {
38.     char tmp[2];
39.     char ret[MAX_BUF];
40.     char arr[MAX_BUF];
41.     long q, r;
42.     int i, n;
43.     int isNegative = FALSE;
45.     if (num < 0L) {
46.         isNegative = TRUE;
47.         num = -num;
48.     }
50.     arr[0] = '\0';
51.     q = num;
52.     r = 0L;
54.     while (q >= (long) radix) {
55.         r = q % (long) radix;
56.         q = q / (long) radix;
57.         tmp[0] = BASE36[r];
58.         tmp[1] = '\0';
59.         strcat(arr, tmp);
60.     }
62.     tmp[0] = BASE36[q];
63.     tmp[1] = '\0';
64.     strcat(arr, tmp);
65.     if (isNegative) {
66.         strcat(arr, "-");
67.     }
68.     n = strlen(arr);
69.     for (i = 0; i < n; i++) {
70.         ret[i] = arr[n - i - 1];
71.     }
72.     ret[n] = '\0';
73.     strcpy(pstr, (char *) ret);
74. }
76. long convertAtoI(const char *pstr, int radix) {
77.     char tmp[2];
78.     long ret = 0L;
79.     char arr[MAX_BUF];
80.     long q, r;
81.     int isNegative = FALSE;
82.     int len = strlen(pstr);
83.     char c;
84.     int i;
85.     long val;
86.     c = pstr[0];
87.     if (c == '-') {
88.        isNegative = TRUE;
89.     }
90.     else if (c >= '0' && c <= '9') {
91.         ret = (long) (c - '0');
92.     }
93.     else if (c >= 'A' && c <= 'Z') {
94.         ret = (long) (c - 'A') + 10L;
95.     }
96.     else if (c >= 'a' && c <= 'z') {
97.         ret = (long) (c - 'a') + 10L;
98.     }
99.     if (ret >= (long) radix) {
100.         println("        Invalid character!");
101.         return ret;
102.     }
104.     for (i = 1; i < len; i++) {
105.         c = pstr[i];
106.         ret *= radix;
107.         if (c >= '0' && c <= '9') {
108.             val = (long) (c - '0');
109.         }
110.         else if (c >= 'A' && c <= 'Z') {
111.             val = (long) (c - 'A') + 10L;
112.         }
113.         else if (c >= 'a' && c <= 'z') {
114.             val = (long) (c - 'a') + 10L;
115.         }
116.         if (val >= (long) radix) {
117.             println("        Invalid character!");
118.             return ret;
119.         }
120.         ret += val;
121.     }
122.     return ret;
123. }
125. void makeTable() {
126.     char sbuf[MAX_BUF];
127.     char abuf[MAX_BUF/2];
128.     char tbuf[MAX_BUF/2];
129.     int i;
131.     for (i = 0; i < 4; i++) {
132.         print("+-------");
133.     }
134.     print("+");
135.     println("");
137.     print("|  Dec");
138.     print("\t|   Bin");
139.     print("\t|  Oct");
140.     print("\t|  Hex  |");
141.     println("");
143.     for (i = 0; i < 4; i++) {
144.         print("+-------");
145.     }
146.     print("+");
147.     println("");
149.     for (i = 0; i < 16; i++) {
150.         sprintf(sbuf, "|   %2d", i);
151.         convertItoA((char *)abuf, (long) i, 2);
152.         sprintf(tbuf, "\t|  %4s", abuf);
153.         strcat(sbuf, tbuf);
155.         convertItoA((char *)abuf, (long) i, 8);
156.         sprintf(tbuf, "\t|   %2s", abuf);
157.         strcat(sbuf, tbuf);
159.         convertItoA((char *)abuf, (long) i, 16);
160.         sprintf(tbuf, "\t|    %-2s |", abuf);
161.         strcat(sbuf, tbuf);
162.         println(sbuf);
163.     }
165.     for (i = 0; i < 4; i++) {
166.         print("+-------");
167.     }
168.     print("+");
169.     println("");
170. }
172. void main(int argc, char *argv[]) {
173.     if (argc > 1 && strcmp("-h", argv[1]) == 0) {
174.         printUsage();
175.         exit(1);
176.     }
177.     makeTable();
178. }

컴파일> cl /EHsc makeRadixTableCPP.cpp

실행> makeRadixTableCPP

+-------+-------+-------+-------+
|  Dec  |   Bin |  Oct  |  Hex  |
+-------+-------+-------+-------+
|    0  |     0 |    0  |    0  |
|    1  |     1 |    1  |    1  |
|    2  |    10 |    2  |    2  |
|    3  |    11 |    3  |    3  |
|    4  |   100 |    4  |    4  |
|    5  |   101 |    5  |    5  |
|    6  |   110 |    6  |    6  |
|    7  |   111 |    7  |    7  |
|    8  |  1000 |   10  |    8  |
|    9  |  1001 |   11  |    9  |
|   10  |  1010 |   12  |    A  |
|   11  |  1011 |   13  |    B  |
|   12  |  1100 |   14  |    C  |
|   13  |  1101 |   15  |    D  |
|   14  |  1110 |   16  |    E  |
|   15  |  1111 |   17  |    F  |
+-------+-------+-------+-------+

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

다음은  대화형 모드(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 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  이차방정식 x^2 - x - 1  = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 C++ 애플리케이션 소스이다. 황금비율을 구하는 비례방정식은   1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1  = 0 이다.

See:  Golden ratio - Sajun.org

1. /*
2.  *  Filename: testGoldenRatioCPP.cpp
3.  *    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
4.  *
5.  *   Compile: cl -GX testGoldenRatioCPP.cpp
6.  *
7.  *   Execute: testGoldenRatioCPP
8.  *
9.  *      Date:  2008/03/24
10.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
11.  */
13. #include <iostream>
14. #include <string>
15. #include <cmath>
17. using namespace std;
19. typedef struct _PAIR {
20.     double x1;
21.     double x2;
22. } PAIR;
24. void printUsing() {
25.     cout << "Using: testGoldenRatioCPP [-h|-help]" << endl;
26.     cout << "This calculates the value of the golden ratio." << endl;
27. }
29. // 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
30. PAIR *findQuadraticRoot(double a, double b, double c) {
31.     static PAIR zeros;
32.     if (a == 0.0) {
33.         cerr << "Since the highest coefficient is zero, the given equation is not a quadratic equation." << endl;
34.         exit(1);
35.     }
36.     else if (b*b - 4*a*c < 0.0) {
37.         cerr << "Since the discriminant " << (b*b - 4*a*c) << " is negative, the given equation has no real root." << endl;
38.         exit(1);
39.     }
41.     zeros.x1 = (-b + sqrt(b*b - 4*a*c)) / (2.0 * a);
42.     zeros.x2 = (-b - sqrt(b*b - 4*a*c)) / (2.0 * a);
43.     return (PAIR *) &zeros;
44. }
46. void main(int argc, char *argv[]) {
47.     double x1, x2;
48.     PAIR *values = (PAIR *) findQuadraticRoot(1.0, -1.0, -1.0);
49.     if (argc > 1 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0)) {
50.         printUsing();
51.         exit(1);
52.     }
54.     values = findQuadraticRoot(1.0, -1.0, -1.0);
55.     x1 = values->x1;
56.     x2 = values->x2;
57.     if (x1 >= x2) {
58.         cout << "The bigger root is " << x1 << endl;
59.         cout << "and the less root is " << x2 << endl;
60.     }
61.     else {
62.         cout << "The bigger root is " << x2 << endl;
63.         cout << "and the less root is " << x1 << endl;
64.     }
65. }

컴파일> cl -GX testGoldenRatioCPP.cpp

실행> testGoldenRatioCPP
The bigger root is 1.618034,
and the less root is -0.618034.




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

1. /*
2.  *  Filename: testCTimeCPP.cpp
3.  *
4.  *  Compile: cl -GX testCTimeCPP.cpp
5.  *
6.  *  Execute: testCTimeCPP
7.  */
9. #include <iostream>
10. #include <ctime>
12. using namespace std;
14. char weekNames[7][3] = {
15.     "일", "월", "화", "수", "목", "금", "토"
16. };
18. int main() {
19.     time_t timer;
20.     struct tm *t;
22.     timer = time(NULL); // 현재 시각을 초 단위로 얻기
23.     t = localtime(&timer); // 초 단위의 시간을 분리하여 구조체에 넣기
25.     // 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
26.     cout << "UTC: " << timer << "초" << endl;
28.     // 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
29.     cout << (t->tm_year + 1900) << "년 " << (t->tm_mon + 1) << "월 " << t->tm_mday << "일 (" << weekNames[t->tm_wday] << "요일) ";
30.     cout << t->tm_hour << "시 " << t->tm_min << "분 " << t->tm_sec << "초" << endl;
33.     // t->tm_yday의 값: 1월 1일은 0, 1월 2일은 1
34.     cout << "올해 몇 번째 날: " << (1 + t->tm_yday);
36.     // t->tm_isdst의 값: 0 이면 서머타임 없음
37.     cout << "서머타임 적용 여부: " << ((t->tm_isdst == 0) ? "안함" : "함") << endl;
38.     return 0;
39. }

컴파일> cl testCTimeCPP.cpp

실행> testCTimeCPP
 UTC: 1206323262초
2008년 3월 24일 (월요일) 10시 47분 42초
올해 몇 번째 날: 84서머타임 적용 여부: 안함

다음 소스 코드는 http://www.daniweb.com/code/snippet808.html 에서 볼 수 있는 (주어진 범위 안에서) 소수(prime number, 북한 용어로는 씨수) 찾기 C++ 소스 코드이다.
 

1. # include<iostream.h>
2. # include<math.h>
4. void main()
5. {
6.     int flag=0;
7.     unsigned long l, h, temp;
9.     cout<<"Enter the lower limit:"; cin>>l;
10.     cout<<"Enter the higher limit:"; cin>>h;
12.     if(l%2==0)
13.     {
14.          if(l==2) cout<<"2\t";
15.          l++; //taking only odd no
16.     }
18.      for(;l<=h;l+=2, flag=0)
19.      {
20.           temp=sqrt(l);
21.           if(temp%2==0) temp++; //taking only odd no
23.           for(; temp>2; temp--)
24.          {
25.              if(l%temp==0)
26.              {
27.                  flag=1;
28.                  break;
29.               }
30.          }
32.          if(flag==0) cout<<l<<"\t";
33.     }
34. }
    

1. #include <iostream.h>
2. # include <math.h>
4. void main() {
6.     int flag = 0;
7.     unsigned long l, h, temp;
9.     cout << "Enter the lower limit: ";
10.     cin >> l;
11.     cout << "Enter the upper limit: ";
12.     cin >> h;
14.     if (l % 2 == 0) {
15.          if (l == 2)
16.              cout << "2\t";
17.          l++;    //  Taking only odd numbers.
18.     }
20.     for (; l <= h; l += 2, flag = 0) {
21.         temp = sqrt(l);
22.         if (temp % 2 == 0)
23.            temp++;    //  Taking only odd numbers.
25.         for (; temp > 2; temp--) {
26.            if (l % temp == 0) {
27.                flag = 1;
28.                break;
29.            }
30.        }
32.        if (flag == 0)
33.            cout << l << "\t";
34.     }
35. }

하지만 아직 표준 C++에 맞지 않으므로 더 고쳐 보았다.

1. #include <iostream>
2. #include <cmath>
4. using namespace std;
6. void main() {
8.     int flag = 0;
9.     unsigned long l, h, temp;
11.     cout << "Enter the lower limit: ";
12.     cin >> l;
13.     cout << "Enter the upper limit: ";
14.     cin >> h;
16.     if (l % 2 == 0) {
17.          if (l == 2)
18.              cout << "2\t";
19.          l++;    //  Taking only odd numbers.
20.     }
22.     for (; l <= h; l += 2, flag = 0) {
23.         temp = sqrt(l);
24.         if (temp % 2 == 0)
25.            temp++;    //  Taking only odd numbers.
27.         for (; temp > 2; temp--) {
28.            if (l % temp == 0) {
29.                flag = 1;
30.                break;
31.            }
32.        }
34.        if (flag == 0)
35.            cout << l << "\t";
36.     }
37. }

            for (; temp > 2; temp--) {
               if (l % temp == 0) {
                   flag = 1;
                   break;
               }
          }

예를 들어 l =  3*1999993 = 5999979 인 경우 sqrt(5999979) ≒ 2449.5 이므로,
for 반복문을 시작하면서 temp = 2995 되고 t = 3 이 될 때 까지 무려 1496번을 반복하게 된다.
이 반복문 안의 나눗셈 과정  l % temp 부분을 l % 3 부터 시작하여 l % 5, l % 7, l % 9 ... 이런 식으로 증가시키면서 반복하는 과정으로 진행한다면, l =  3*1999993 = 5999979 인 경우 ㅣ% 3 = 0 이므로 더 이상 반복하지 않고 바로 반복문을 탈출하고 5999979는 소수가 아니라고 판정내린다.

이런 이유로 인하여, 위 소스 코드를 리팩토링하여 다음 처럼 수정하였다.

1. #include <iostream>
2. #include <cmath>
4. using namespace std;
6. void main() {
8.     int flag = 0;
9.     unsigned long l, h, j, temp;
11.     cout << "Enter the lower limit: ";
12.     cin >> l;
13.     cout << "Enter the upper limit: ";
14.     cin >> h;
16.     if (l % 2 == 0) {
17.          if (l == 2)
18.              cout << "2\t";
19.          l++;    //  Taking only odd numbers.
20.     }
22.     for (; l <= h; l += 2, flag = 0) {
23.         temp = sqrt(l);
24.         if (temp % 2 == 0)
25.            temp++;    //  Taking only odd numbers.
27.         for (j = 3L; j <= temp; j += 2L) {
28.            if (l % j == 0L) {
29.                flag = 1;
30.                break;
31.            }
32.        }
34.        if (flag == 0)
35.            cout << l << "\t";
36.     }
37. }

 
컴파일> cl /GX findPrimes.cpp

실행> findPrimes
Enter the lower limit: 200
Enter the upper limit: 500
211     223     227     229     233     239     241     251     257     263
269     271     277     281     283     293     307     311     313     317
331     337     347     349     353     359     367     373     379     383
389     397     401     409     419     421     431     433     439     443
449     457     461     463     467     479     487     491     499

1. /*
2.  *  Filename:  testGMPXX.cc
3.  *
4.  *   Compile:  g++ -o testGMPXX testGMPXX.cc -lgmpxx -lgmp
5.  *
6.  *   Execute:  ./testGMPXX
7.  */
9. #include <gmpxx.h>
10. #include <iostream>
12. using namespace std;
14. int main (void) {
15.     mpz_class a, b, c;
16.     a = 1234;
17.     b = "-5678";
18.     c = a + b;
19.     cout << "sum is " << c << "\n";
20.     cout << "absolute value is " << abs(c) << "\n";
21.      return 0;
22. }

컴파일> g++ -o testGMPXX testGMPXX.cc -lgmpxx -lgmp

실행> ./testGMPXX
sum is -4444
absolute value is 4444




* Visual C++ 9.0 (Visual Studio 2008) 에서 컴파일하기:
컴파일>cl testGMPXX.cpp gmp.lib

실행> testGMPXX
sum is -4444
absolute value is 4444



** 영문  위키피디아에서 소개하는 MinGW

** MinGW 의 공식 웹사이트에서 MinGW 를 설치하면 gcc 버전이 3.4.5 밖에 되지 않고,
    gmp 라이브러리도 수동으로 설치헤야 하는 번거로움이 있으므로,
    여기서는 Luna MinGW 를 설치하기로 한다. Luna MinGW 를 설치하면,
    현재 최신 버전인 gcc4.5.0 을 쓸 수 있다. 그 대신 g++ 로 컴파일 후에 쓰일 
    런타임 다이나믹 라이브러리 libgmpxx-4.dll 은 별도로 구하여 설치해야 한다.

** 윈도우에 Luna MinGW (with GCC 4.5.0) 설치하기:
      * Luna MinGW 홈페이지(MinGW GCC C/C++ Compiler package with installer) 
      * Luna MinGW 설치파일 다운로드
      1) 설치는 C:\MinGW 에 한것으로 간주한다.
      2) gcc 에서 gmp 라이브러리는 추가 설치 없이 바로 쓸 수 있는데,
         g++ 로는 컴파일은 되지만 컴파일된 실행파일을 실행하면 
         limgmpxx-4.dll 파일이 없다고 에러가 날 것이다. 이때는 아래 처럼 
         limgmpxx-4.dll 파일을 컴파일해서 만들던가 이미 만들어진 것을 PATH 가
         걸려 있는 곳에 넣어두어야 한다.
         아래는 limgmpxx-4.dll 파일을 구할 수 있는 곳이다. 
       
** g++에서 gmp를 사용하기 위해 libgmpxx-4.dll 구하여 설치하기:
      * 소스포지에서 libgmpxx-5.0.1-1-mingw32-dll-4.tar.lzma 다룬로드하기
      1)  확장명이 lzma 인 파일은 7zip 으로 풀어야 한다.
      2) 위의 파일을 받아서 7zip으로 압축 해제하여 libgmpxx-4.dll 을
          C:\MinGW\bin 에 복사힌다.
         (C:\MinGW 은 Luna MinGW 가 설치된 디렉토리이다)

** gcc 버전 확인하기
C:\test\mingw>gcc -v
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=c:/mingw/bin/../libexec/gcc/mingw32/4.5.0/lto-wrapper.exe
Target: mingw32
Configured with: ../gcc-4.5.0/configure --enable-languages=c,c++,ada,fortran,obj
c,obj-c++ --disable-sjlj-exceptions --with-dwarf2 --enable-shared --enable-libgo
mp --disable-win32-registry --enable-libstdcxx-debug --enable-version-specific-r
untime-libs --disable-werror --build=mingw32 --prefix=/mingw
Thread model: win32
gcc version 4.5.0 (GCC)

** g++ 버전 확인하기
C:\test\mingw>g++ -v
Using built-in specs.
COLLECT_GCC=g++
COLLECT_LTO_WRAPPER=c:/mingw/bin/../libexec/gcc/mingw32/4.5.0/lto-wrapper.exe
Target: mingw32
Configured with: ../gcc-4.5.0/configure --enable-languages=c,c++,ada,fortran,obj
c,obj-c++ --disable-sjlj-exceptions --with-dwarf2 --enable-shared --enable-libgo
mp --disable-win32-registry --enable-libstdcxx-debug --enable-version-specific-r
untime-libs --disable-werror --build=mingw32 --prefix=/mingw
Thread model: win32
gcc version 4.5.0 (GCC)


** Luna MinGW의 GCC 4.5.0 의 g++로 컴파일하기 (소스 파일의 확장명을 cc로 바꾸었다):
C:\test\mingw>g++ -o testGMPXX testGMPXX.cc -lgmpxx -lgmp

C:\test\mingw>testGMPXX
sum is -4444
absolute value is 4444





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

1. /*
2.  *  Filename: testSyntheticDivisionCPP.cpp
3.  *
4.  *  Purpose:  Find the quotient and remainder when some polynomial is
5.  *            divided by a monic polynomial of the first degree.
6.  *
7.  *  Compile:  cl -GX testSyntheticDivisionCPP.cpp
8.  *        Or  cl /EHsc testSyntheticDivisionCPP.cpp
9.  *
10.  *  Execute:  testSyntheticDivisionCPP -2 1 3 3 1
11.  */
13. #include <iostream>
14. #include <string>
15. #include <cmath>
16. #include <memory>
18. using namespace std;
20. void print(char str[]) {
21.     cout << str;
22. }
24. void println() {
25.     cout << endl;
26. }
28. void println(char str[]) {
29.     cout << str << endl;
30. }
32. // 사용법 표시
33. void printUsage() {
34.      cout << "사용법: testSyntheticDivisionCPP [수] [피제식의 계수들]" << endl;
35.      cout << "조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다." << endl;
36. }
39. // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
40. char *simplify(double v) {
41.     int n;
42.     static char t[] = "                               ";
43.     char tmp[] = "                               ";
44.     sprintf(t, "%g", v);
45.     n = strlen(t);
46.     if ((n > 2) && (t[n - 2] == '.') && (t[n - 1] == '0'))
47.         t[n-2] = '\0';
48.     return (char *) t;
49. }
51. // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
52. // 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
53. char *simplify(double v, int width) {
54.     int n, len;
55.     static char t[] = "                               ";
56.     char tmp[] = "                               ";
57.     sprintf(t, "%g", v);
58.     n = strlen(t);
59.     if ((n > 2) && (t[n - 2] == '.') && (t[n - 1] == '0'))
60.         t[n-2] = '\0';
61.     len = strlen(t);
62.     strcpy(tmp, t);
63.     if (len < width) {
64.         strncpy(t, "               ", width - len);
65.         t[width - len] = '\0';
66.         strcat(t, tmp);
67.     }
68.     return (char *) t;
69. }
71. // 다항식을 내림차순의 문자열로로 반환하는 함수
72. // 반환된 문자열은 동적 메모리에 존재하므로.
73. // 사용 후 반드시 해제(free)하여야 한다.
74. char *toPolyString(double c[], int size) {
75.     int SIZE = size;
76.     int i;
77.     static char t[300];
78.     char tmp[80];
79.     char *pc = simplify(c[0], -1);
80.     char *pci;
82.     if (SIZE > 2) {
83.         if (strlen(pc) == 1 && pc[0] == '1')
84.             sprintf(t,  "x^%d", SIZE - 1);
85.         else if (strlen(pc) == 2 && pc[0] == '-' && pc[1] == '1')
86.             sprintf(t,  "-x^%d", SIZE - 1);
87.         else
88.             sprintf(t,  "%s x^%d", simplify(c[0], -1), SIZE - 1);
89.     }
90.     else if (SIZE == 2) {
91.         if (strlen(pc) == 1 && pc[0] == '1')
92.             strcpy(t,  "x");
93.         else if (strlen(pc) == 2 && pc[0] == '-' && pc[1] == '1')
94.             strcpy(t,  "-x");
95.         else
96.             sprintf(t,  "%s x", simplify(c[0], -1));
97.     }
98.     else if (SIZE == 1) {
99.         sprintf(t,  "%s", simplify(c[0], -1));
100.     }
102.     for (i = 1; i < SIZE; i++) {
103.         pci = simplify(c[i], -1);
104.         if (SIZE - 1 - i > 1) {
105.             if (c[i] > 0.0) {
106.                 if (strlen(pci) == 1 && pci[0] == '1') {
107.                     sprintf(tmp,  " + x^%d", SIZE - 1 - i);
108.                     strcat(t, tmp);
109.                 }
110.                 else {
111.                     sprintf(tmp,  " + %s x^%d", simplify(c[i], -1), SIZE - 1 - i);
112.                     strcat(t, tmp);
113.                 }
114.             }
115.             else if (c[i] < 0.0) {
116.                 if (strlen(pci) == 2 && pci[0] == '-' && pci[1] == '1') {
117.                     sprintf(tmp,  " - x^%d", SIZE - 1 - i);
118.                     strcat(t, tmp);
119.                 }
120.                 else {
121.                     sprintf(tmp,  " - %s x^%d", simplify(fabs(c[i]), -1), SIZE - 1 - i);
122.                     strcat(t, tmp);
123.                 }
124.             }
125.         }
126.         else if (SIZE - 1 - i == 1) {
127.             if (c[i] > 0.0) {
128.                 if (strlen(pci) == 1 && pci[0] == '1') {
129.                     strcat(t, " + x");
130.                 }
131.                 else {
132.                     sprintf(tmp,  " + %s x", simplify(c[i], -1));
133.                     strcat(t, tmp);
134.                 }
135.             }
136.             else if (c[i] < 0.0) {
137.                 if (strlen(pci) == 2 && pci[0] == '-' && pci[1] == '1') {
138.                     strcat(t, " - x");
139.                 }
140.                 else {
141.                     sprintf(tmp,  " - %s x", simplify(fabs(c[i]), -1));
142.                     strcat(t, tmp);
143.                 }
144.             }
145.         }
146.         else if (SIZE - 1 - i == 0) {
147.             if (c[i] > 0.0) {
148.                 sprintf(tmp,  " + %s", simplify(c[i], -1));
149.                 strcat(t, tmp);
150.             }
151.             else if (c[i] < 0.0) {
152.                 sprintf(tmp,  " - %s", simplify(fabs(c[i]), -1));
153.                 strcat(t, tmp);
154.             }
155.         }
156.     }
157.     return (char *) t;
158. }
160. // 다항식 나눗셈 결과를
161. //     (피제식) = (제식)(몫) + (나마지)
162. // 형태로 출력
163. void printDivisionResult(double a, double c[], double b[], int size) {
164.     int SIZE = size;
165.     int i;
166.     double *pTmpPoly;
167.     double r;
168.     double monic[] = { 1.0, 0.0 };
170.     print("  ");
171.     print(toPolyString(c, SIZE));
172.     println("");
174.     print("    = ( ");
175.     monic[1] = -a;
176.     print(toPolyString(  monic, 2 ));
177.     print(" )");
179.     pTmpPoly = (double *)  calloc(SIZE - 1, sizeof(double));
180.     for (i = 0; i < SIZE - 1; i++) {
181.         pTmpPoly[i] = b[i];
182.     }
183.     print("( ");
184.     print(toPolyString(pTmpPoly, SIZE - 1));
185.     print(" )");
186.     free(pTmpPoly);
188.     r = b[SIZE - 1];
189.     if (r > 0.0) {
190.         print(" + ");
191.         print(simplify(r, -1));
192.     }
193.     else if (r < 0.0) {
194.         print(" - ");
195.         print(simplify(fabs(r), -1));
196.     }
197.     println();
198. }
200. // 조립제법 계산표 출력 함수
201. void printSyntheticTable(double a, double c[], double s[], double q[], int size) {
202.     int SIZE = size;
203.     int i;
204.     print("       | ");
205.     print(simplify(c[0], 6));
206.     for (i = 1; i < SIZE; i++) {
207.         print("  ");
208.         print(simplify(c[i], 6));
209.     }
210.     println();
212.     print(simplify(a, 6));
213.     print(" | ");
214.     print("        ");
215.     print(simplify(s[1], 6));
216.     for (i = 2; i < SIZE; i++) {
217.         print("  ");
218.         print(simplify(s[i], 6));
219.     }
220.     println();
222.     print("       |-");
223.     for (i = 0; i < SIZE; i++) {
224.         print("--------");
225.     }
226.     println();
228.     print("         ");
229.     print(simplify(q[0], 6));
230.     for (i = 1; i < SIZE; i++) {
231.         print("  ");
232.         print(simplify(q[i], 6));
233.     }
234.     println();
235. }
237. // C++ 언어의 실행 시작 지점
238. int main(int argc, char *argv[]) {
239.     int i;
240.     int SIZE = argc - 2;
241.     double a, c[15], s[15], b[15];
243.     if (argc < 4) {
244.         printUsage();
245.         exit(1);
246.     }
248.     //////////////////////////////////////////////////////
249.     // 피제식은 c_0 x^n +  c_1 x^(n -1) + ... + c_n
250.     // 제식은 x -  a
251.     a = atof(argv[1]);
253.     for (i = 0; i < SIZE; i++) {
254.      c[i] = atof(argv[i + 2]);
255.     }
257.     //////////////////////////////////////////////////////
258.     // 조립제법의 주요 부분
259.     s[0] = 0.0;
260.     b[0] = c[0];
261.     for (i = 1; i < SIZE; i++) {
262.         s[i] = b[i-1]*a;
263.         b[i] = c[i] + s[i];
264.     }
266.     print("몫의 계수는 ");
267.     for (i = 0; i < SIZE - 2; i++) {
268.         print(simplify(b[i], -1));
269.         print(", ");
270.     }
271.     print(simplify(b[SIZE - 2], -1));
272.     print(" 이고, 나머지는 ");
273.     print(simplify(b[SIZE - 1], -1));
274.     println(" 이다.");
275.     println();
277.     //////////////////////////////////////////////////////
278.     // 조립제법 표를 출력한다.
279.     printSyntheticTable(a, c, s, b, SIZE);
280.     println();
282.     //////////////////////////////////////////////////////
283.     // (피제식) = (제식) x (몫) + (나머지)
284.     printDivisionResult(a, c, b, SIZE);
285.     return 0;
286. }

컴파일> cl -EHsc testSyntheticDivisionCPP.cpp

실행> testSyntheticDivisionCPP 1 2 3 4 5
몫의 계수는 2, 5, 9 이고, 나머지는 14 이다.

       |      2       3       4       5
     1 |              2       5       9
       |---------------------------------
              2       5       9      14

  2 x^3 + 3 x^2 + 4 x + 5
    = ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14