1. 프로그래밍의 이해

목차

1. 프로그래밍의 이해2. 변수와 연산자3. 반복과 조건4. 1 차원 배열과 포인터5. 2 차원 배열과 포인터6. 구조체7. 함수8. 표준함수

목차

09. C 문법의 확장10. 객체지향 프로그래밍11. 클래스12. 연산자 오버로딩13. 상속14. 템플릿15. 예외처리

Chapter 1프로그래밍의 이해

이진수십진수 이진수 8

진수

16진수

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

16 10000

20 10

컴퓨터의 구조

CPU

제어장치

산술 / 논리장치

메모리

입력 장치 출력 장치

외부 저장 장치

기계어

X = (A+B)×(C+D)

1. MOVE A, R1

2. ADD B, R1

3. MOVE C, R2

4. ADD D, R2

5. MUL R2, R1

6. MOVE R1, X

프로그래밍 언어 고수준 언어 vs. 저수준 언어 컴파일 , 컴파일러 라이브러리 링크 , 링커

C/C++ 이란 고수준 프로그래밍 언어 베이직 자바 보다는 저수준 언어 효율적이고 유연

C C++

함수

리턴형 함수이름 ( 입력 ){

함수의 몸체}

첫번째 프로그램

#include <stdio.h>

int main(void)

{

printf("Hello\n");

return 0;

}

프로그램 작성 과정

소스코드 작성 및 수정

에러발생

컴파일

링크

에러발생

실행파일

에러발생

완성

No

No

No

Yes

Yes

Yes

주석/* 이 프로그램은 첫번째로 작성한 예제 프로그램으로 ,화면에 Hello 라는 문장을 출력 . */

/* stdio.h 에는 printf 를 비롯한 표준 입출력 함수 선언 . printf 함수를 사용하려면 , 이 헤더 파일을 인클루드 */#include <stdio.h>

int main(void)

{

printf("Hello\n"); // 화면에 Hello 를 출력합니다 .return 0; // 리턴 값은 나중에 다시 공부

}

실습과제 다음과 같은 결과를 화면에 출력하는 프로그램을 작성하세요 .

********************************************

Let’s study C/C++ programming!!!

********************************************

실습과제 해설#include <stdio.h>

int main(void){

printf("************************************\n");printf(" Let's study C/C++ programming!!! \n");printf("************************************\n");return 0;

}

Chapter 2변수와 연산자

컴퓨터의 데이터 저장 방식 1bit = 0/1

2bit = 00/01/10/11

3bit = 000/001/010/011/ 100/101/110/111

데이터 타입

데이터타입 길이 표현가능한범위

정수형

unsigned char1 바이트 0 ~ 255

unsigned short2 바이트 0 ~ 65,535

unsigned long (int)

4 바이트 0 ~ 4,294,967,295

char1 바이트 -128 ~ 127

short2 바이트 -32,768 ~ 32,768

long (int)4 바이트 -2,147,483,648 ~ 2,147,483,647

실수형float

4 바이트 ±3.4×10-37, ±3.4×1038

double8 바이트 ±1.7×10-307, ±1.7×10308

음수 표현

이진수 표현 unsigned char

char

00000000 0 0

00000001 1 1

00000010 2 2

... ... ...

01111110 126 126

01111111 127 127

10000000 128 -128

10000001 129 -127

... ... ...

11111110 254 -2

11111111 255 -1

0 127 255-128-256

unsigned charchar

실수표현

부호 지수 ( 소수점 위치 ) 가수 ( 유효숫자 )

1 8 23float

1 11 52double

문자 표현

32 33 ! 34 " 35 # 36 $ 37 % 38 & 39 '

40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 /

48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7

56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ?

64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G

72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O

80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W

88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _

96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g

104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o

112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w

120 x 121 y 122 z 123 { 124 | 125 } 126 ~

변수

int main(void)

{

int a, b, c; // 변수 선언a = 10; // 변수 사용b = 20;

c = a + b;

return 0;

}

변수 선언 및 초기화 int a, b, c;

int a;int b;int c;

int a = 10, b = 20, c;

초기화 상수 int a = 13; // 십진수 13int b = 013; // 8 진수 13, 십진수 11int c = 0x13; // 16 진수 13, 십진수 19

char ch = 'A'; // 숫자 65

변수이름 대소문자가 구별

Value, value

알파벳 , 숫자 , 언더바 (_) 조합 첫 글자는 숫자 불가

언더바 (_) 이외의 기호나 공백 불가

변수 값 출력

#include <stdio.h>

int main(void)

{

int radius = 10;

double pi = 3.141592;

printf("radius = %d, PI = %f\n", radius, pi);

return 0;

}

서식 문자서식문자 변환방법

%d 부호있는 10 진정수%u 부호없는 10 진정수%x 부호없는 16 진정수 , 소문자사용 (a, b, c, d, e, f)

%X 부호없는 16 진정수 , 대문자사용 (A, B, C, D, E, F)

%f 부호있는 10 진실수

%e 부동소수점표현방식의 10 진실수 (가수 e+ 지수형태로출

력 )

%E 부동소수점표현방식의 10 진실수 (가수 E+ 지수형태로출

력 )

%c 문자%s 문자열%p 포인터 ( 메모리주소 )

%% % 기호자체출력

자릿수 설정#include <stdio.h>

int main(void){int radius = 10;double pi = 3.141592;printf("radius = %05d\n", radius);printf("PI = %0.2f\n", pi);return 0;

}

기호 출력#include <stdio.h>

int main(void)

{

printf("\" 너 자신을 알라 \" 라고 소크라테스는 말했다 \n");

printf(" 일이 70%% 진행되었다 .\n");

printf("c:\\temp 폴더에 복사한다 .\n");

printf("\n");

printf(" 교통비 \t: %5d\n", 50000);

printf(" 잡비 \t: %5d\n", 2200);

return 0;

}

변수 값 입력#include <stdio.h>

int main(void)

{

int radius;

float pi;

scanf("%d %f", &radius, &pi);

return 0;

}

산술 연산자#include <stdio.h>

int main(void){

int val1=5, val2=2;printf("5+2 = %d\n", val1+val2); // 덧셈printf("5-2 = %d\n", val1-val2); // 뺄셈printf("5*2 = %d\n", val1*val2); // 곱셈printf("5/2 = %d\n", val1/val2); // 나눗셈printf("5%%2 = %d\n", val1%val2); // 나머지return 0;

}

산술 연산자 우선 순위 result = a+(b+c)*c/d;

result = b+c;result = result * c;result = result / d;result = result + a;

대입 연산자

val = 5;

5 = val; // error

산술연산자와 대입연산자의 결합 result = b+c;result = result * c;result = result / d;result = result + a;

result = b+c;result *= c;result /= d;result += a;

부호연산자 val2 = -val1; // 부호 val2 -= val1; // 산술 + 대입

증감 연산자 a = 1;b = ++a;

a = 1;b = a++;

관계 연산자 <, >, <=, >=, ==, !=

if(val1 == val2)printf(" 두 값이 같다 .\n");

논리연산자 if(val>10 && val<20)

printf(" 값은 10 과 20 사이에 있다 .\n");

if(val<10 || val>20)printf(" 값은 10 과 20 밖에 않다 .\n");

if(!val)printf(" 값은 0 이다 .\n");

조건선택연산자 「조건식」 ? 「값 1 」 : 「값 2 」

max = (val1>val2) ? val1 : val2;

비트 논리연산자 int val1=15, val2=28;

int logicAnd, bitAnd;

logicAnd = val1 && val2;

bitAnd = val1 & val2;

0 0 0 0 1 1 1 1

0 0 0 1 1 1 0 0

0 0 0 0 1 1 0 0

15:

28:

12:

쉬프트 연산자 a << 2; a >> 2;

삭제1 1 1 0 1 1 0 0

1 0 1 1 0 0

0 0

1 1

삽입

비트연산자와 대입연산자의 결합

결합전 결합후

a = a & b; a &= b;

a = a | b; a |= b;

a = a ^ b; a ^= b;

a = a << b; a <<= b;

a = a >> b; a >>= b;

4 비트 변수 분리#include <stdio.h>

int main(void)

{

unsigned char fourBitVal1=0x05, fourBitVal2=0x07;

unsigned char eightBitVal;

eightBitVal = fourBitVal1<<4;

eightBitVal |= fourBitVal2;

printf("%x, %x -> %x\n",

fourBitVal1, fourBitVal2, eightBitVal);

return 0;

}

4 비트 변수 합치기#include <stdio.h>

int main(void)

{

unsigned char eightBitVal=0x57;

unsigned char fourBitVal1, fourBitVal2;

fourBitVal1 = eightBitVal >> 4;

fourBitVal2 = eightBitVal & 0x0F;

printf("%x -> %x, %x\n",

eightBitVal, fourBitVal1, fourBitVal2);

return 0;

}

콤마연산자 int a=1, b=2;

a++, b++;

연산자의 우선순위우선순위 연산자 결합성

1 ( ), [ ], ->, . 2 sizeof, & (포인터 ), ++, ==, ~, !, * (포인터 ), -

(부호 )

3 * (곱셈 ), /, % 4 + (덧셈 ), - (뺄셈 ) 5 <<, >> 6 <, <=, >=, > 7 ==, != 8 & ( 비트논리 ) 9 ^

10 | 11 && 12 || 13 ? : 14 =, +=, *=, /=, %=, ^=, !=, <<=, >>= 15 , (콤마 )

데이터 타입의 계층 구조

char

short

long

float

double

대입연산자와 타입 변환 short s = 50;double d = s;

double d = 50.7;short s = d;

double d = 50.7;short s = (short)d;

산술연산자와 타입 변환 int i = 1;

double d = 2.0;double result = i/d;

int i = 1;double d = 2.0;int result = i/d;

int i = 1;double d = 2.0;int result = (int)i/d;

int i1 = 1;int i2 = 2;double result = i1/i2;

double result = (double)i1/i2;

double result = (double)(i1/i2);

상수의 데이터 타입 float pi = 3.141592;

float pi = 3.141592f;

데이터 타입의 크기#include <stdio.h>

int main(void)

{

int i=0;

double d=0.0;

printf("size of int: %d\n", sizeof(int));

printf("size of i: %d\n", sizeof(i));

printf("size of double: %d\n", sizeof(double));

printf("size of d: %d\n", sizeof(d));

return 0;

}

실습과제 키를 센티미터 단위로 입력 받아 미터와 센티미터 단위로 나누어

출력하는 프로그램을 작성하세요 .

실습과제 해설

#include <stdio.h>

int main(void)

{

int height;

printf(" 키를 센티미터 단위로 입력하세요 : ");

scanf("%d", &height);

printf(" 키가 %dm %dcm 이시군요 .\n",

height/100, height%100);

return 0;

}

실습과제 원의 반지름을 실수로 입력 받아 원의 둘레의 길이와 면적을 소수점

둘째 자리까지 출력하는 프로그램을 작성하세요 .


int main(void){

double radius; // 반지름double pi = 3.141592; // 원주율double perimeter; // 원둘레double area; // 원면적printf(" 원의 반지름을 입력하세요 : ");scanf("%lf", &radius); // 반지름을 입력 받음perimeter = 2.0 * pi * radius; // 원둘레 계산area = pi * radius * radius; // 원면적 계산printf(" 원둘레 : %.2f\n", perimeter); // 원둘레 출력printf(" 원면적 : %.2f\n", area); // 원면적 출력return 0;

}

실습과제 태어나서 지금까지 내가 먹은 밥값이 얼마나 되는지 계산하는

프로그램을 작성하세요 . 나이는 사용자로부터 입력 받고 하루 3 끼 식사를 하되 한끼 식사를 3 천원으로 계산하세요 .


int main(void){

int age; // 나이int cost; // 밥값 printf(" 만 나이를 입력하세요 : ");scanf("%d", &age);cost = age * 365 * 3 * 3000;printf(" 지금까지 밥값은 %d 원 입니다 .\n", cost);return 0;

}

Chapter 3반복과 조건

while 문#include <stdio.h>

int main(void){int loop = 1;while(loop <= 10){

printf("%d Little Indian\n", loop);loop++;

}return 0;

}

do ~ while 문#include <stdio.h>

int main(void){int loop = 1;do{

printf("%d Little Indian\n", loop++);} while(loop <= 10);

return 0;}

for 문

#include <stdio.h>

int main(void)

{

int loop;

for(loop=1 ; loop<=10 ; loop++)

{

printf("%d Little Indian\n", loop);

}

return 0;

}

for 문과 while 문 비교

for( 「초기화」 ; 「 조건」 ; 「 변경」 )

{

「 처리」 ;

}

①②

③④

⑤

for( i=1 ; i<=10 ; i++ )

{

printf("...");

}

i=1;

while( i<=10 )

{

printf("...");

i++;

}

for 문의 용도#include <stdio.h>

int main(void){

int F, C;for(C=0 ; C<=100 ; C++){

F = (9*C/5) + 32;printf(" 섭씨 %3d 도 : 화씨 %3d 도 \n", C, F);

}return 0;

}

while 문의 용도#include <stdio.h>

int main(void){

int num=1; // 숫자를 1 로 초기화int sum=0; // 합은 0 으로 초기화while(sum < 100) // 합이 100 미만이 경우 ...{

sum += num; // 숫자를 합산printf("Sum of 1~%d is %d\n", num, sum);num++; // 숫자를 증가

}return 0;

}

do ~ while 문의 용도#include <stdio.h>

int main(void){

int num, sum=0;printf(" 숫자를 입력하고 , 끝내려면 0 을 입력하세요 .\n");do{

scanf("%d", &num); // 숫자를 입력 받음sum += num; // 숫자 합산

} while(num != 0); // 입력한 숫자가 0 이 아니면printf(" 합계는 %d 입니다 .\n", sum);return 0;

}

if 문#include <stdio.h>int main(void){

int i, j;for(i=0 ; i<100 ; i++){

if(i%3 == 0 && i%4 == 0){

printf("%d\t", i);}

}printf("\n");return 0;

}

if ~ else 문#include <stdio.h>int main(void){

int charge=13000; // 기본요금으로 초기화int amount; // 통화시간printf(" 이번 달 통화 시간을 분 단위로 입력하세요 .\n");scanf("%d", &amount); // 사용자의 입력을 받음if(amount < 100) // 100 분 미만{

charge += amount*50; // 분당 50 원}else if(amount < 200) // 200 분 미만{

charge += 100*50; // 100 분까지는 분당 50 원charge += (amount-100)*30; // 그 이상은 분당 30 원

}else // 200 분 이상{

charge += 100*50; // 100 분까지는 분당 50 원charge += 100*30; // 100 분에서 200 분까지는 분당 30 원charge += (amount-200)*20; // 그 이상은 분당 20 원

}printf(" 통화요금은 %d 원 입니다 .\n", charge);return 0;

}

switch ~ case 문#include <stdio.h>int main(void){

int month;printf(" 몇 월에 태어나셨습니까 ? ");scanf("%d", &month);printf(" 당신의 탄생석은 ");switch(month){case 1:

printf(" 석류석 ");break;

case 2:printf(" 자수정 ");break;

...default:

printf(" 짱돌 ");break;

}printf(" 입니다 .\n");return 0;

}

break 문

switch( 변수 )

case 값 1:

처리 1:

break

case 값 2:

처리 2:

break

case 값 3:

처리 3:

break

switch( 변수 )

case 값 1:

처리 1:

case 값 2:

처리 2:

break

case 값 3:

처리 3:

break

for 문의 변형 for(C=0 ; C<=100 ; C+=5)

{

}

for(C=100 ; C>=0 ; C--) {

}

for(C=100, index=1 ; C>=0 ; C-=5, index++) {

}

반복문의 중첩#include <stdio.h>int main(void){

int i, j;for(i=2 ; i<=9 ; i++){

for(j=1 ; j<=9 ; j++){

printf("%d x %d = %d\n", i, j, i*j);}printf("\n");

}return 0;

}

조건에 따른 루프의 탈출#include <stdio.h>int main(void){

char input;while(1){

input = getchar(); // 한 글자를 입력받음if(input == '.') // 마침표면 루프를 빠져나감

break;

if(input >= 'a' && input <= 'z')input += 'A'-'a'; // 소문자를 대문자로 변환

putchar(input); // 한 글자 출력}printf("\n");return 0;

}

조건에 따른 루프의 생략#include <stdio.h>int main(void){

char input;while(1){

input = getchar(); // 한 글자를 입력 받음if(input == '.') // 마침표면 루프를 빠져나감

break;if(input >= '0' && input <= '9')// 숫자가 입력되면 ...

continue; // 루프의 뒷부분 생략

if(input >= 'a' && input <= 'z')input += 'A'-'a'; // 소문자를 대문자로 변환

putchar(input); // 한 글자 출력}printf("\n");return 0;

}

선행처리기 #define PI 3.141592

#if 조건문장 1

#else문장 2

#endif

#ifdef 매크로문장 1

#else문장 2

#endif

실습과제 미국 인디언들은 1627 년에 뉴욕 맨하튼 섬을 네덜란드 이주자들에게

단돈 24 달러에 팔았다고 합니다 . 지금 생각하면 헐값에 판 것 같지만 , 이 돈을 지금까지 은행에 넣어두고 8% 의 이자를 복리로 받았다면 지금쯤 엄청난 금액이 되어 있을 거라고 합니다 . 2010 년을 기준으로 이 돈의 가치가 얼마나 되는지 계산하는 프로그램을 작성하세요 .


int main(void){

double amount = 24;int year;for(year=1627 ; year<=2010 ; year++){

amount *= 1.08;}printf("2010 년 현재 잔액은 %.2f 달러 입니다 .\n", amount);return 0;

}

실습과제 키와 몸무게를 입력 받아 비만지수를 계산하고 , 비만도에 따른

구분을 출력하는 프로그램을 작성하세요 . 비만지수는 다음과 같이 계산되고 이에 따라 출력할 문장은 표와 같습니다 .

비만지수 (BMI) =

몸무게 (Kg)

키 (m) 의제곱

비만지수 출력할문장30.0 이상 고도비만25.0 ~ 29.9

비만

23.0 ~ 24.9

과체중

18.5 ~ 22.9

표준체중

18.5 이하 체중미달

실습과제 해설#include <stdio.h>int main(void){

int height; // 키 (cm 단위 )int weight; // 몸무게double dheight; // 키 (m 단위 )double bmi; // 비만지수printf(" 키를 입력하세요 (cm): ");scanf("%d", &height); // 키 입력printf(" 몸무게를 입력하세요 (Kg): ");scanf("%d", &weight); // 몸무게 입력dheight = height/100.0; // 키를 cm 단위에서 m 단위로 변환bmi = weight / (dheight * dheight); // 비만지수 계산printf(" 당신의 비만지수는 %.2f 으로 , ", bmi);

if(bmi >= 30) printf(" 고도비만입니다 .\n");else if(bmi >= 25) printf("비만입니다 .\n");else if(bmi >= 23) printf("과체중입니다 .\n");else if(bmi >= 18.5)printf("표준체중입니다 .\n");else printf(" 체중미달입니다 .\n");return 0;

}

Chapter 41 차원 배열과 포인터

배열이란int main(void){int array[10];array[0] = 0;array[1] = 10;array[2] = 20;...array[8] = 80;array[9] = 90;return 0;

}

배열의 초기화 int array[5] = {1, 2, 3, 4, 5};

int array[] = {1, 2, 3, 4, 5};

int array[5] = {1, 2};

int array[5] = {0};

배열의 활용 #include <stdio.h>

int main(void){

int students, s, sum=0;int score[] = {85, 90, 95, 70, 82, 60, 92, 88};// 학생들의 점수

students = sizeof(score)/sizeof(int); // 학생 수 계산for(s=0 ; s<students ; s++) // 학생 수만큼 루프{

sum += score[s]; // 점수의 총합을 계산}printf(" 총점 : %d\n", sum);printf(" 평균 : %0.2f\n", (double)sum/students);

return 0;}

배열과 문자열

A

p

p

l

e

null

65

112

112

108

101

0

배열과 문자열 #include <stdio.h>

int main(void){

int row, col;char str[11] = "I LOVE YOU"; // 문자열로 초기화

for(row=1 ; row<10 ; row++) // 10 까지 루프{

for(col=0 ; col<=row ; col++) // row 만큼 루프{

printf("%c", str[col]); // col 번째 원소 출력

}printf("\n");

}return 0;

}

포인터의 필요성

int size = 10;

int array[size]; // 컴파일 에러

포인터 변수의 선언 int *ptr;

int *ptr1, *ptr2;

char *ptr3;

포인터 변수의 크기#include <stdio.h>int main(void){

printf("char 의 크기 : %d\n", sizeof(char));printf("short 의 크기 : %d\n", sizeof(short));printf("long 의 크기 : %d\n", sizeof(long));printf("int 의 크기 : %d\n", sizeof(int));printf("float 의 크기 : %d\n", sizeof(float));printf("double 의 크기 : %d\n", sizeof(double));printf("\n");

printf("char 형 포인터의 크기 : %d\n", sizeof(char*));printf("short 형 포인터의 크기 : %d\n", sizeof(short*));printf("long 형 포인터의 크기 : %d\n", sizeof(long*));printf("int 형 포인터의 크기 : %d\n", sizeof(int*));printf("float 형 포인터의 크기 : %d\n", sizeof(float*));printf("double 형 포인터의 크기 : %d\n", sizeof(double*));return 0;

}

포인터 변수의 사용

int *ptr = 메모리 주소 ;

ptr[0] = 0;

ptr[1] = 10;

...

ptr[9] = 90;

ptrptr[0]ptr[1]ptr[2]ptr[3]ptr[4]ptr[5]ptr[6]ptr[7]ptr[8]ptr[9]

포인터 변수의 초기화 int *ptr = NULL;

메모리 할당과 해제 int *ptr = (int *)malloc(sizeof(int) * 10);

ptr = (int *)calloc(10, sizeof(int));

ptr = (int *)realloc(ptr, 20*sizeof(int));

free(ptr);

#include <malloc.h>

포인터와 배열의 비교 #include <stdio.h>#include <string.h>#include <malloc.h>#define MAX_INPUT 256

int main(void){

char input[MAX_INPUT]={0}; // 입력을 받기 위한 배열char *output=NULL; // 출력을 저장하기 위한 포인터int length, ch;fgets(input, MAX_INPUT-1, stdin); // 사용자로부터 문자열을 입력 받음length = strlen(input)+1; // NULL 을 포함한 문자열의 길이만큼output = (char *)malloc(length); // 메모리를 할당 받음for(ch=0 ; ch<length ; ch++){

if(input[ch] >= 'a' && input[ch] <= 'z')output[ch] = input[ch] + 'A'-'a'; // 소문자면 대문자로 변환

elseoutput[ch] = input[ch];

}printf("Input : %s", input); // 입력 값 표시printf("Output: %s", output); // 출력 값 표시free(output); // 메모리 반납return 0;

}

포인터의 활용 #include <stdio.h>#include <malloc.h>int main(void){

int students, s, sum=0;int *score=NULL; // 점수를 저장할 메모리 공간의 포인터printf(" 성적 처리할 학생 수를 입력하세요 : ");scanf("%d", &students); // 학생 수 입력score=(int *)malloc(sizeof(int)*students); // 메모리 할당printf(" 학생의 성적을 입력하세요 .\n");for(s=0 ; s<students ; s++){

printf("%d 번 : ", s+1);scanf("%d", &score[s]); // 점수 입력

}printf("----------------------\n");for(s=0 ; s<students ; s++){

sum += score[s]; // 총점 계산printf("%d 번 : %3d\n", s+1, score[s]); // 점수 출력

}printf("----------------------\n");printf(" 총점 : %3d 점 \n", sum); // 총점 출력printf(" 평균 : %3.2f 점 \n", (double)sum/students); // 평균 출력free(score); // 메모리 반납return 0;

}

& 연산자 int a, b=1, c=2;a = b & c;

int var;int *ptr;ptr = &var;

& 연산자#include <stdio.h>

int main(void){int var = 100;int *ptr = NULL; ptr = &var;printf(" 변수 var 의 위치 : %p\n", ptr);return 0;

}

* 연산자 int result, var1=3, var2=5;result = var1 * var2;

int *ptr;

short var1=1, var2=2;short *ptr = NULL;ptr = &var1;var2 = *ptr;

var1=110001001100210031004100510061007100810091010

ptr=1000

var2=1

포인터의 이동 int val = 5;int *ptr = NULL;ptr = &val;ptr = ptr+1;

ptr += 1; ptr++;

포인터의 이동#include <stdio.h>

int main(void)

{

char *ptrChar = NULL;

short *ptrShort = NULL;

int *ptrInt = NULL;

printf("char 형 포인터의 증가량 : %d\n", ++ptrChar);printf("short 형 포인터의 증가량 : %d\n", ++ptrShort);

printf("int 형 포인터의 증가량 : %d\n", ++ptrInt);return 0;

}

[] 연산자

p[0]1000100110021003100410051006100710081009101010111012101310141015

p[1]

p[2]

p[3]

p[4]

p=1000

*ptr1000100110021003100410051006100710081009101010111012101310141015

*(ptr+1)

*(ptr+2)

*(ptr+3)

*(ptr+4)

ptr=1000

배열과 포인터 #include <stdio.h>int main(void){

short array[3]; // 배열 선언short *ptr = array; // 포인터가 배열을 가리키게 함ptr[0] = 0; // 포인터를 이용하여 배열에 값을 대입ptr[1] = 10;ptr[2] = 20; // 배열에 저장된 값을 출력printf(" 배열에 의한 데이터 참조 :\t");printf("%d, %d, %d\n", array[0], array[1], array[2]);

// 포인터가 가리키는 데이터의 값을 출력printf(" 포인터에 의한 데이터 참조 :\t");printf("%d, %d, %d\n\n", ptr[0], ptr[1], ptr[2]);

// 배열과 포인터의 주소를 각각 출력printf(" 배열의 주소 :\t %p\n", array);printf(" 포인터가 가리키는 주소 :\t %p\n", ptr);return 0;

}

포인터 연산 정리 변수에 & 연산자

포인터 포인터에 * 연산자

포인터가 가리키는 데이터 포인터에 [] 연산자

포인터가 가리키는 위치부터 연속된 데이터 포인터의 덧셈 , 뺄셈

포인터를 다음 데이터 위치로 이동

포인터에 익숙해지기 short array[3];

short *ptr = array;ptr[0] = 0;ptr[1] = 10;ptr[2] = 20;

short array[3];short *ptr = array;*ptr = 0;*(ptr+1) = 10;*(ptr+2) = 20;

short array[3];short *ptr = array;*ptr++ = 0;*ptr++ = 10;*ptr = 20;

short array[3];short *ptr = array;*ptr = 0;*(++ptr) = 10;*(++ptr) = 20;

short array[3]; short *ptr = &array[0];ptr[0] = 0;ptr[1] = 10;ptr[2] = 20;

변수와 상수 int num = 5;

char array[5] = "Golf";

문자열 상수와 배열 #include <stdio.h>

int main(void)

{

char array[] = "Golf";

array[3] = 'd';

printf("%s\n", array);

return 0;

}

문자열 상수와 포인터 #include <stdio.h>

int main(void)

{

char *ptr = "Golf";

ptr[3] = 'd'; // 에러printf("%s\n", ptr); // OK

return 0;

}

널 문자열의 포인터와 널 포인터 char *ptr1 = "";

char *ptr2 = NULL;

실습과제 영어 단어를 입력 받아 A 에 1 점 , B 에 2 점 , C 에 3 점 이런 식으로

점수를 계산하는 프로그램을 작성하세요 .

실습과제 해설#include <stdio.h>#include <string.h>#define MAX_INPUT 256

int main(void){

char input[MAX_INPUT]={0};char *ptr = NULL;int score = 0;fgets(input, MAX_INPUT, stdin); // 사용자로부터 문자열을 입력 받음input[strlen(input)-1] = '\0'; // 문자열 끝의 '\n' 제거ptr = input; // 문자열의 첫 글자를 가리키게 함while(*ptr != '\0') // 단어가 끝나 '\0' 이 나올 때까지 ...{

if(*ptr >= 'A' && *ptr <= 'Z')score += *ptr - 'A' + 1; // A 에 1 점 , B 에 2 점 ...

else if(*ptr >= 'a' && *ptr <= 'z')score += *ptr - 'a' + 1; // a 에 1 점 , b 에 2 점 ...

ptr++; // 포인터 증가}printf("%s is %d %%\n", input, score);return 0;

}

실습과제

1 과 자기 자신 외의 약수를 가지지 않는 자연수를 소수 (Prime number) 라고 합니다 . 소수를 찾을 때는 에라토스테네스 (Eratosthenes)의 체라는 것을 사용합니다 . 1 보다 큰 자연수의 배수는 모두 소수가 아니므로 , 먼저 2의 배수를 모두 걸러내고 그 다음 3의 배수를 걸러내고 그 다음 5의 배수를 걸러내는 식으로 반복하는 것이지요 . 이렇게 하다 보면 결국 소수만 남게 됩니다 . 이 방법을 이용하여 사용자가 입력한 임의의 숫자보다 작은 수 중 소수를 찾아 출력하는 프로그램을 작성하세요 .

실습과제 해설#include <stdio.h>#include <malloc.h>int main(void){

int max; // 소수를 찾는 범위int mul; // 배수를 걸러내기 위한 숫자int i, j; // 루프의 인덱스char *isprime; // 소수이면 1, 소수가 아니면 0 을 저장하기 위한 포인터printf(" 소수를 찾을 최대 수를 입력하세요 : ");scanf("%d", &max);isprime = (char *)malloc(max); // 메모리 할당

for(i=2 ; i<max ; i++)isprime[i] = 1; // 배열의 모든 원소를 1 로 초기화

for(i=2 ; i<max ; i++)for(j=2, mul=i*j ; mul<max ; mul=++j*i)

isprime[mul] = 0; // i 의 배수를 걸러냄for(i=2 ; i<max ; i++)

if(isprime[i]) // 걸러지지 않은 값들을 출력printf("%d\t", i);

printf("\n");free(isprime); // 메모리 반납return 0;

}

Chapter 52 차원 배열과 포인터

2 차원 배열 ( 배열의 배열 )

int array[5][10];

10

5

2 차원 배열의 초기화 int array[2][3] = {{1, 2, 3}, {4, 5, 6}};

int array[2][3] = {1, 2, 3, 4, 5, 6};

int array[2][3] = {{1}, {4, 5}};

int array[][3] = {1, 2, 3, 4, 5, 6};

int array[2][] = {1, 2, 3, 4, 5, 6}; // 에러

2 차원 배열의 활용 #include <stdio.h>#define LESSONS 3int main(void){

int students; // 학생수int sum=0; // 합계int l, s; // for 루프를 위한 임시변수int score[][LESSONS] = {

{85, 90, 95}, // 1 번째 학생의 점수{70, 82, 60}, // 2 번째 학생의 점수...{78, 84, 92}}; // 8 번째 학생의 점수

students = sizeof(score)/sizeof(score[0]); // 학생 수 계산for(l=0 ; l<LESSONS ; l++) // 과목 수만큼 루프{

sum = 0;for(s=0 ; s<students ; s++) // 학생 수만큼 루프{

sum += score[s][l]; // 과목별 총합 계산}printf("[%d] Total: %d, ", l, sum);printf("Average: %0.2f\n", (double)sum/students);

}return 0;

}

가변 크기 2 차원 데이터

가로축

고정개수 가변개수

세로축 고정개수 2 차원배열 ( 배열의배

열 ) 포인터의배열

가변개수 배열의포인터 2 차원포인터 ( 포인터의포인터 )

포인터의 배열 char *ptrArray[5];

가변

고정

배열의 포인터 char (*arrayPtr)[10];

…

고정

가변

2 차원 포인터 ( 포인터의 포인터 )

char **ptrPtr;

…

가변

가변

char

char *

char **

2 차원 배열과 포인터의 배열 char lesson[3][8] = {"Korean", "English", "Math"};

char *lesson[3] = {"Korean", "English", "Math"};

M a t h \0

E n g l i s h \0

K o r e a n \0

M a t h \0

E n g l i s h \0

K o r e a n \0

포인터의 배열 활용#include <stdio.h>#define LESSONS 3int main(void){

int students; // 학생수int sum=0; // 합계int l, s; // for 루프를 위한 임시변수int score[][LESSONS] = {

{85, 90, 95}, // 1 번째 학생의 점수{70, 82, 60}, // 2 번째 학생의 점수...{78, 84, 92}}; // 8 번째 학생의 점수

char *lesson[] = {"Korean", "English", "Math"};

students = sizeof(score)/sizeof(score[0]); // 학생 수 계산for(l=0 ; l<LESSONS ; l++) // 과목에 대해 루프{


sum += score[s][l]; // 과목별 총합 계산}printf("[%7s] Total: %d, ", lesson[l], sum);printf("Average: %0.2f\n", (double)sum/students);

}return 0;

}

배열의 포인터 활용#define LESSONS 3int main(void){

int students, sum=0, l, s;char *lesson[] = {"Korean", "English", "Math"};int (*score)[LESSONS] = NULL;printf("학생 수를 입력하세요 : ");scanf("%d", &students);score = (int (*)[LESSONS])malloc(sizeof(int [LESSONS])*students);for(s=0 ; s<students ; s++) // 학생 수만큼 루프{

printf("%d번째 학생의 점수 : ", s+1);for(l=0 ; l<LESSONS ; l++) // 과목 수만큼 루프{

scanf("%d", &score[s][l]); // 점수 입력 받음}

}for(l=0 ; l<LESSONS ; l++) // 과목 수만큼 루프{


sum += score[s][l]; // 과목별 총합 계산}printf("[%7s] Total: %d, ", lesson[l], sum);printf("Average: %0.2f\n", (double)sum/students);

}free(score); // 메모리 해제return 0;

}

2 차원 포인터 활용int main(void){

int students, sum=0, l, s;int *lessons = NULL;int **score = NULL;printf(" 학생수를 입력하세요 : ");scanf("%d", &students);score = (int **)malloc(sizeof(int *)*students); // 세로축에 해당하는 메모리 할당lessons = (int *)malloc(sizeof(int)*students);for(s=0 ; s<students ; s++) // 학생 수만큼 루프{

printf("%d 번째 학생의 수강과목 수 : ", s+1);scanf("%d", &lessons[s]); // 학생별 수강과목 수 입력score[s] = (int *)malloc(sizeof(int)*lessons[s]); // 가로축에 해당하는 메모리 할당printf("%d 번째 학생의 점수 (%d개 ): ", s+1, lessons[s]);for(l=0 ; l<lessons[s] ; l++) // 과목 수만큼 루프

scanf("%d", &score[s][l]); // 점수 입력}for(s=0 ; s<students ; s++) // 학생 수만큼 루프{

sum = 0;for(l=0 ; l<lessons[s] ; l++)

sum += score[s][l]; // 학생별 평균 계산printf("%d 번째 학생 : %0.2f\n", s+1, (double)sum/lessons[s]);

}for(s=0 ; s<students; s++) // 학생 수만큼 루프

free(score[s]); // 가로축에 해당하는 메모리 반납free(score); // 세로축에 해당하는 메모리 반납free(lessons);return 0;

}

실습과제사용자로부터 행과 열의 개수 및 그 크기만큼의 행렬 데이터를 입력 받고 , 가로 방향과 세로 방향으로 각각 합계를 계산하여 다음과 같이 출력하는 프로그램을 작성하세요 .

행과 열의 개수를 각각 입력하세요 : 5 71 번째 행의 원소 7 개를 입력하세요 : 6 7 8 9 6 3 42 번째 행의 원소 7 개를 입력하세요 : 1 2 5 6 3 7 83 번째 행의 원소 7 개를 입력하세요 : 3 5 1 7 4 5 24 번째 행의 원소 7 개를 입력하세요 : 5 6 8 4 3 2 15 번째 행의 원소 7 개를 입력하세요 : 1 2 5 6 5 3 66 7 8 9 6 3 4 | 431 2 5 6 3 7 8 | 323 5 1 7 4 5 2 | 275 6 8 4 3 2 1 | 291 2 5 6 5 3 6 | 28-----------------------------------16 22 27 32 21 20 21

실습과제 해설 1/3

intint *int **

①

②

③

실습과제 해설 2/3#include <stdio.h>#include <malloc.h>int main(void){

int row, col, r, c, sum;int **data; // 2차원 포인터printf(" 행과 열의 개수를 각각 입력하세요 : ");scanf("%d %d", &row, &col); // 행과 열의 개수 입력data = (int **)malloc(row*sizeof(int*)); // 포인터를 위한 메모리 할당data[0] = malloc(row*col*sizeof(int)); // 데이터를 위한 메모리 할당

for(r=1 ; r<row ; r++){

data[r] = data[r-1] + col; // 포인터 값 지정}for(r=0 ; r<row ; r++){

printf("%d 번째 행의 원소 %d개를 입력하세요 : ", r+1, col);for(c=0 ; c<col ; c++){

scanf("%d", &data[r][c]); // 데이터 입력}

}...


...printf("\n");for(c=0 ; c<col ; c++){

sum = 0;for(r=0 ; r<row ; r++){

sum += data[r][c]; // 세로 방향 합계 계산}printf("%d\t", sum); // 세로 방향 합계 출력

}printf("\n");free(data[0]); // 데이터를 위한 메모리 반납free(data); // 포인터를 위한 메모리 반납return 0;

}

Chapter 6구조체

구조체 struct Point

{int x; // x 좌표int y; // y 좌표

};

struct Customer{

char name[10]; // 이름char phone[20]; // 전화번호char address[50]; // 주소int age; // 나이int sex; // 성별float height; // 키float weight; // 몸무게

};

구조체 변수의 선언 #include <stdio.h>struct Point{

int x; // x좌표int y; // y좌표

};

int main(void){

struct Point pt;

printf("Point 의 크기 : %d\n", sizeof(pt));return 0;

}

구조체 변수의 초기화 struct Point{


};

int main(void){

struct Point pt1 = {10, 20}, pt2 = {50, 60};...return 0;

}

구조체의 사용 #include <stdio.h>struct Point{


};

int main(void){

struct Point pt1 = {10, 20}, pt2 = {50, 60};

printf(" 첫째 점의 좌표 : (%d, %d)\n", pt1.x, pt1.y);printf(" 둘째 점의 좌표 : (%d, %d)\n", pt2.x, pt2.y);return 0;

}

구조체의 배열 #include <stdio.h>struct Point{


};

int main(void){

int i;struct Point pt[3] = {{10, 20}, {30, 40}, {50, 60}};for(i=0 ; i<3 ; i++){

printf("%d 번째 점의 좌표 : (%d, %d)\n", i+1, pt[i].x, pt[i].y);}return 0;

}

구조체의 포인터 #include <stdio.h>struct Point{


};

int main(void){

int i;struct Point pt[3] = {{10, 20}, {30, 40}, {50, 60}};struct Point *ptr = pt;for(i=0 ; i<3 ; i++){

printf("%d 번째 구조체 값 : (%d, %d)\n", i+1, ptr[i].x, ptr[i].y);}

printf(" 첫번째 구조체 값 : (%d, %d)\n\n", (*ptr).x, (*ptr).y);printf(" 첫번째 구조체 값 : (%d, %d)\n\n", ptr->x, ptr->y);

return 0;}

구조체 멤버변수 #include <stdio.h>struct Point{


};

struct Circle{

struct Point center; // 중심의 좌표double radius; // 반지름

};

int main(void){

struct Circle c1 = {{10, 10}, 5.0};printf(" 원의 중심 좌표 : (%d, %d)\n", c1.center.x, c1.center.y);printf(" 원의 반지름 : %0.2f\n", c1.radius);return 0;

}

구조체의 포인터 멤버변수 struct NoGood{

NoGood member; // 에러};

struct List{

int member;struct List *next;

};

구조체 활용 1/3

#include <stdio.h>#include <malloc.h>#include <string.h>#define MAX_NAME 50

struct Item{

char name[MAX_NAME]; // 품명int price; // 단가int num; // 수량

};


int main(void){

int i;int count, sum=0, total; // 항목개수 , 합계 , 총액struct Item *item = NULL; // 항목printf("항목의 개수를 입력하세요 : ");scanf("%d", &count); // 항목개수 입력item = malloc(count * sizeof(item)); // 메모리 할당

for(i=0 ; i<count ; i++){

printf("\n품명 : ");fgets(item[i].name, MAX_NAME-1, stdin); // 품명 입력item[i].name[strlen(item[i].name)-1] = '\0'; // '\n' 제거printf(" 단가 : ");scanf("%d", &item[i].price); // 단가 입력printf(" 수량 : ");scanf("%d", &item[i].num); // 수량 입력

}...


...printf("------------------------------\n");printf("품명 \t 단가 \t 수량 \n");printf("------------------------------\n");for(i=0 ; i<count ; i++){

printf("%s\t", item[i].name); // 품명 출력printf("%d\t", item[i].price); // 단가 출력printf("%d\n", item[i].num); // 수량 출력sum += (item[i].price * item[i].num); // 합계 계산

}free(item); // 메모리 반납total = (int)(sum * 1.1); // 부가세 포함금액printf("------------------------------\n");printf(" 합계 : %d\n", sum);printf(" 총액 : %d ( 부가세 10%% 포함 )\n", total);return 0;

}

구조체 멤버변수의 정렬 1/2

#include <stdio.h>struct s1{

char c;short s;int i;

};

struct s2{

char c;int i;short s;

};

int main(void){

printf("s1 의 크기 : %d\n", sizeof(struct s1));printf("s2 의 크기 : %d\n", sizeof(struct s2));return 0;

}

구조체 멤버변수의 정렬 2/2

char c

short s

int i

정렬단위

정렬단위

char c

short s

int i

정렬단위

정렬단위

정렬단위

struct s1 struct s2

공용체#include <stdio.h>union Color{

unsigned char rgb[4];unsigned int code;

};

int main(void){

int input;union Color c = {0};printf("Red: "); // Red 성분 입력scanf("%d", &input);c.rgb[2] = (unsigned char)input;printf("Green: "); // Green 성분 입력scanf("%d", &input);c.rgb[1] = (unsigned char)input;printf("Blue: "); // Blue 성분 입력scanf("%d", &input);c.rgb[0] = (unsigned char)input;

printf("Color code: 0x%X\n", c.code); // Code 출력return 0;

}

공용체 멤버변수의 정렬

c[0]

c[1]

c[2]

c[3]

i

s[0]

s[1]

union Data{

char c[4];short s[2];int i;

};

열거형 #include <stdio.h>enum Season {SPRING, SUMMER, FALL, WINTER};int main(void){

enum Season s = SPRING;

switch(s){case SPRING:

printf("봄 ");break;

case SUMMER: printf(" 여름 ");break;

case FALL:printf(" 가을 ");break;

case WINTER:printf("겨울 ");break;

}return 0;

}

데이터 타입 정의 typedef unsigned int uint;typedef struct{

int x;int y;

} Point;

int main(void){

Point pt1, pt2;uint val;...return 0;

}

실습과제 성적처리 할 학생의 수를 사용자로부터 입력 받고 , 사용자가 입력한

수만큼의 학생에 대해 이름과 국어 , 영어 , 수학 성적을 각각 입력 받아 총점과 평균을 계산하여 출력하는 프로그램을 작성하세요 .


#include <stdio.h>#include <malloc.h>#include <string.h>

#define MAX_NAME 20#define SUBJECTS 3

struct Grade{

char name[MAX_NAME]; // 이름int score[SUBJECTS]; // 점수int total; // 총점double average; // 평균

};

int main(void){

int students, i, j;struct Grade *grade;char *subject[SUBJECTS] = {"국어 ", "영어 ", " 수학 "};/////////////////////////////////////////////////////////// 학생 수 입력 및 메모리 할당printf(" 성적처리 할 학생 수를 입력하세요 : ");scanf("%d", &students);grade = (struct Grade *)malloc(students*sizeof(struct Grade));


/////////////////////////////////////////////////////////// 성적 입력for(i=0 ; i<students ; i++){

printf("**************** %d번째 학생 ****************\n", i+1);printf(" 이름 : ");scanf("%s", grade[i].name);for(j=0 ; j<SUBJECTS ; j++){

printf("%s: ", subject[j]);scanf("%d", &grade[i].score[j]);

}}/////////////////////////////////////////////////////////// 성적 계산for(i=0 ; i<students ; i++){

grade[i].total = 0;for(j=0 ; j<SUBJECTS ; j++){

grade[i].total += grade[i].score[j];}grade[i].average = (double)grade[i].total/SUBJECTS;

}


/////////////////////////////////////////////////////////// 성적 출력printf("--------------------------------------------------\n");printf(" 이름 \t| 국어 \t| 영어 \t| 수학 \t| 총점 \t| 평균 \n");printf("--------------------------------------------------\n");for(i=0 ; i<students ; i++){

printf("%s\t| ", grade[i].name);for(j=0 ; j<SUBJECTS ; j++){

printf("%d\t| ", grade[i].score[j]);}printf("%d\t| ", grade[i].total);printf("%0.2f\n", grade[i].average);

}printf("--------------------------------------------------\n");free(grade); // 메모리 반납return 0;

}

Chapter 7함수

함수

리턴형 함수이름 ( 입력 )

{

함수의 몸체}

함수의 정의와 호출

int main(void)

{

...

result = average( val1, val2 );

...

}

double average( double a, double b )

{

double c = (a + b)/2.0;

return c;

}

인자

매개변수

함수 선언int average(double a, double b); // 함수 선언

int main(void){

int result, val1=1, val2=2;result = average(val1, val2); // 함수 호출return 0;

}

int average(int a, int b) // 함수 정의{

int c = (a + b)/2;return c;

}

구조적 프로그래밍

int main(void)

{

func1( );

func2( );

func3( );

}

int func1( );{

func4( );}

int func2( );{

...}

int func3( );{

...}

int func4( );{

...}

①

② ③

④

⑤

구조적 프로그래밍의 예 1/4

#include <stdio.h>

#define NUM 5

void input(int data[]);void sort(int data[]);void output(int data[]);

int main(void)

{

int data[NUM];// 데이터를 저장할 배열input(data); // 입력 기능sort(data); // 정렬 기능output(data); // 출력 기능return 0;

}


// 입력 함수 정의void input(int data[])

{

int i;

printf(" 숫자 %d개를 입력하세요 .\n", NUM);

for(i=0 ; i<NUM ; i++)

{

printf("%d 번째 숫자 : ", i+1);

scanf("%d", &data[i]);

}

}


// 정렬 함수 정의void sort(int data[]){

int i, j, temp;for(i=0 ; i<NUM ; i++)for(j=i+1 ; j<NUM ; j++){

if(data[i] > data[j]) {

temp = data[i];data[i] = data[j];data[j] = temp;

}}

}

i=0 1 2 3 4

j=0

1

2

3

4


// 출력 함수 정의void output(int data[])

{

int i;

printf("\n 입력된 숫자를 크기 순으로 나열합니다 .\n");

for(i=0 ; i< NUM ; i++)

{

printf("%d 번째 숫자 : %d\n", i+1, data[i]);

}

}

지역변수

int add(int val1, int val2)

{

int result;

result = val1 + val2;

return result;

}

전역변수

int global = 0;

int main(void)

{

...

}

정적변수#include <stdio.h>int Count(void);

int main(void){

int i, count;for(i=0 ; i<5 ; i++){

count = Count();printf("Count 함수가 %d 번 호출되었습니다 .\n", count);

}return 0;

}

int Count(void){

static int count = 0;count++;return count;

}

변수의 종류에 따른 사용 범위와 수명

선언방법 사용범위 메모리에존재하는수명

지역변수 함수안에서선언 함수내 함수가실행되는동안

전역변수 함수밖에서선언 프로그램전체 프로그램이실행되는동안

정적변수 함수안 / 밖에서

static 키워드를붙여선언

함수안에서선언 : 함수내 함수밖에서선언 : 파일내 프로그램이실행되는동안

스택과 지역변수int func1(void);int func2(void);

int main(void){

int ma, mb;func1();func2();return 0;

}

int func1(void){

int f1a, f1b, f1c;...

}

int func2(void){

int f2a, f2b;...

}

ma

mb

ma

mb

f1a

f1b

f1c

ma

mb

f2a

f2b

ma

mb

(a) (b) (c) (d) (e)

스택

스택포인터

스택 오버플로우 1/2

int main(void){

int array[10000000];...return 0;

}

int main(void){

int *array = malloc(10000000*sizeof(int));...free(array);return 0;

}

스택 오버플로우 2/2

int f(void){int a;g();

}

int g(void){int b;f();

}

인자 전달 방식#include <stdio.h>void output(int taken);

int main(void){

int given=10;printf("main 이 넘겨준 값 : %d\n", given);output(given);return 0;

}

void output(int taken){

printf("output 이 받은 값 : %d\n", taken);}

Call By Value

#include <stdio.h>void output(int taken);

int main(void){

int given=10;printf("main 이 넘겨준 값 : %d (%p)\n", given, &given);output(given);return 0;

}

void output(int taken){

printf("output 이 받은 값 : %d (%p)\n", taken, &taken);}

인자의 값 변경#include <stdio.h>void swap(int a, int b);

int main(void){

int a=10, b=20;swap(a, b);printf("a=%d, b=%d\n", a, b);return 0;

}

void swap(int a, int b){

int temp;temp = a;a = b;b = temp;

}

#include <stdio.h>void swap(int *a, int *b);

int main(void){

int a=10, b=20;swap(&a, &b);printf("a=%d, b=%d\n", a, b);return 0;

}

void swap(int *a, int *b){

int temp;temp = *a;*a = *b;*b = temp;

}

구조체 인자 1/3

#include <stdio.h>

typedef struct // 구조체 선언{

char name[100]; // 품명int price; // 단가int count; // 수량

} Item;

void PrintItem(Item item);

int main(void){

Item item = {" 사과 ", 1000, 50}; // 구조체 초기화PrintItem(item); // 구조체를 인자로 넘겨줌return 0;

}

void PrintItem(Item item) // 구조체를 인자로 받는 함수{

printf("품명 : %s\n", item.name);printf(" 단가 : %d\n", item.price);printf(" 수량 : %d\n", item.count);

}


#include <stdio.h>



} Item;

void PrintItem(Item *item);

int main(void){

Item item = {" 사과 ", 1000, 50}; // 구조체 초기화PrintItem(&item); // 구조체의 포인터를 인자로 넘겨줌return 0;

}

void PrintItem(Item *item) // 구조체의 포인터를 인자로 받는 함수{

printf("품명 : %s\n", item->name);printf(" 단가 : %d\n", item->price);printf(" 수량 : %d\n", item->count);

}


#include <stdio.h>



} Item;

void PrintItem(const Item *item);

int main(void){

Item item = {" 사과 ", 1000, 50}; // 구조체 초기화PrintItem(&item); // 구조체의 포인터를 인자로 넘겨줌return 0;

}

void PrintItem(const Item *item) // 구조체의 포인터를 인자로 받는 함수{

printf("품명 : %s\n", item->name);printf(" 단가 : %d\n", item->price);printf(" 수량 : %d\n", item->count);

}

1 차원 배열 인자 1/3#include <stdio.h>int sum(int data[5]);

int main(void){

int total;int data[5] = {10, 30, 20, 50, 70};total = sum(data);printf(" 합계 : %d\n", total);return 0;

}

int sum(int data[5]){

int i, total = 0;for(i=0 ; i<5; i++){

total += data[i];}return total;

}

1 차원 배열 인자 2/3#include <stdio.h>int sum(int data[], int size);

int main(void){

int total;int data[5] = {10, 30, 20, 50, 70};total = sum(data, 5);printf(" 합계 : %d\n", total);return 0;

}

int sum(int data[], int size){

int i, total = 0;for(i=0 ; i<size ; i++){


}

1 차원 배열 인자 3/3#include <stdio.h>int sum(int *data, int size);

int main(void){

int total;int data[5] = {10, 30, 20, 50, 70};total = sum(data, 5);printf(" 합계 : %d\n", total);return 0;

}

int sum(int *data, int size){

int i, total = 0;for(i=0 ; i<size ; i++){


}

2 차원 배열 인자 1/2#include <stdio.h>int sum(int data[][3], int size);

int main(void){

int total;int data[2][3] = {{10, 30, 20}, {50, 70, 30}};total = sum(data, 2);printf(" 합계 : %d\n", total);return 0;

}

int sum(int data[][3], int size){

int i, j, total = 0;for(i=0 ; i<size ; i++)for(j=0 ; j<3 ; j++){

total += data[i][j];}return total;

}

2 차원 배열 인자 2/2#include <stdio.h>int sum(int (*data)[3], int size);

int main(void){

int total;int data[2][3] = {{10, 30, 20}, {50, 70, 30}};total = sum(data, 2);printf(" 합계 : %d\n", total);return 0;

}

int sum(int (*data)[3], int size){

int i, j, total = 0;for(i=0 ; i<size ; i++)for(j=0 ; j<3 ; j++){

total += data[i][j];}return total;

}

main 함수의 인자#include <stdio.h>

int main(int argc, char *argv[]){

int i;

printf("%d개의 명령행 인자가 입력됐습니다 .\n", argc);for(i=0 ; i<argc ; i++){

printf("%d: %s\n", i, argv[i]);}return 0;

}

성공 여부 판별int squre(int num){

int result;result = num*num;return result;

}

int squre(int num){

if(num > 46340 || num < -46340)return -1;

elsereturn num*num;

}

성공 여부와 계산 결과의 분리int Divide(int dividend, int divider){

int result;result = dividend/divider;return result;

}

int Divide(int dividend, int divider){

int result;if (divider==0)

return 0;result = dividend/divider;return result;

}

int Divide(int dividend, int divider, int *result){

if (divider==0)return 0;

*result = dividend/divider;return 1;

}

항상 성공하는 함수int FindMax(int a, int b)

{

if(a > b)

return a;

else

return b;

}

리턴형이 void 인 함수int total;

int count;

void initialize(void)

{

total = 0;

count = 0;

}

함수의 포인터 int add(int a, int b);int sub(int a, int b);

int add(int a, int b);int divide(int a, int b, int *result);

int (*ptrFunc)(int a, int b); int (*ptrFunc)(int, int); int *ptrFunc(int, int); int (*ptrFunc[10])(int, int);

함수의 포인터 활용#include <stdio.h>int add(int a, int b); // 함수 선언int sub(int a, int b); // 함수 선언

int main(void){

int result;int (*calc)(int, int); // 함수의 포인터 선언calc = add; // add 함수의 포인터 얻기result = calc(20, 10); // 함수의 포인터로 함수 호출printf("Calc result: %d\n", result);calc = sub; // sub 함수의 포인터 얻기result = calc(20, 10); // 함수의 포인터로 함수 호출printf("Calc result: %d\n", result);return 0;

}

int add(int a, int b) // 함수 정의{

return a+b;}

int sub(int a, int b) // 함수 정의{

return a-b;}

Callback 함수 1/2

#include <stdio.h>#include <stdlib.h>#define NUM 10

int ascending(const void *, const void *);int descending(const void *, const void *);void output(int data[], int size);

int main(void){

int data[NUM] = {10, 58, 63, 21, 17, 36, 93, 72, 20, 11};

qsort(data, NUM, sizeof(int), ascending);output(data, NUM);

qsort(data, NUM, sizeof(int), descending); output(data, NUM);return 0;

}

Callback 함수 2/2int ascending(const void *a, const void *b){

if(*(int *)a > *(int *)b) return 1;else if(*(int *)a < *(int *)b) return -1;else return 0;

}

int descending(const void *a, const void *b){

if(*(int *)a < *(int *)b) return 1;else if(*(int *)a > *(int *)b) return -1;else return 0;

}

void output(int data[], int size){

int i;for(i=0 ; i<size ; i++)

printf("%d ", data[i]);}

함수를 만드는 원칙 생산자와 소비자의 원칙 함수기능 정의의 원칙 함수이름 정의의 원칙 인자 정의의 원칙 리턴 값 정의의 원칙

함수기능 정의의 원칙 1/2

#include <stdio.h>void CircleArea(double radius);

int main(void){

CircleArea (3.0);return 0;

}

void CircleArea(double radius){

double area;area = radius * radius * 3.141592;printf("%0.2f\n", area);

}

함수기능 정의의 원칙 2/2

#include <stdio.h>double CircleArea(double radius);

int main(void){

double area;area = CircleArea(3.0);printf(" 반지름이 3 인 원의 면적은 %0.2f 입니다 .\n", area);return 0;

}

double CircleArea(double radius){

double area;area = radius * radius * 3.141592;return area;

}

함수이름 정의의 원칙 1/2

#include <stdio.h>int Find(int a, int b);

int main(void){

int val1=10, val2=20;int max;max = Find(val1, val2);printf(" 큰 값은 %d 입니다 .\n", max);return 0;

}

int Find(int a, int b){

if(a > b)return a;

elsereturn b;

}

함수이름 정의의 원칙 2/2

#include <stdio.h>int FindMax(int a, int b);

int main(void){

int val1=10, val2=20;int max;max = FindMax(val1, val2);printf(" 큰 값은 %d 입니다 .\n", max);return 0;

}

int FindMax(int a, int b){

if(a > b)return a;

elsereturn b;

}

인자 정의의 원칙void PrintLine(void){

printf("----------------------------------------\n");}

void PrintLine(char symbol){

int i;for(i=0; i<40 ; i++)

printf("%c", symbol);printf("\n");

}

void PrintLine(char symbol, int length){

int i;for(i=0; i<length ; i++)

printf("%c", symbol);printf("\n");

}

실습과제메뉴 방식으로 동작하는 단위환산 프로그램을 작성하세요 . 먼저 다음과 같이 메인 메뉴를 보여줍니다 .----------------------------------0. 길이 변환1. 무게 변환2. 부피 변환3. 넓이 변환4. 종료----------------------------------여기서 항목을 선택하면 그 다음 동작을 하기 위한 서브 메뉴를 보여줍니다 . 예를 들어 사용자가 0번을 선택하면 다음과 같은 서브 메뉴를 보여줍니다 .----------------------------------0. 마일 킬로미터1. 킬로미터 마일----------------------------------0번을 선택하면 마일 단위로 입력을 받아 킬로미터 단위로 변환하여 출력을 해 줍니다 . 변환에는 다음 변환식을 사용합니다 .1 마일 = 1.6093 킬로미터1 파운드 = 0.45359 킬로그램1갤론 = 3.7854 리터1 에이커 = 0.40468 헥타아르변환이 끝나면 다시 메인 메뉴를 출력합니다 .

실습과제 해설 1/6#define MAX_MAIN_MENU 4#define MAX_SUB_MENU 2

int main(void){

int mainmenu, submenu;while(1){

mainmenu = MainMenu();if(mainmenu >= 0 && mainmenu < MAX_MAIN_MENU){

submenu = SubMenu(mainmenu);if(submenu >= 0 || submenu < MAX_SUB_MENU)

Conversion(mainmenu, submenu);}else if(mainmenu == 4)

break; // 프로그램 종료}return 0;

}


int MainMenu(){

int menu;

printf("--------------------------\n");printf("0. 길이 변환 \n");printf("1. 무게 변환 \n");printf("2. 부피 변환 \n");printf("3. 넓이 변환 \n");printf("4. 종료 \n");printf("--------------------------\n");printf(" 입력 : ");scanf("%d", &menu);

return menu;}

실습과제 해설 3/6static char title[MAX_MAIN_MENU][MAX_SUB_MENU][9] = {

{" 마일 ", "킬로미터 "}, {" 파운드 ", "킬로그램 "},{"갤론 ", " 리터 "},{" 에이커 ", "헥타아르 "}

};

int SubMenu(int mainmenu){

int submenu;printf("--------------------------\n");printf("0. %s -> %s\n", title[mainmenu][0], title[mainmenu][1]);printf("1. %s -> %s\n", title[mainmenu][1], title[mainmenu][0]);printf("--------------------------\n");

printf(" 입력 : ");scanf("%d", &submenu);printf("--------------------------\n");

return submenu;}

실습과제 해설 4/6double mile2kilometer(double mile){

return mile*1.6093;}

double kilometer2mile(double kilometer){

return kilometer/1.6093;}

double pound2kilogram(double pound){

return pound*0.45359;}

double kilogram2pound(double kilogram){

return kilogram/0.45359;}

실습과제 해설 5/6double gallon2liter(double gallon){

return gallon*3.7854;}

double liter2gallon(double liter){

return liter/3.7854;}

double acre2ha(double acre){

return acre*0.40468;}

double ha2acre(double ha){

return ha/0.40468;}


void Conversion(int mainmenu, int submenu)

{

double input, output;

double (*convert[MAX_MAIN_MENU][MAX_SUB_MENU])(double) = {

{mile2kilometer, kilometer2mile},

{pound2kilogram, kilogram2pound},

{gallon2liter, liter2gallon},

{acre2ha, ha2acre}

};

printf("%s: ", title[mainmenu][submenu]);

scanf("%lf", &input);

output = convert[mainmenu][submenu](input);

printf("-> %s: %.2f\n", title[mainmenu][(submenu+1)%2], output);

}

Chapter 8표준함수

파일 열기 /닫기 함수 함수형태 기능

FILE *fopen(const char *filename, const char *mode) 지정된파일을지정된모드로열기int fclose(FILE *fp) 지정된파일을닫기

모드 의미r 지정한파일을읽기전용으로열기 . 지정한파일이없으면실패w 지정한파일을생성하고쓰기전용으로열기 . 지정한파일이이미있으면삭제한후새로생성a 지정한파일이있으면내용을그대로유지하고 , 맨끝에내용을추가할수있도록쓰기전용으로

열기 . 지정한파일이없으면새로생성r+ 지정한파일을수정하기위해읽기 / 쓰기용으로열기 . 지정한파일이없으면실패w+ 지정한파일을생성하고읽기 / 쓰기용으로열기 . 지정한파일이이미있으면삭제하고새로생성 .

a+ 지정한파일이있으면내용을그대로유지하고 , 맨끝에내용을추가할수있도록읽기 / 쓰기용으로열기 . 지정한파일이없으면새로생성

모드 의미t 텍스트모드로열기b 바이너리모드로열기

파일 열기의 예 – 텍스트 쓰기 모드#include <stdio.h>

int main(void){

FILE *fp;

if((fp = fopen("test.txt", "wt")) == NULL){

printf(" 파일 열기에 실패했습니다 .\n");return 1;

}

// 여기서 파일 읽기 , 쓰기를 합니다 .

fclose(fp);return 0;

}

파일 열기의 예 – 바이너리 읽기 모드#include <stdio.h>

int main(void){

FILE *fp;

if((fp = fopen("test.bin", "rb")) == NULL){

printf(" 파일 열기에 실패했습니다 .\n");return 1;

}

// 여기서 파일 읽기 , 쓰기를 합니다 .

fclose(fp);return 0;

}

텍스트 쓰기 /읽기 함수

함수형태 기능

int fprintf(FILE *fp, const char *format [, argument ]…) 포맷에맞춰문자열을파일에쓰기

char *fputs(const char *string, FILE *fp) 문자열을파일에쓰기

int fputc(int c, FILE *fp) 문자를파일에쓰기

함수형태 기능

int fscanf(FILE *fp, const char *format [, argument ]…) 포맷에맞춰문자열을파일에서읽기

char *fgets(char *string, int n, FILE *fp) 문자열을파일에서읽기

int fgetc(FILE *fp) 문자를파일에서읽기

텍스트 쓰기의 예#include <stdio.h>int main(void){

int students, s, sum=0;int score[] = {85, 90, 95, 70, 82, 60, 92, 88};double average;FILE *fp;students = sizeof(score)/sizeof(int);for(s=0 ; s<students ; s++)

sum += score[s];average = (double)sum/students;

if((fp = fopen("score.txt", "wt")) == NULL) // 파일 열기{

printf(" 파일을 열지 못했습니다 .\n");return 1;

}fputs(" 성적처리 결과 \n", fp); // 파일에 쓰기fprintf(fp, " 총점 : %d\n", sum); // 파일에 쓰기fprintf(fp, " 평균 : %0.2f\n", average); // 파일에 쓰기fclose(fp); // 파일 닫기return 0;

}

텍스트 읽기의 예#include <stdio.h>#define MAX_INPUT 128

int main(void){

FILE *fp;char text[MAX_INPUT];int total;double average;if((fp = fopen("score.txt", "rt")) == NULL) // 파일 열기{


}fgets(text, MAX_INPUT, fp); // 파일 읽기printf("%s", text);fscanf(fp, "%s %d", text, &total); // 파일 읽기printf("%s %d\n", text, total);fscanf(fp, "%s %lf", text, &average); // 파일 읽기printf("%s %0.2f\n", text, average);fclose(fp); // 파일 닫기return 0;

}

바이너리 쓰기 /읽기 함수

함수형태 기능

size_t fwrite(const void *ptr, size_t size, size_t n, FILE *fp) ptr 이 가리키는곳에 저장된 size 크기의 데이터 n 개를 파일에쓰기

size_t fread(void *ptr, size_t size, size_t n, FILE *fp) 파일에서 size 크기의 데이터 n 개를 읽어 ptr 이 가리키는곳에 저장

바이너리 쓰기의 예#include <stdio.h>int main(void){

int students, s, sum=0;int score[] = {85, 90, 95, 70, 82, 60, 92, 88};double average;FILE *fp;students = sizeof(score)/sizeof(int);for(s=0 ; s<students ; s++)

sum += score[s];average = (double)sum/students;if((fp = fopen("score.bin", "wb")) == NULL) // 파일 열기{


}fwrite(" 성적처리 결과 ", 14, 1, fp); // 파일에 쓰기fwrite(" 총점 : ", 7, 1, fp); // 파일에 쓰기fwrite(&sum, sizeof(int), 1, fp); // 파일에 쓰기fwrite(" 평균 : ", 7, 1, fp); // 파일에 쓰기fwrite(&average, sizeof(double), 1, fp); // 파일에 쓰기fclose(fp); // 파일 닫기return 0;

}

바이너리 읽기의 예#include <stdio.h>#define MAX_INPUT 128int main(void){

FILE *fp;char text[MAX_INPUT];int total;double average;if((fp = fopen("score.bin", "rb")) == NULL) // 파일 열기{


}fread(text, 14, 1, fp); // 파일에서 읽기printf("%s\n", text);fread(text, 7, 1, fp); // 파일에서 읽기fread(&total, sizeof(int), 1, fp); // 파일에서 읽기printf("%s %d\n", text, total);fread(text, 7, 1, fp); // 파일에서 읽기fread(&average, sizeof(double), 1, fp); // 파일에서 읽기printf("%s %0.2f\n", text, average);fclose(fp); // 파일 닫기return 0;

}

텍스트 파일과 바이너리 파일 1억

텍스트 : 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00

바이너리 : 0x05, 0xF5, 0xE1, 0x00

파일 포인터와 버퍼 함수형태 기능

int ftell(FILE *fp) 현재파일포인터를리턴int fseek(FILE *fp, long offset, int origin) 파일포인터의위치를지정된곳으로옮김 .

성공하면 0 을리턴

상수 의미

SEEK_SET 파일의처음을기준으로함

SEEK_CUR 현재파일포인터가가리키는곳을기준으로함

SEEK_END 파일의끝을기준으로함

함수형태 기능

int fflush(FILE *fp) 버퍼의내용을파일에쓰기 . 성공하면 0 을리턴

메모리 함수

함수형태 기능

void *memcpy(void *dest, const void *src, size_t count) src 를 count 만큼 dest 에 복사

void *memset(void *dest, int c, size_t count) dest 를 count 만큼 c 로채움

void *memchr(const void *buf, int c, size_t count) buf 의 count 범위에서 c 를 찾음

int memcmp(const void *buf1, const void *buf2, size_t count) buf1 과 buf2 를 count 범위에서비교

시간 표현법 time_t: 1970. 1. 1. 자정 기준 경과 시간을 ( 초 단위 )

struct tm{

int tm_sec; // 초 (0-59)int tm_min; // 분 (0-59)int tm_hour; // 시 (0-23)int tm_mday; // 일 (1-31)int tm_mon // 월 (0-11)int tm_year // 년 (1900 년 이후의 값 )int tm_wday // 요일 (0: 일 , 1: 월 , …, 6

토 )int tm_yday // 연중 일자 (0-365)int tm_isdst; // 일광시각절약제 사용여부

};

시각 함수

함수형태 기능

time_t time(time_t *timer) 시스템의현재시각을얻어옴

struct tm *gmtime(const time_t *timer) time_t 를 tm 구조체로 변환 ( 세계 표준시 기준 )

struct tm *localtime(const time_t *timer) time_t 를 tm 구조체로 변환 ( 지역시간 기준 )

clock_t clock(void) 프로그램이시작된후경과된 clock 수를얻어옴

현재시각을 출력하는 예#include <stdio.h>#include <time.h>

int main(void){

time_t now = time(NULL);struct tm *lt = localtime(&now);printf("오늘은 %d 년 %d 월 %d 일입니다 .\n",

lt->tm_year+1900, lt->tm_mon+1, lt->tm_mday);printf(" 현재시각은 %d 시 %d 분입니다 .\n",

lt->tm_hour+1, lt->tm_min+1);

return 0;}

시간 계산 함수

함수형태 기능

double difftime(time_t timer1, time_t timer0) 두시각의차이 , timer1-timer0 을계산함

time_t mktime(struct tm *timer) tm 구조체를 time_t 로 변환

시간 계산의 예 1/2

#include <stdio.h>#include <time.h>

int main(void){

time_t now = time(NULL);time_t worldcup;struct tm worldcupDay = {0,0,0,1,5,110,0,0,0}; double diff;worldcup = mktime(&worldcupDay);diff = difftime(worldcup, now);printf("2010 년 월드컵까지 앞으로 %d 일 남았습니다 .\n",

(int)diff/60/60/24);return 0;

}

시간 계산의 예 2/2

#include <stdio.h>#include <time.h>#include <memory.h>

int main( void ){

struct tm *today, theday;time_t now = time(NULL);today = localtime(&now);memcpy(&theday, today, sizeof(theday));theday.tm_mday += 20;mktime(&theday);

printf("오늘은 %d 년 %d 월 %d 일입니다 .\n",today->tm_year+1900, today->tm_mon+1, today->tm_mday);

printf("20 일 후에는 %d 년 %d 월 %d 일이 됩니다 .\n",theday.tm_year+1900, theday.tm_mon+1, theday.tm_mday);

return 0;}

시간 / 문자열 변환 함수

함수형태 기능

char *ctime(const time_t *timer) time_t 형식을 문자열로 변환

char asctime(const struct tm *time) tm 구조체형식을문자열로변환

size_t strftime(char *strDest, size_t maxsize, const char *format, const struct tm *time)

tm 구조체형식을문자열로변환하되 , 사용자가 지정한형식에맞춰변환

시간 출력 서식 문자범주 서식문자 의미년 %Y 4 자리로표현

%y 2 자리로표현월 %m 1 부터 12 까지의 숫자

%b 짧은월이름 (Jan, Feb, Mar 등 )

%B 긴월이름 (January, February, March 등 )

일 %d 월중 일자 . 1 부터 31 까지의 숫자%j 연중 일자 . 1 부터 366 까지의 숫자

시 %H 0 부터 23 까지의 숫자 (24 시간 형식 )%I 1 부터 12 까지의 숫자 (12 시간 형식 )%p AM/PM (오전 / 오후표시 )

분 %M 0 부터 59 까지 숫자초 %S 0 부터 59 까지 숫자주 %w 0 부터 6 까지 숫자 (0:일 , 1:월 , 2:화 , 3:수 , 4: 목 , 5:금 , 6:토 )

%a 짧은요일이름 (Sun, Mon, Tue 등 )

%A 긴요일이름 (Sunday, Monday, Tuesday 등 )

%W 0 부터 53 까지 년중 주일 ( 월요일이 한 주의 시작 )%U 0 부터 53 까지 년중 주일 ( 일요일이 한 주의 시작 )

기타 %x 현재시스템에설정되어있는형식의날짜 (예 : 2008/01/01)

%X 현재시스템에설정되어있는형식의시각 (예 : 12:20:00)

%c 현재시스템에설정되어있는형식의날짜와시각%z 타임존이름 ( 예 : 대한민국표준시 )%% % 기호

시간 출력의 예#include <stdio.h>#include <memory.h>#define MAX_OUTPUT 256

int main( void ){

time_t now = time(NULL);struct tm *lt = localtime(&now);char output[MAX_OUTPUT];printf("ctime: %s", ctime(&now));printf("asctime: %s", asctime(lt));strftime(output, MAX_OUTPUT, "%Y 년 %m 월 %d 일 %X", lt);printf("strftime: %s\n", output);

return 0;}

문자열 복사 함수

함수형태 기능

char *strcpy(char *dest, const char *src) src 를 dest 에 복사

char *strncpy(char *dest, const char *src, size_t count) src 를 count 개수만큼 dest 에 복사

char *strcat(char *dest, const char *src) src 를 dest 끝에붙임

char *strncat(char *dest, const char *src, size_t count) src 를 count 개수만큼 dest 끝에붙임

문자열 복사의 예#include <stdio.h>#include <string.h>#include <time.h>#define MAX_INPUT 20int main(void){

int noon; // 오전오후 저장time_t now; // 현재시각 저장struct tm *lt = NULL; // 현재시각 저장char name[MAX_INPUT] = {0}; // 이름 저장char output[100] = {0}; // 출력 문장 저장char *greeting[] = {"좋은 아침입니다 . ", "활기찬 오후 되세요 . "};char *postfix[] = {"님 ", " 씨 "};printf(" 이름을 입력하세요 : ");fgets(name, MAX_INPUT-1, stdin); // 이름을 입력 받음name[strlen(name)-1] = '\0'; // '\n' 제거now = time(NULL); // 현재 시각을 얻음lt = localtime(&now);if(lt->tm_hour < 12) noon = 0; // 정오를 넘지 않았으면 0else noon = 1; // 정오를 넘었으면 1

strcpy(output, greeting[noon]); // 인사말 복사strcat(output, name); // 이름 붙이기strcat(output, postfix[noon]); // 존칭 붙이기printf("%s\n", output);return 0;

}

문자열 비교 함수

함수형태 기능

int strcmp(const char *s1, const char *s2) s1 과 s2 를비교

int strncmp(const char *s1, const char *s2, size_t count) s1 과 s2 를 count 개수만큼비교

int stricmp(const char *s1, const char *s2) s1 과 s2 를비교 ( 대소문자무시 )

int strnicmp(const char *s1, const char *s2, size_t count) s1 과 s2 를 count 개수만큼비교( 대소문자무시 )

문자열 비교의 예#include <stdio.h>#include <string.h>#define MAX_INPUT 100

int main(void){

char answer[MAX_INPUT] = {0};printf("개를 영어로 뭐라고 합니까 ? ");fgets(answer, MAX_INPUT-1, stdin);answer[strlen(answer)-1] = '\0';if(stricmp(answer, "dog") == 0)

printf(" 정답입니다 .\n");else

printf("틀렸습니다 . 정답은 Dog 입니다 .\n");

return 0;}

문자열 검색 함수

함수형태 기능

char *strchr(const char *str, int c) str 에서 c 를검색

char *strrchr(const char *str, int c) str 에서 c 를뒤에서부터검색

char *strstr(const char *str, const char*strSearch) str 에서 strSearch 를검색

char *strpbrk(const char *str, const char *strCharSet) str 에서 strCharSet 에 주어진 문자 중 가장먼저 나오는 것을검색

문자열 검색의 예#include <stdio.h>#include <string.h>#define MAX_INPUT 256int main(void){

char input[MAX_INPUT] = {0};char *ptr = NULL;int count = 0;printf(" 아무 문자열이나 입력하세요 . a 를 찾아드리겠습니다 .\n 입력 : ");fgets(input, MAX_INPUT-1, stdin);printf("\n");ptr = input;while(1){

ptr = strchr(ptr, 'a'); if(ptr == NULL)

break;printf("%d 번째 글자는 a 입니다 .\n", ptr-input+1);count++;ptr++;

}printf("a 가 총 %d 번 나왔습니다 .\n", count);return 0;

}

문자열 변환 함수

함수형태 기능

char *strset(char *str, int c) str 을 c 로채움

char *strnset(char *str, int c, size_t count) str 을 count 개수만큼 c 로채움

char *strlwr(char *str) str 을 소문자로 변환

char *strupr(char *str) str 을 대문자로 변환

char *strrev(char *str) str 을 거꾸로뒤집음

문자열 변환 예#include <stdio.h>#include <string.h>#define MAX_TEXT 256int main(void){

char input[MAX_TEXT] = {0};char output[MAX_TEXT] = {0};printf(" 아무 문자열이나 입력하세요 .\n 입력 : ");fgets(input, MAX_TEXT-1, stdin);input[strlen(input)-1] = '\0';printf("\n");strncpy(output, input, MAX_TEXT);strset(output, '*');printf("strlwr: %s\n", output);strncpy(output, input, MAX_TEXT);strlwr(output);printf("strlwr: %s\n", output);strncpy(output, input, MAX_TEXT);strupr(output);printf("strupr: %s\n", output);strncpy(output, input, MAX_TEXT);strrev(output);printf("strrev: %s\n", output);return 0;

}

문자 분류 함수

함수형태 기능

int isalpha(int c) 입력이 ASCII 코드로알파벳범위에있으면참 (A-Z, a-z)

int isupper(int c) 입력이 ASCII 코드로대문자범위에있으면참 (A-Z)

int islower(int c) 입력이 ASCII 코드로소문자범위에있으면참 (a-z)

int isdigit(int c) 입력이 ASCII 코드로십진수숫자범위에있으면참 (0-9)

int isxdigit(int c) 입력이 ASCII 코드로 16 진수숫자범위에있으면참 (0-9, A-F, a-f)

int isalnum(int c) 입력이 ASCII 코드로숫자나알파벳범위에있으면참 (0-9, A-Z, a-z)

int isprint(int c) 입력이 ASCII 코드로인쇄가능한문자면참

int isgraph(int c) 입력이 ASCII 코드로공백을제외한인쇄가능한문자면참

int ispuct(int c) 입력이 ASCII 코드로 인쇄가능한 문자 중 alnum 을 제외한 문자면 참

int isspace(int c) 입력이 ASCII 코드로공백문자면참

문자열 분류 예#include <stdio.h>#include <ctype.h>int main(void){

int i;printf("\n-------------------- Alpha --------------------\n");for(i=0 ; i<128 ; i++){

if(isalpha(i))printf("%d %c\t", i, i);

}printf("\n\n-------------------- Upper --------------------\n");for(i=0 ; i<128 ; i++){

if(isupper(i))printf("%d %c\t", i, i);

}printf("\n\n-------------------- Lower --------------------\n");for(i=0 ; i<128 ; i++){

if(islower(i))printf("%d %c\t", i, i);

}return 0;

}

텍스트 / 바이너리 변환

함수형태 기능

double atof(const char *s) 문자열을 double 형으로변환

int atoi(const char *s) 문자열을 int 형으로변환

long atol(const char *s) 문자열을 long 형으로변환

텍스트 / 바이너리 변환 예#include <stdio.h>#include <stdlib.h>

int main(void){

int i = 100;double d = 3.141592;char text[100];

sprintf(text, "%d", i);i = atoi(text);

sprintf(text, "%lf", d);d = atof(text);

return 0;}

난수 발생 함수

함수형태 기능

int rand(void) 0 과 RAND_MAX 사이의임의의숫자를리턴

void srand(unsigned int seed) 무작위값의시작값을설정

난수 발생 예

#include <stdio.h>#include <stdlib.h>#include <time.h>

int main(void){

int random, loop;srand((unsigned int)time(NULL));for(loop=0 ; loop<10 ; loop++){

random = (int)((double)rand()/RAND_MAX*1000);printf("Random number: %03d\n", random);

}return 0;

}

삼각함수

함수형태 기능

double sin(double x) x 의사인함수값을계산

double cos(double x) x 의코사인함수값을계산

double tan(double x) x 의탄젠트함수값을계산

double asin(double x) x 의역사인함수값을계산

double acos(double x) x 의역코사인함수값을계산

double atan(double x) x 의역탄젠트함수값을계산

double atan2(double y, double x) y/x 의역탄젠트함수 값을 계산

double sinh(double x) x 의쌍곡사인 함수 값을 계산

double cosh(double x) x 의쌍곡코사인 함수 값을 계산

double tanh(double x) x 의쌍곡탄젠트함수 값을 계산

삼각함수 예#include <stdio.h>#include <math.h>

int main(void){

int i, j;double pi = 3.141592;double radian, sine;for(i=0 ; i<=360 ; i+=15){

radian = i*pi/180.0;sine = 20+(int)(20*sin(radian));for(j=0 ; j<sine ; j++)

printf(" ");printf("*\n");

}return 0;

}

지수 및 로그 함수

함수형태 기능

double sqrt(double x) x 의제곱근 , √즉 x 를계산

double pow(double x, double y) x 의 y 승 , 즉 xy 을 계산

double log(double x) x 의자연로그 , 즉밑을 e 로하는로그를계산

double log10(double x) x 의 상용로그 , 즉밑을 10 으로 하는 로그를 계산

double exp(double x) 자연대수 e 의 x승 , 즉 ex 을계산

double hypot(double x, double y) √(x2+y2) 을계산 ( 피타고라스정리 )

제곱근 계산 예#include <stdio.h>#include <math.h>

int main(void){

int students, s, sum=0;int score[] = {85, 90, 95, 70, 82, 60, 92, 88};double average, stdev, variance = 0;

students = sizeof(score)/sizeof(int);for(s=0 ; s<students ; s++)

sum += score[s];average = (double)sum/students;for(s=0 ; s<students ; s++)

variance += (score[s]-average)*(score[s]-average);variance /= students;stdev = sqrt(variance);printf(" 총점 : %d\n", sum);printf(" 평균 : %0.2f\n", average);printf(" 분산 : %0.2f\n", variance);printf(" 표준편차 : %0.2f\n", stdev);return 0;

}

정수화 함수 , 절대값 함수

함수형태 기능

double floor(double x) x 보다작지않은최소정수를 double 형으로리턴

double ceil(double x) x 보다크지않은최대정수를 double 형으로리턴

함수형태 기능

int abs(int x) x 의절대값을리턴

long labs(long x) x 의절대값을리턴

double fabs(double x) x 의절대값을리턴

정수형 데이터의 한계

상수 값 의미CHAR_BIT 8 char 의 비트수

SCHAR_MAX 127 char 의최대값SCHAR_MIN -128 char 의최소값SHRT_MAX 32767 short 의최대값SHRT_MIN -32768 short 의최소값LONG_MAX 2147483647 long 의최대값LONG_MIN –2147483648 long 의최소값INT_MAX 2147483647 int 의최대값INT_MIN –2147483648 int 의최소값UCHAR_MAX 255 unsigned char 의최대값USHRT_MAX 65535 unsigned short 의최대값ULONG_MAX 4294967295 unsigned long 의최대값UINT_MAX 4294967295 unsigned int 의최대값

double 형 데이터의 한계

상수 값 의미DBL_DIG 15 십진유효숫자개수DBL_MANT_DIG 53 유효숫자의비트수DBL_MAX_10_EXP

308 최대십진자릿수

DBL_MIN_10_EXP -307 최소십진자릿수DBL_MAX_EXP 1024 최대이진자릿수DBL_MIN_EXP -1021 최소이진자릿수DBL_MAX 1.7976931348623158e+

308최대값

DBL_MIN 2.2250738585072014e-308

양의최소값

DBL_EPSILON 2.2204460492503131e-016

1.0+ DBL_EPSILON != 1.0 이되는최소값

float 형 데이터의 한계

상수 값 의미FLT_DIG 6 십진유효숫자개수FLT_MANT_DIG 24 유효숫자의비트수FLT_MAX_10_EXP 38 최대십진자릿수FLT_MIN_10_EXP -37 최소십진자릿수FLT_MAX_EXP 128 최대이진자릿수FLT_MIN_EXP -125 최소이진자릿수FLT_MAX 3.402823466e+38 최대값FLT_MIN 1.175494351e-38 양의최소값FLT_EPSILON 1.192092896e-07 1.0+ FLT_EPSILON != 1.0 이되는최소값

실습과제사용자로부터 제목과 본문의 내용을 입력 받아 이를 HTML 파일로 저장하는 프로그램을 작성하세요 . 문서 내용을 HTML 파일로 저장하려면 전체 내용을 <html> 과 </html> 태그 사이에 쓰고 , 제목은 <title> 과 </title> 태그 사이에 , 본문은 <body> 와 </body> 태그 사이에 쓰면 됩니다 . 즉 , 다음과 같은 형태로 파일에 써 주면 됩니다 .

<html><title>제목</title><body>본문</body></html>


#include <stdio.h>#include <string.h>#include <malloc.h>#define MAX_FILENAME 256#define MAX_TEXT 1024int main(void){

char filename[MAX_FILENAME];char title[MAX_TEXT];char body[MAX_TEXT];FILE *fp; // 파일 포인터printf(" 저장할 파일명을 입력하세요 : ");fgets(filename, MAX_FILENAME, stdin); // 파일이름 입력filename[strlen(filename)-1] = '\0'; // 줄 바꿈 제거fp = fopen(filename, "rb"); // 파일 열기if(!fp){


}...


printf(" 제목을 입력하세요 : ");fgets(title, MAX_TEXT, stdin); // 제목입력

printf(" 내용을 입력하세요 : ");fgets(body, MAX_TEXT, stdin); // 내용입력

fprintf(fp, "<html>\n"); // <html> 태그fprintf(fp, "<title>\n"); // <title> 태그fprintf(fp, "%s\n", title); // 제목fprintf(fp, "</title>\n"); // </title> 태그fprintf(fp, "<body>\n"); // <body> 태그fprintf(fp, "%s\n", body); // 본문fprintf(fp, "</body>\n"); // </body> 태그fprintf(fp, "</html>\n"); // </html> 태그

fclose(fp); // 파일 닫기return 0;

}

실습과제원본과 대상 파일명을 각각 입력 받아 원본 파일을 대상 파일에 복사하는 프로그램을 작성하세요 .


#include <stdio.h>#include <string.h>#include <malloc.h>

#define MAX_FILENAME 256#define BUFFER_SIZE 102400

int main(void){

char srcfile[MAX_FILENAME], dstfile[MAX_FILENAME];FILE *fpsrc, *fpdst; char *buffer;int read;

printf(" 원본 파일명을 입력하세요 : ");fgets(srcfile, MAX_FILENAME, stdin);srcfile[strlen(srcfile)-1] = '\0';

fpsrc = fopen(srcfile, "rb");if(!fpsrc){

printf(" 원본 파일을 열지 못했습니다 .\n");return 1;

}


printf(" 복사될 파일명을 입력하세요 : ");fgets(dstfile, MAX_FILENAME, stdin);dstfile[strlen(dstfile)-1] = '\0';

fpdst = fopen(dstfile, "wb");if(!fpdst){

printf(" 복사될 파일을 열지 못했습니다 .\n");return 1;

}buffer = (char *)malloc(BUFFER_SIZE);do{

read = fread(buffer, 1, BUFFER_SIZE, fpsrc);fwrite(buffer, 1, read, fpdst);

} while (read == BUFFER_SIZE);printf("%s 가 %s 에 복사되었습니다 .\n", srcfile, dstfile);fclose(fpsrc);fclose(fpdst);free(buffer);return 0;

}

실습과제다음과 같은 형태로 이달의 달력을 출력하는 프로그램을 작성하세요 . 편의상 윤달에 대한 고려는 하지 않는 것으로 합니다 .

====================================

SUN MON TUE WED THU FRI SAT

1 2 3

4 5 6 7 8 9 10

11 12 13 14 15 16 17

18 19 20 21 22 23 24

25 26 27 28 29 30 31

====================================



int main(void){

time_t now;struct tm *lt;int weekday, i;int num_days[12]={31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

now = time(NULL);lt = localtime(&now);

lt->tm_mday = 1;mktime(lt);

weekday = lt->tm_wday;...


...printf("==========================================\n");printf("SUN\tMON\tTUE\tWED\tTHU\tFRI\tSAT\n");

for(i=0 ; i<weekday ; i++)printf("\t");

for(i=1 ; i<=num_days[lt->tm_mon] ; i++){

if(weekday > 6){

printf("\n");weekday = 0;

}printf("%d\t", i);weekday++;

}printf("==========================================\n");return 0;

}

실습과제사용자에게 1 부터 45까지 숫자 중 6 개를 선택하게 하고 , 컴퓨터에게 6 개의 숫자를 무작위로 선택하게 해서 몇 개가 맞았는지 출력하는 로또 (Lotto) 프로그램을 작성하세요 . 편의상 보너스 번호는 없는 것으로 합니다 .



void Lottery(int number[]);void UserInput(int number[]);int compare(const void *a, const void *b);int Matching(int number1[], int number2[]);void ShowResult(int computer[], int user[], int matched);

int main(void){

int computer[6]; // 컴퓨터가 선택한 숫자int user[6]; // 사용자가 선택한 숫자int matched; // 일치한 개수

Lottery(computer); // 컴퓨터에게 임의로 숫자를 선택하게 함UserInput(user); // 사용자로부터 숫자를 입력 받음

qsort(computer, 6, sizeof(int), compare); // 정렬qsort(user, 6, sizeof(int), compare); // 정렬

matched = Matching(computer, user); // 일치한 개수를 카운트ShowResult(computer, user, matched); // 결과 출력

return 0;}

실습과제 해설 2/5void Lottery(int number[]){

int i, j;int duplicated;

srand((unsigned int)time(NULL)); // 무작위 값을 초기화for(i=0 ; i<6 ; i++){

do{

number[i] = (int)((double)rand()/RAND_MAX*44)+1;duplicated = 0;

for(j=0 ; j<i-1 ; j++) // 이전에 선택된 값과 같은지 확인{

if(number[j] == number[i]){

duplicated = 1;break;

}}

} while (duplicated); // 이전 선택과 중복되면 다시 선택}

}

실습과제 해설 3/5void UserInput(int number[]){

int i;printf("1 부터 45 까지의 숫자 6개를 입력하세요 : ");for(i=0 ; i<6 ; i++){

scanf("%d", &number[i]);}

}

int compare(const void *a, const void *b){

if(*(int *)a > *(int *)b)return 1;

else if(*(int *)a < *(int *)b)return -1;

elsereturn 0;

}

실습과제 해설 4/5int Matching(int number1[], int number2[]){

int n1=0, n2=0;int matched = 0;

while(n1<6 && n2<6) // 둘 중 하나가 끝까지 진행하면 중단{

if(number1[n1]==number2[n2]) // 두 숫자가 같으면{

matched++; // 일치된 개수를 1 증가n1++; // 첫번째 배열 인덱스 1 증가n2++; // 두번째 배열 인덱스 1 증가

}else if(number1[n1]<number2[n2]) // 두번째 배열의 수가 더 크면{

n1++; // 첫번째 배열 인덱스 1 증가}else // 첫번째 배열의 수가 더 크면{

n2++; // 첫번째 배열 인덱스 1 증가}

}return matched;

}

실습과제 해설 5/5void ShowResult(int computer[], int user[], int matched){

int i;

printf(" 로또 번호 : ");for(i=0 ; i<6 ; i++)

printf("%02d ", computer[i]);printf("\n");

printf(" 선택 번호 : ");for(i=0 ; i<6 ; i++)

printf("%02d ", user[i]);printf("\n");

switch(matched){case 6:case 5:case 4:

printf("**********************************\n");printf(" 축하합니다 . %d등에 당첨됐습니다 . \n", 6-matched+1);printf("**********************************\n");break;

default:printf("꽝입니다 . 아쉽지만 다음 기회에 ...\n");

}}

Chapter 9C 문법의 확장

변수선언int main(void){

int result, a=3, b=4;result = a+b;int i;

for(i=0 ; i<10 ; i++){

result += i;}return 0;

}

bool 타입

int main(void)

{

int num = -10;

bool isNegative;

isNegative = num<0;

if(isNegative == true)

num = -num;

return 0;

}

레퍼런스struct Point{

double x, y;};

struct Circle{

struct Point center;double radius;

};

int main(void){

struct Circle cir1;cir1.center.x = 3;double &cx = cir1.center.x;...return 0;

}

int &ref; // 컴파일 에러int &ref = 10; // 컴파일 에러

범위지정 연산자 1/2namespace Graphics{

int value;void Initialize(void){

...}

}

namespace Network{

int value;void Initialize(void){

...}

}

int main(void){

Graphics::Initialize();Network::Initialize();...return 0;

}

using namespace Graphics;

using Graphics::Initialize;

범위지정 연산자 2/2

int value = 0; // 전역변수 선언

int main(void){

int value = 10; // 지역변수 선언value++; // 지역변수 참조::value++; // 전역변수 참조return 0;

}

출력 연산자 std::cout << "Hello"; std::cout << std::endl; std::cout << "Hello" << std::endl; int num = 10;

std::cout << "num = " << num << std::endl;

#include <iostream>using namespace std;

int main(void){

int num = 10;cout << "num = " << num << endl;return 0;

}

입력 연산자int num;

std::cin >> num;

new/delete 연산자 int *ptrOne = new int; int *ptrTen = new int [10];

delete ptrOne; delete [] ptrTen;

cf) int *ptrAlloc = (int*)malloc(sizeof(int)*10);

오버로딩 (Overloading)

#include <iostream>using namespace std;int add(int a, int b);double add(double a, double b);

int main(void){

int i1=10, i2=20;double d1=0.1, d2=0.2;cout << "i1+i2 = " << add(i1, i2) << endl;cout << "d1+d2 = " << add(d1, d2) << endl;return 0;

}

int add(int a, int b){

return a+b;}

double add(double a, double b){

return a+b;}

오버로딩 주의점void function(void){

...}

int function(void) // 컴파일 에러{

...return 0;

}

디폴트 매개변수 값#include <iostream>using namespace std;

void PrintDate(int year=2000, int month=1, int day=1);

int main(void){

PrintDate(); // 2000. 1. 1 을 지정PrintDate(2010); // 2010. 1. 1 을 지정PrintDate(2010, 8); // 2010. 8. 1 을 지정PrintDate(2010, 8, 5); // 2010. 8. 5를 지정return 0;

}

void PrintDate(int year, int month, int day){

cout << year << " 년 " << month << " 월 " << day << " 일 " << endl;}

오버로딩된 함수의 디폴트 매개변수void output(int num=10);void output(void);

void output(int num){

cout << num;}

void output(void){

cout << 20;}

int main(void){

output(); // 컴파일 에러return 0;

}

inline 함수#include <iostream>using namespace std;

int add(int a, int b);

int main(void){

int i, sum=0;for(i=0 ; i<100000000 ; i++){

sum = add(i, sum);}cout << "sum = " << sum << endl;return 0;

}

inline int add(int a, int b){

return a+b;}

레퍼런스 인자#include <stdio.h>

void swap(int *a, int *b);

int main(void){

int a=10, b=20;swap(&a, &b);printf("a=%d\n", a);printf("b=%d\n", b);return 0;

}

void swap(int *a, int *b){

int temp;temp = *a;*a = *b;*b = temp;

}

#include <iostream>using namespace std;void swap(int &a, int &b);

int main(void){

int a=10, b=20;swap(a, b);cout << "a=" << a << endl;cout << "b=" << b << endl;return 0;

}

void swap(int &a, int &b){

int temp;temp = a;a = b;b = temp;

}

Chapter 10객체지향 프로그래밍

프로그래밍 방식 구조적 프로그래밍 (Structured Programming)

객체지향 프로그래밍(Object Oriented Programming)

객체의 분할프레임 윈도우

도구모음주소입력창

뷰

상태표시줄

메뉴

C 와 C++

C C++

프로그래밍방식 구조적프로그래밍 객체지향프로그래밍

프로그램분할방법 기능 객체

구현단위 함수 클래스

규모 중소형프로그램 작성에적합

중대형프로그램 작성에적합

객체의 특징

사물

생물 무생물

동물 식물

어류 조류 포유류

고등어 참치 참새 꿩 개 고양이 원숭이 오동나무 소나무 전나무

활엽수 침엽수

상속성

다형성

캡슐화

Chapter 11클래스

C 스타일의 데이터 처리struct Point{

int x, y;};

void SetPosition(struct Point *pPoint, int _x, int _y){

pPoint->x = _x;pPoint->y = _y;

}

void Move(struct Point *pPoint, int _x, int _y){

pPoint->x += _x;pPoint->y += _y;

}

void Show(const struct Point *pPoint){

printf("(%d, %d)\n", pPoint->x, pPoint->y);}

int main(void){

struct Point p1, p2;

SetPosition(&p1, 10, 20);SetPosition(&p2, 50, 60);

Move(&p1, 5, 0);Move(&p2, 0, 5);

Show(&p1);Show(&p2);

return 0;}

C++ 스타일의 데이터 처리struct Point{

int x, y;void SetPosition(int _x, int _y);void Move(int _x, int _y);void Show(void);

};

void Point::SetPosition(int _x, int _y){

x = _x;y = _y;

}

void Point::Move(int _x, int _y){

x += _x;y += _y;

}

void Point::Show(void){

cout << "(" << x << ", " << y << ")" << endl;}

int main(void){

Point p1, p2;

p1.SetPosition(10, 20);p2.SetPosition(50, 60);

p1.Move(5, 0);p2.Move(0, 5);

p1.Show(); p2.Show();

return 0;}

접근권한class 클래스 이름{public:

멤버변수 ;멤버함수 ;

private:멤버변수 ;멤버함수 ;

};

클래스의 선언class Point

{

public:

int x, y;

void SetPosition(int _x, int _y);

void Move(int _x, int _y);

void Show(void);

};

클래스의 정의void Point::SetPosition(int _x, int _y){

x = _x;y = _y;

}

void Point::Move(int _x, int _y){

x += _x;y += _y;

}

void Point::Show(void){

cout << "(" << x << ", " << y << ")" << endl;}

클래스의 사용int main(void){

Point p1, p2; // 점의 좌표를 저장할 변수 선언

p1.SetPosition(10, 20); // p1 의 좌표 설정p2.SetPosition(50, 60); // p2의 좌표 설정

p1.Move(5, 0); // p1 의 좌표 이동p2.Move(0, 5); // p2의 좌표 이동

p1.Show(); // p1 의 좌표를 출력p2.Show(); // p2의 좌표를 출력

return 0;}

클래스의 내부와 외부 클래스의 내부void Point::SetPosition(int _x, int _y){

x = _x;y = _y;

}

클래스의 외부int main(void){

Point p1, p2; // 점의 좌표를 저장할 변수선언p1.SetPosition(10, 20); // p1 의 좌표 설정...

}

접근권한을 설정하는 이유

추상화 안전성

데이터 감추기class Point

{

public:

void SetPosition(int _x, int _y);

void Move(int _x, int _y);

void Show(void);

private:

int x, y;

};

멤버함수를 통한 멤버변수 접근 1/2


int main(void){

int counter = 0; // 카운터를 리셋counter++; // 버튼을 한번 누름counter++; // 버튼을 한번 누름cout << counter << endl; // 카운터 값을 출력

return 0;}

멤버함수를 통한 멤버변수 접근 2/2class Counter{public:

void Reset(void);void Click(void);int GetCount(void);

private:int count;

};

void Counter::Reset(void){

count = 0;}

void Counter::Click(void){

count++;}

int Counter::GetCount(void){

return count;}


int main(void){

Counter ct; // 카운터 선언ct.Reset(); // 카운터를 리셋ct.Click(); // 버튼을 한번 누름ct.Click(); // 버튼을 한번 누름cout << ct.GetCount(); // 카운터 값을 출력cout << endl;return 0;

}

생성자와 소멸자class Counter{public:

Counter(void); // 생성자~Counter(void); // 소멸자void Reset(void); // 카운터를 리셋void Click(void); // 버튼을 한번 누름int GetCount(void); // 카운터의 값을 얻음

private:int count; // 변수에는 접근하지 못하게 함

};

Counter::Counter(void){

count = 0; // 변수 초기화cout << "Constuctor" << endl;

}Counter::~Counter(void){

cout << "Distructor" << endl;}

인스턴스의 생성과 소멸 선언방법 사용범위 메모리에존재하는수명

지역변수 함수안에서선언 함수내 함수가실행되는동안

전역변수 함수밖에서선언 프로그램전체 프로그램이실행되는동안

정적변수 함수안 / 밖에서

static 키워드를붙여선언

함수안에서선언 : 함수내 함수밖에서선언 : 파일내 프로그램이실행되는동안

Counter *pCounter = new Counter; // 메모리 할당 ( 생성자 호출 )...delete pCounter; // 메모리 반납 ( 소멸자 호출 )

Counter *pCounter = new Counter [5]; // 메모리 할당 ( 생성자 호출 )...delete [] pCounter; // 메모리 반납 ( 소멸자 호출 )

// 메모리 할당 ( 생성자는 호출되지 않음 )Counter *pCounter = (Counter *)malloc(sizeof(Counter));...free(pCounter) // 메모리 반납 ( 소멸자는 호출되지 않음 )

생성자의 인자 1/4

class Array{public:

Array(void); // 기본 생성자Array(int size); // 크기를 지정하는 생성자~Array(void); // 소멸자bool SetData(int pos, int data);bool GetData(int pos, int &data);

private:int *pData; // 데이터를 저장하기 위한 포인터int maxsize; // 데이터 저장 공간의 크기

};


Array::Array(void){

maxsize = 100; // 크기를 기본 값으로 설정pData = new int [maxsize]; // 메모리 할당

}

Array::Array(int size){

maxsize = size; // 크기를 주어진 값으로 설정pData = new int [maxsize]; // 메모리 할당

}

Array::~Array(void){

delete [] pData; // 메모리 반납}


bool Array::SetData(int pos, int data)

{

if(pos < 0 || pos >= maxsize) // 범위를 벗어난 쓰기는 실패return false;

pData[pos] = data; // 데이터 쓰기return true; // 성공

}

bool Array::GetData(int pos, int &data)

{

if(pos < 0 || pos >= maxsize) // 범위를 벗어난 읽기는 실패return false;

data = pData[pos]; // 데이터 읽기return true; // 성공

}



int main(void){

Array data(10); // 10 개짜리 공간을 확보int i, val;for(i=0 ; i<=10 ; i++){

if(!data.SetData(i, i)) // 데이터 쓰기cout << "Fail to set data" << endl;

if(!data.GetData(i, val)) // 데이터 읽기cout << "Fail to get data" << endl;

elsecout << "Data = " << val << endl;

}return 0;

}

복사 생성자Array::Array(const Array &data){

maxsize = data.maxsize;pData = data.pData;

}

Array::Array(const Array &data){

maxsize = data.maxsize;pData = data.pData;

}

Array::Array(const Array &data){

maxsize = data.maxsize; // 크기를 같게 설정pData = new int [maxsize]; // 메모리 공간 할당memcpy(pData, data.pData, maxsize); // 데이터 영역 복사

}

포함된 클래스의 생성자 호출 1/2

class Container

{

public:

Container(int size);

// ...

private:

Array data;

};

Container::Container(int size) : data(size)

{

}

포함된 클래스의 생성자 호출 2/2

class Container{public:

Container(int size);// ...

private:Array data(10); // 컴파일 에러

};

Container::Container(int size){

data(size); // 컴파일 에러}

Container::Container(int size){

Array data(size); // 지역변수 선언}

파일의 분할

ClassA.cpp ClassA.h

ClassB.cpp ClassB.h

ClassC.cpp ClassC.h

main.cpp

파일 분할의 예 1/3

// Counter.h 파일의 내용

class Counter{public:

Counter(void); // 생성자void Reset(void); // 카운터를 리셋void Click(void); // 버튼을 한번 누름int GetCount(void); // 카운터의 값을 얻음

private:int count; // 변수에는 접근하지 못하게 함

};


// Counter.cpp 파일의 내용#include "Counter.h"

Counter::Counter(void) // 생성자{

count = 0;}void Counter::Reset(void) // 카운터를 리셋{

count = 0;}void Counter::Click(void) // 버튼을 한번 누름{

count++;}int Counter::GetCount(void) // 카운터의 값을 얻음{

return count;}


// main.cpp 파일의 내용#include <iostream>#include "Counter.h"using namespace std;

int main(void){

Counter ct; // 카운터 선언ct.Reset(); // 카운터를 리셋ct.Click(); // 버튼을 한번 누름ct.Click(); // 버튼을 한번 누름cout << ct.GetCount(); // 카운터 값을 출력cout << endl;return 0;

}

inline 멤버함수 1/2

class Counter{public:

Counter(void)void Reset(void) // 묵시적 inline 함수{

count=0;}void Click(void)int GetCount(void);

private:int count;

};

inline 멤버함수 2/2

#include "Counter.h“

Counter::Counter(void){

count = 0;}

inline void Counter::Click(void) // 명시적 inline 멤버함수{

count++;}

int Counter::GetCount(void){

return count;}

static 멤버 1/3

#define MAX_NAME 20

class Student{public:

Student(char *_name, int _age); // 나이와 이름 초기화~Student(void); // 소멸자void Show(void); // 나이와 이름 출력static int GetCount(void); // 수강생수를 얻음

private:int age; // 나이char name[MAX_NAME]; // 이름static int count; // 수강생 수

};

static 멤버 2/3

int Student::count = 0; // static 멤버변수 선언 및 초기화

Student::Student(char *_name, int _age){

strncpy(name, _name, MAX_NAME-1);age = _age;count++; // 인스턴스 개수 증가

}Student::~Student(void){

count--; // 인스턴스 개수 감소}void Student::Show(void){

cout << name;cout << " (" << age << ")";cout << endl;

}int Student::GetCount(void){

return count; // 인스턴스 개수 리턴}

static 멤버 3/3

#include "Student.h"#include <iostream>

using namespace std;

int main(void){

Student s1("김옥빈 ", 22);Student s2(" 문근영 ", 19);Student s3("전지현 ", 27);s1.Show();s2.Show();s3.Show();cout << " 수강생 수 : " << Student::GetCount() << endl;return 0;

}

this 포인터 1/2

" 김옥빈 "

name

22

age

0x1000

this

s1

“문근영 "

name

19

age

0x1100

this

s2

“ 전지현 "

name

27

age

0x1200

this

s3

int Student::GetCount(){ return count;}

3

count

멤버함수 / 멤버변수 static 멤버함수 / 멤버변수

클래스의 외부

this

this

void Student::Show(){ cout << name << age;}

int main(){ ...}

①

②

③ ④ ⑩ ⑦

⑧

⑥

⑤ ⑨

this 포인터 2/2

int main(void)

{

...

s1.Show();

...

}

void Student::Show()

{

cout << name << age;

}

void Student::Show(Student *this)

{

cout << this->name << this->age;

}

int main(void)

{

...

Student::Show(s1.this);

...

}

static 멤버 호출 인스턴스를 통한 호출

s1.GetCount();

인스턴스를 통하지 않은 호출Student::GetCount();

일반 멤버함수에서 Static 멤버함수 호출void Student::Show(void){

GetCount(); // OK}

Static 멤버함수에서 일반 멤버함수 호출int Student::GetCount(void){

Show(); // 컴파일 에러return count;

}

this 포인터의 활용 Student::Student(char *_name, int _age){

strncpy(name, _name, MAX_NAME-1);age = _age;count++;

}

Student::Student(char *name, int age){

strncpy(this->name, name, MAX_NAME-1);this->age = age;count++;

}

멤버함수의 포인터 1/3

#define MAX_NAME 20class Student{public:

Student(char *_name, int _age); // 나이와 이름 초기화~Student(void); // 소멸자void Show(void); // 나이와 이름 출력static int GetCount(void); // 수강생수를 얻음static int CompareAge(const void *a, const void *b);static int CompareName(const void *a, const void *b);

private:int age; // 나이char name[MAX_NAME]; // 이름static int count; // 수강생 수

};

멤버함수의 포인터 2/3

int Student::CompareAge(const void *a, const void *b){

Student *pa = (Student *)a;Student *pb = (Student *)b;if(pa->age > pb->age) return 1;else if(pa->age < pb->age) return -1;else return 0;

}

int Student::CompareName(const void *a, const void *b){

Student *pa = (Student *)a;Student *pb = (Student *)b;return strcmp(pa->name, pb->name);

}

멤버함수의 포인터 3/3#include <iostream>#include "student.h"using namespace std;int main(void){

int i;Student talent[] = {Student("김옥빈 ",22), Student(" 문근영 ",19),

Student("전지현 ",27), Student(" 이영애 ",37), Student("송혜교 ",26) };int count = Student::GetCount();cout << " 나이순 :" << endl;qsort(talent, count, sizeof(Student), Student::CompareAge);for(i=0 ; i< count ; i++)

talent[i].Show();cout << endl << " 이름순 :" << endl;qsort(talent, count, sizeof(Student), Student::CompareName);for(i=0 ; i<count ; i++)

talent[i].Show();return 0;

}

const 상수const double pi = 3.141592;

pi = 10.0; // 컴파일 에러

const 포인터const int *ptr = NULL

int num[2];

ptr = num;

ptr++;

*ptr = 20; // 컴파일 에러

const 멤버변수class Person{public:

Person(int id);private:

const int id;};

Person::Person(int id) : id(id){}

int main(void){

Person tom(800828), bob(820213);...return 0;

}

const 멤버함수class Person{public:

Person(void);Person(int id);int GetId(void) const;

private:const int id;

};

int Person::GetId(void) const{

return id;}

실습과제사각형 영역을 저장하고 처리하는 클래스 만드세요 . 파워포인트나 포토샵 같은 프로그램에서 마우스를 드래그해서 사각형 영역을 선택하고 , 선택된 영역을 다시 마우스로 드래그해서 이동하거나 크기를 조절하는 등의 조작을 해 보았을 겁니다 . 이런 프로그램을 만들 때 활용할 수 있을 법한 클래스를 만들고자 하는 것입니다 .


class Region{public:

Region(void); // 생성자Region(int l, int t, int r, int b); // 생성자

private://///////////////////////////////////////////////////////////// 사각형 영역을 저장하기 위한 멤버변수들int left; // 시작점의 x좌표int top; // 시작점의 y좌표int right; // 끝점의 x좌표int bottom; // 끝점의 y좌표

/////////////////////////////////////////////////////////////// 출력방식을 지정하기 위한 멤버변수static int notation; // POINT_POINT 또는 POINT_SIZE

public:enum {POINT_POINT, POINT_SIZE}; // 시작점과 끝점 , 시작점과 길이...


public://///////////////////////////////////////////////////////////// 사각형 영역에 대한 정보를 얻는 함수들int GetWidth() const; // 가로길이 얻기int GetHeight() const; // 세로길이 얻기void GetStartPoint(int &x, int &y) const; // 시작점 얻기void GetEndPoint(int &x, int &y) const; // 끝점 얻기void GetCenterPoint(int &x, int &y) const; // 중심점 얻기bool IsPointInRegion(int x, int y) const; // 점이 영역 안에 있는지

/////////////////////////////////////////////////////////////// 사각형 영역을 설정하고 처리하는 함수들void SetRect(int l, int t, int r, int b); // 영역 설정void Move(int x, int y); // 위치 이동void Resize(int width, int height); // 크기 변경void UnionRegion(const Region &r1, const Region &r2); // 교집합void IntersectRegion(const Region &r1, const Region &r2); // 합집합

/////////////////////////////////////////////////////////////// 사각형 영역을 표시하기 위한 함수들void Show(void); // 영역 출력static void SetNotation(int notation); // 출력 방식 지정

};


#include <stdio.h>#include "Region.h"int Region::notation = Region::POINT_POINT;

Region::Region(void){

SetRect(0, 0, 0, 0); // 영역을 0 으로 초기화}Region::Region(int l, int t, int r, int b){

SetRect(l, t, r, b); // 영역을 주어진 값으로 초기화}

void Region::SetRect(int l, int t, int r, int b){

left = l; // 시작점의 x좌표 설정top = t; // 시작점의 y좌표 설정right = r; // 끝점의 x좌표 설정bottom = b; // 끝점의 y좌표 설정

}


int Region::GetWidth() const{

return right - left;}int Region::GetHeight() const{

return bottom - top;}void Region::GetStartPoint(int &x, int &y) const{

x = left; // 시작점의 x 좌표 얻기y = top; // 시작점의 y좌표 얻기

}void Region::GetEndPoint(int &x, int &y) const{

x = right; // 끝점의 x 좌표 얻기y = bottom; // 끝점의 y좌표 얻기

}


void Region::GetCenterPoint(int &x, int &y) const{

x = (left + right)/2; // 중심점의 x 좌표 얻기y = (top + bottom)/2; // 중심점의 y좌표 얻기

}

bool Region::IsPointInRegion(int x, int y) const{

return (x>=left && x<=right && y>=top && y<=bottom);}


void Region::Move(int x, int y){

left += x; // 시작점의 x좌표 이동right += x; // 끝점의 x좌표 이동top += y; // 시작점의 y좌표 이동bottom += y; // 끝점의 y좌표 이동

}

void Region::Resize(int width, int height){

int x, y;GetCenterPoint(x, y);// 중심점 좌표 얻기left = x - width/2; // 중심으로부터 가로길이의 절반만큼 이동top = y - height/2; // 중심으로부터 세로길이의 절반만큼 이동right = left + width;// 가로길이가 width 가 되도록 조절bottom = top + height; // 세로길이가 height 가 되도록 조절

}


void Region::UnionRegion(const Region &r1, const Region &r2){

left = r1.left > r2.left ? r1.left : r2.left;right = r1.right < r2.right ? r1.right : r2.right;top = r1.top > r2.top ? r1.top : r2.top;bottom = r1.bottom < r2.bottom ? r1.bottom : r2.bottom;if(left >= right || top >= bottom) // 교집합이 존재하지 않는 경우{

left = top = right = bottom = 0;}

}

void Region::IntersectRegion(const Region &r1, const Region &r2){

left = r1.left < r2.left ? r1.left : r2.left;right = r1.right > r2.right ? r1.right : r2.right;top = r1.top < r2.top ? r1.top : r2.top;bottom = r1.bottom > r2.bottom ? r1.bottom : r2.bottom;

}


void Region::SetNotation(int n){

notation = n;}

void Region::Show(void){

if(notation == POINT_POINT) // 시작점 / 끝점 형식{

printf("(%d, %d), (%d, %d)\n", left, top, right, bottom);}else // 시작점 / 가로 , 세로 / 길이 형식{

printf("(%d, %d), [%d x %d]\n", left, top, GetWidth(), GetHeight());

}}


#include "Region.h"int main(void){

Region::SetNotation(Region::POINT_POINT); // 출력 형식 지정Region r1(10, 10, 100, 100); // 영역 r1 선언Region r2(50, 50, 120, 120); // 영역 r2 선언Region r3;

r3.IntersectRegion(r1, r2); // r1 과 r2 의 교집합을 r3 에 저장r3.Show();r3.UnionRegion(r1, r2); // r1 과 r2 의 합집합을 r3 에 저장r3.Show();r3.Move(100, 100); // r3 의 위치 이동r3.Show();r3.Resize(200, 200); // r3 의 크기 변경r3.Show();

Region::SetNotation(Region::POINT_SIZE); // 출력 형식 변경r1.Show();r2.Show();r3.Show();return 0;

}

Chapter 12연산자 오버로딩

연산자와 함수

a = b + c;

a = Add(b, c);

SetData(a, Add(b, c));

연산자 오버로딩

연산자가 수행하는 기능을 함수로 구현 함수로 구현된 기능을 연산자 표현으로 호출

연산자 오버로딩의 제약

연산자의 본래 기능을 바꾸면 안됨 연산자의 우선순위나 결합성 변경 불가 기본 데이터 타입끼리의 연산자 함수 정의 불가 오버로딩이 금지된 연산자

sizeof 멤버 참조 연산자 (.) 범위지정 연산자 (::) 조건 선택 연산자 (?:)

기본 클래스 정의 1/2

// Point.hclass Point{public:

Point(void);Point(int x, int y);void Show(void);

private:int x, y;

};

기본 클래스 정의 2/2

// Point.cpp#include "Point.h"#include <iostream>using namespace std;

Point::Point(void){

x = y = 0;}Point::Point(int x, int y){

this->x = x;this->y = y;

}void Point::Show(void){

cout << "(" << x << ", " << y << ")" << endl;}

단항연산자 정의class Point{

...public:

Point operator++(void);Point operator++(int);

};

Point Point::operator++(void) // 전위형{

++x, ++y;return *this;

}Point Point::operator++(int) // 후위형{

Point temp = *this;++x, ++y;return temp;

}

단항연산자 호출#include <iostream>#include "Point.h“

int main(void){

Point p1(0, 0), p2, p3;p2 = ++p1; // 전위형 . operator++() 호출p1.Show();p2.Show();

p3 = p1++; // 후위형 . operator++(int) 호출p1.Show();p3.Show();return 0;

}

단항연산자 호출 과정

Point Point::operator++()

{

++x, ++y;

return *this;

}

p2 = ++p1;

p2 = p1.operator++();

Point Point::operator++(int)

{

Point temp = *this;

++x, ++y;

return temp;

}

p2 = p1++;

p2 = p1.operator++(int);

이항연산자 정의class Point{

...public:

Point operator+(Point pt);};

Point Point::operator+(Point pt){

Point temp;temp.x = x + pt.x;temp.y = y + pt.y;return temp;

}

이항연산자 호출#include <iostream>

#include "Point.h“

int main(void)

{

Point p1(10, 20), p2(5, 7), p3;

p3 = p1 + p2;

p3.Show();

return 0;

}

이항연산자 호출 과정

Point Point::operator+(Point pt)

{

Point temp;

temp.x = x + pt.x;

temp.y = y + pt.y;

return temp;

}

a = b + c;

a = b.operator+(c);

friend 함수의 필요성

Point p1(10, 20), p2;

p2 = p1 * 2;

Point p1(10, 20), p2;

p2 = 2 * p1;

Point Point::operator*(int mag){

Point temp;temp.x = x * mag;temp.y = y * mag;return temp;

}

?

friend 연산자 함수 정의class Point{

...public:

Point operator*(int mag);friend Point operator*(int mag, Point pt);

};



}Point operator*(int mag, Point pt){

Point temp;temp.x = mag * pt.x;temp.y = mag * pt.y;return temp;

}

friend 연산자 함수 호출#include <iostream>#include "Point.h“

int main(void){

Point p1(10, 20), p2;

p2 = p1 * 2; // 멤버함수 호출 p2.Show();

p2 = 2 * p1; // friend 함수 호출p2.Show();

return 0;}

friend 연산자 함수 호출 과정

Point Point::operator*(int mag, Point pt)

{

Point temp;

temp.x = mag * pt.x;

temp.y = mag * pt.y;

return temp;

}

a = 2 * b;

a = operator*(2, b);

연산자 함수의 인자Point Point::operator+(const Point &pt){


}



}

연산자 함수 상수화Point Point::operator+(const Point &pt) const

{

Point temp;

temp.x = x + pt.x;

temp.y = y + pt.y;

return temp;

}

연산자 함수의 리턴 타입Point &Point::operator=(const Point &pt){

x = pt.x;y = pt.y;return *this;

}

Point Point::operator+(const Point &pt) const{


}

bool Point::operator==(const Point &pt) const{

return (x == pt.x && y == pt.y);}

return Point(x + pt.x, y + pt.y);

연산자 함수의 리턴값 상수화Point &Point::operator++(void){++x, ++y;return *this;

}

const Point Point::operator++(int){Point temp = *this;++*this;return temp;

}

대입연산자 1/2

class Point{public:

...Point &operator=(const Point &pt);Point &operator+=(const Point &pt);Point &operator-=(const Point &pt);Point &operator*=(int mag);Point &operator/=(int div);...

};

대입연산자 1/2Point &Point::operator=(const Point &pt){

x = pt.x; y = pt.y;return *this;

}Point &Point::operator+=(const Point &pt){

x += pt.x; y += pt.y;return *this;

}Point &Point::operator-=(const Point &pt){

x -= pt.x; y -= pt.y;return *this;

}Point &Point::operator*=(int mag){

x *= mag; y *= mag;return *this;

}Point &Point::operator/=(int div){

x /= div; y /= div;return *this;

}

산술연산자 1/2

class Point{public:

...Point operator+(const Point &pt) const;Point operator-(const Point &pt) const;Point operator*(int mag) const;Point operator/(int div) const;friend Point operator*(int mag, const Point &pt);friend Point operator/(int div, const Point &pt);...

};

산술연산자 1/2Point Point::operator+(const Point &pt) const{

return Point(x + pt.x, y + pt.y);}Point Point::operator-(const Point &pt) const{

return Point(x - pt.x, y - pt.y);}Point Point::operator*(int mag) const{

return Point(x * mag, y * mag);}Point Point::operator/(int div) const{

return Point(x / div, y / div);}Point operator*(int mag, const Point &pt){

return Point(pt.x * mag, pt.y * mag);}Point operator/(int div, const Point &pt){

return Point(pt.x / div, pt.y / div);}

관계연산자class Point{public:

...bool operator==(const Point &pt) const;bool operator!=(const Point &pt) const;...

};

bool Point::operator==(const Point &pt) const{

return (x == pt.x && y == pt.y); // x, y 가 모두 같으면 true}bool Point::operator!=(const Point &pt) const{

return (x != pt.x || y != pt.y); // x, y 중 하나라도 다르면 true}

증감연산자 1/2

class Point{public:

...Point &operator++(void);Point &operator--(void);const Point operator++(int);const Point operator--(int);...

};

증감연산자 2/2

Point &Point::operator++(void){

++x, ++y;return *this;

}Point &Point::operator--(void){

--x, --y;return *this;

}const Point Point::operator++(int){

Point temp = *this;++*this;return temp;

}const Point Point::operator--(int){

Point temp = *this;--*this;return temp;

}

인덱스연산자 1/2

class Point{public:

...int &operator[](int index);...

};

int &Point::operator[](int index){

if(index == 0)return x;

return y;}

인덱스연산자 2/2

#include <iostream>#include "Point.h"using namespace std;

int main(void){Point pt(10, 20);

cout << pt[0] << endl; // x좌표cout << pt[1] << endl; // y좌표return 0;

}

new, delete 연산자class Point{public:

...void *operator new(size_t size);void operator delete(void *p);...

};

void *Point::operator new(size_t size){

return malloc(size);}void Point::operator delete(void *p){

free(p);}

<<, >> 연산자#include <iostream>using namespace std;class Point{public:

...friend ostream &operator<<(ostream &os, const Point &pt);friend istream &operator>>(istream &is, Point &pt);...

};

ostream &operator<<(ostream &os, const Point &pt){

os << "(" << pt.x << ", " << pt.y << ")";return os;

}istream &operator>>(istream &is, Point &pt){

is >> pt.x;is >> pt.y;return is;

}

실습과제복소수를 저장하는 클래스를 만들고 , 복소수끼리의 사칙연산 , 대입 , 비교 , 입출력 등을 할 수 있도록 +, -, *, /, =, +=, -=, *=, /=, ==, <<, >> 연산자를 오버로딩 하세요 .



class complex{public:

complex(double real=0, double image=0);~complex(void);

private:double real; // 실수부double image; // 허수부...


...public:

complex operator+(const complex &c);complex operator-(const complex &c);complex operator*(const complex &c);complex operator/(const complex &c);complex &operator=(const complex &c);complex &operator+=(const complex &c);complex &operator-=(const complex &c);complex &operator*=(const complex &c);complex &operator/=(const complex &c);bool operator==(const complex &c);friend ostream &operator<<(ostream &os, const complex &c);friend istream &operator>>(istream &is, complex &c);

};


#include "complex.h“

complex::complex(double real, double image){

this->real = real;this->image = image;

}complex::~complex(void){}


complex complex::operator+(const complex &c){

complex temp;temp.real = real + c.real;temp.image = image + c.image;return temp;

}

complex complex::operator-(const complex &c){

complex temp;temp.real = real - c.real;temp.image = image - c.image;return temp;

}


complex complex::operator*(const complex &c){

complex temp;temp.real = real*c.real - image*c.image;temp.image = real*c.image + image*c.real;return temp;

}

complex complex::operator/(const complex &c){

complex temp;temp.real = (real*c.real + image*c.image)

/ (c.real*c.real + c.image*c.image); temp.image = (image*c.real - real*c.image)

/ (c.real*c.real + c.image*c.image);return temp;

}


complex &complex::operator=(const complex &c){

real = c.real;image = c.image;return *this;

}complex &complex::operator+=(const complex &c){

real += c.real;image += c.image;return *this;

}complex &complex::operator-=(const complex &c){

real -= c.real;image -= c.image;return *this;

}


complex &complex::operator*=(const complex &c){

double temp;temp = real*c.real - image*c.image;image = real*c.image + image*c.real;real = temp;return *this;

}

complex &complex::operator/=(const complex &c){

double temp;temp = (real*c.real + image*c.image)

/ (c.real*c.real + c.image*c.image); image = (image*c.real - real*c.image)

/ (c.real*c.real + c.image*c.image);real = temp;return *this;

}

실습과제 해설 8/9bool complex::operator==(const complex &c){

return (real == c.real && image == c.image);}

ostream &operator<<(ostream &os, const complex &c){

if(c.image > 0)os << c.real << "+" << c.image << "i";

else if(c.image < 0)os << c.real << c.image << "i";

else os << c.real;

return os;}

istream &operator>>(istream &is, complex &c){

is >> c.real;is >> c.image;return is;

}


#include "complex.h"int main(void){

complex a, b, c;cout << " 첫번째 복소수 입력 : ";cin >> a; // >> 연산자 호출cout << " 두번째 복소수 입력 : ";cin >> b; // >> 연산자 호출

cout << "a = " << a << endl; // << 연산자 호출cout << "b = " << b << endl; // << 연산자 호출cout << "a+b = " << a+b << endl; // + 연산자 호출cout << "a-b = " << a-b << endl; // - 연산자 호출cout << "a*b = " << a*b << endl; // * 연산자 호출cout << "a/b = " << a/b << endl; // / 연산자 호출

return 0;}

실습과제문자열을 저장하는 클래스를 만들고 , 문자열을 대입하는 기능 , 이어 붙이는 기능 , 비교하는 기능 , 문자열의 각 문자를 참조하는 기능 , 입출력 하는 기능 등을 할 수 있도록 =, +=, +, ==, [], <<, >> 연산자를 오버로딩 하세요 .


#include <iostream>using namespace std;class text{public:

text(const char *s=NULL);text(const text &s);~text(void);int length() { return len; }text &operator=(const text &s);text &operator+=(const text &s);text operator+(const text &s);bool operator==(const text &s);char &operator[](int index);friend ostream &operator<<(ostream &os, const text &s);friend istream &operator>>(istream &is, text &s);

private:char *str; // 문자열 저장int len; // 문자열의 길이 저장

};


#include <string.h>#include "text.h"#define MAX_INTPUT 256

text::text(const char *s){

if(s) // NULL 이 아닌 문자열로 초기화할 경우{

len = (int)strlen(s); // 문자열 길이 계산str = new char [len+1]; // 문자열 길이만큼 메모리 할당strcpy(str, s); // 문자열을 복사해서 저장

}else // NULL 로 초기화할 경우{

len = 0; // 길이를 0 으로 초기화str = NULL; // 포인터를 NULL 로 초기화

}}


text::text(const text &s){

len = s.len; // 문자열 길이 설정str = new char [len+1]; // 문자열 길이만큼 메모리 할당strcpy(str, s.str); // 문자열을 복사해서 저장

}text::~text(void){

if(str)delete [] str; // 메모리 반납

}text &text::operator=(const text &s){

if(str)delete [] str; // 기존의 메모리 반납

len = s.len; // 새로운 길이 설정str = new char[len+1]; // 메모리를 다시 할당strcpy(str, s.str); // 문자열을 복사해서 저장return *this;

}


text &text::operator+=(const text &s){

len += s.len; // 이어 붙일 문자열 길이 합산char *newstr = new char[len+1]; // 새로운 메모리 할당strcpy(newstr, str); // 기존 문자열 복사if(str) delete [] str; // 기존 메모리 반납strcat(newstr, s.str); // 이어 붙일 문자열 연결str = newstr; // 새로운 메모리 설정return *this;

}

text text::operator+(const text &s){

text temp; // 임시변수 선언temp.len = len + s.len; // 두 문자열의 길이 합산temp.str = new char [temp.len+1]; // 메모리 할당strcpy(temp.str, str); // 첫번째 문자열 복사strcat(temp.str, s.str); // 두번째 문자열 연결return temp;

}


bool text::operator==(const text &s){

return strcmp(str, s.str) == 0;}char &text::operator[](int index){

return str[index];}ostream &operator<<(ostream &os, const text &s){

os << s.str;return os;

}

istream &operator>>(istream &is, text &s){

char str[MAX_INTPUT];is >> str;s = text(str);return is;

}


#include "text.h"int main(void){

text t1("Text"); // 첫번째 문자열text t2("Test"); // 두번째 문자열text t3("Text Test"); // 첫번째와 두번째의 합text t4 = t1; // 문자열 대입t4 += text(" ") + t2; // 문자열 이어 붙이기cout << "t3: " << t3 << endl; // 문자열 출력cout << "t4: " << t4 << endl; // 문자열 출력

if(t3 == t4) // 문자열 비교cout << "t3 와 t4 는 같습니다 " << endl;

for(int i=0 ; i< t4.length() ; i++)cout << t4[i] << " / "; // 인덱스에 의한 접근

cout << endl;return 0;

}

Chapter 13상속

상속 1/3

// Parent.hclass Parent // 부모를 모델링 한 클래스{public:

Parent(void); // 생성자~Parent(void); // 소멸자void Character(void); // 성품 출력void Appearance(void); // 외모 출력void Wealth(void); // 재산 출력

private:int money; // 돈 저장

};

상속 2/3

#include <iostream>#include "Parent.h"using namespace std;

Parent::Parent(void){

money = 1000000000; // 십억 원}Parent::~Parent(void){}void Parent::Character(void){

cout << "차분한 성품 " << endl;}void Parent:: Appearance(void){

cout << "잘생긴 외모 " << endl;}void Parent::Wealth(void){

cout << " 재산 : " << money << " 원 " << endl;}

상속 3/3

// Child.h

#include "Parent.h“

class Child : public Parent

{

};

기능의 추가 1/2

// Child.h#include "Parent.h"class Child : public Parent{public:

Child(); // 생성자~ Child(); // 소멸자void Humanity(void); // 추가된 멤버함수

};

void Child::Humanity(void){

cout << "넘치는 인간미 " << endl;}

기능의 추가 2/2

#include "Child.h“

int main(void)

{

Child aBoy;

aBoy.Character(); // Parent 에서 상속 받은 함수 호출aBoy.Appearance(); // Parent 에서 상속 받은 함수 호출aBoy.Wealth(); // Parent 에서 상속 받은 함수 호출aBoy.Humanity(); // Child 에서 추가된 함수 호출return 0;

}

기능의 수정class Child : public Parent{public:

Child(); // 생성자~ Child(); // 소멸자void Humanity(void); // 추가된 멤버함수void Character(void); // 수정된 멤버함수

};

void Child::Character(void){

cout << " 불 같은 성품 " << endl;}

기능의 확장class Child : public Parent{public:

Child(); // 생성자~ Child(); // 소멸자void Humanity(void); // 추가된 멤버함수void Character(void); // 수정된 멤버함수void Appearance(void); // 확장된 멤버함수

};

void Child::Appearance(void){

Parent::Appearance(); // 기반 클래스에서 정의한 기능cout << "훤칠한 키 " << endl; // 파생 클래스에서 확장된 기능

}

접근권한

private

protected

public

기반클래스

private

protected

public

파생클래스

클래스 외부

생성자와 소멸자 1/2

Parent::Parent(void){

money = 1000000000;cout << "Parent 생성자 " << endl;

}Parent::~Parent(void){

cout << "Parent 소멸자 " << endl;}

Child::Child(void){

cout << "Child 생성자 " << endl;}Child::~Child(void){

cout << "Child 소멸자 " << endl;}

생성자와 소멸자 2/2

class Parent{public:

Parent(void);Parent(int money);...

};

Parent::Parent(int money){

this->money = money;cout << "Parent 생성자 " << endl;

}

Child::Child(void) : Parent(1000){

cout << "Child 생성자 " << endl;}

다형성

기반 클래스 1/2

// Figure.hclass Figure{public:

Figure(int x, int y, int width, int height);~Figure();void Move(int x, int y); // 도형 이동void Resize(int width, int height); // 도형 크기 조절void Draw(); // 도형 그리기

protected:int x; // 중심의 x좌표int y; // 중심의 x좌표int width; // 가로 길이int height; // 세로 길이

};

기반 클래스 2/2

#include <iostream>#include "Figure.h"using namespace std;

Figure::Figure(int x, int y, int width, int height){

Move(x, y);Resize(width, height);

}void Figure::Move(int x, int y){

this->x = x;this->y = y;

}void Figure::Resize(int width, int height){

this->width = width;this->height = height;

}void Figure::Draw(){

cout << "Figure::Draw" << endl;}

파생 클래스class Ellipse : public Figure{public:

Ellipse(int x, int y, int width, int height);~Ellipse();void Draw(); // 오버라이딩

};

Ellipse::Ellipse(int x, int y, int width, int height) : Figure(x, y, width, height){}

void Ellipse::Draw(){

cout << "Draw Ellipse: ";cout << "(" << x << ", " << y << "), ";cout << width << " x " << height;cout << endl;

}

클래스의 사용#include "Figure.h“

int main(void){

Ellipse ellipse(30, 20, 50, 20);Triangle triangle(10, 10, 20, 30);Rectangle rectangle(20, 30, 10, 20);

ellipse.Draw(); // 타원 그리기triangle.Draw(); // 삼각형 그리기rectangle.Draw(); // 사각형 그리기

return 0;}

상속과 포인터

Figure부분

Ellipse추가 부분

Figure

Ellipse

Figure부분

Triangle추가 부분

Figure

Triangle

Figure부분

Rectangle추가 부분

Figure

Rectangle

Ellipse ellipse(10, 10, 20, 20);

Figure *ptrFigure = &ellipse;

포인터를 이용한 호출#include "Figure.h"#define FIGURES 10

int main(void){

Figure *figures[FIGURES] = {new Triangle(10, 10, 20, 30),new Rectangle(20, 30, 10, 20),new Ellipse(30, 20, 50, 20),...new Triangle(50, 0, 30, 20)

};int i;for(i=0 ; i< FIGURES ; i++)

figures[i]->Draw(); // 저장된 모든 도형 그리기

for(i=0 ; i< FIGURES ; i++)delete figures[i];

return 0;}

virtual 함수// Figure.hclass Figure{public:

Figure(int x, int y, int width, int height);~Figure();void Move(int x, int y); // 도형 이동void Resize(int width, int height); // 도형 크기 조절virtual void Draw(); // 도형 그리기


};

동적 바인딩

Figure부분

Ellipse추가 부분

Figure

Ellipse

vptr

Figure::Draw()Figure

부분Figure

vptr

Ellipse::Draw()

Figure class

Ellipse class

virtual 함수의 상속 virtual 속성도 상속됨

순수 virtual 함수// Figure.hclass Figure{public:

Figure(int x, int y, int width, int height);~Figure();void Move(int x, int y); // 도형 이동void Resize(int width, int height); // 도형 크기 조절virtual void Draw() = 0; // 도형 그리기


};

virtual 소멸자 1/2

#include "Figure.h"int main(void){

Figure *figures[10] = {new Triangle(10, 10, 20, 30),...new Triangle(50, 0, 30, 20)

};int i;for(i=0 ; i<10 ; i++){

figures[i]->Draw(); // 저장된 모든 도형을 그리기}for(i=0 ; i<10 ; i++){

delete figures[i]; // 소멸자 호출}return 0;

}

virtual 소멸자 2/2

class Figure{public:

Figure(int x, int y, int width, int height);virtual ~Figure();void Move(int x, int y);void Resize(int width, int height);virtual void Draw();

protected:int x;int y;int width;int height;

};

상속의 형태 is-a 관계 : public 상속

Triangle is a Figure.

has-a 관계 : private/protected 상속 Phone has a camera.

has-a 관계의 예 1/2

class Camera{public:

void Photograph(void);void Zoom(int zoom);

};

void Camera::Photograph(void){

cout << "Take a photo..." << endl;}

void Camera::Zoom(int zoom){

cout << "Zoom..." << zoom << endl;}

has-a 관계의 예 2/2

class Phone{public:

void CallUp(int number);void HangUp(void);

};

void Phone::CallUp(int number){

cout << "Call up... " << number << endl;}

void Phone::HangUp(void){

cout << "Hang up... " << endl;}

컨테인먼트에 의한 has-a 관계class Phone{public:

void CallUp(int number);void HangUp(void);void Photomail(int number);

private:Camera camera;

};

void Phone::Photomail(int number){

camera.Photograph();CallUp(number);

}

private 상속에 의한 has-a 관계class Phone : private Camera{public:

void CallUp(int number);void HangUp(void);void Photomail(int number);

};


Photograph();CallUp(number);

}

컨테인먼트와 상속의 비교void Phone::Photomail(int number){

camera.Photograph();CallUp(number);

}


Photograph();CallUp(number);

}

private 상속

public 상속 private 상속

private

protected

public

기반클래스

private

protected

public

파생클래스

클래스 외부

private

protected

public

기반클래스

private

protected

public

파생클래스

클래스 외부

상속의 형태에 따른 접근권한

public 상속 protected 상속 private 상속

public 멤버 public protected private

protected 멤버 protected protected private

private 멤버 접근불가 접근불가 접근불가

실습과제아래 표는 A회사의 직원 목록입니다 . 이 회사는 사원 , 대리 , 과장 , 부장 , 이사의 5 단계 직급체계와 시급제 , 월급제 , 연봉제의 3 가지 급여 산출 방식을 사용하고 있습니다 . 시급제는 신입사원 기준으로 시간당 1 만원을 지급하고 , 직급별로 2 배씩 차등 지급합니다 . 월급제는 신입사원 기준으로 월 200 만원을 지급하고 , 직급별로 20 만원씩 , 연차 별로 5 만원씩 차등 지급합니다 . 연봉제는 신입사원 능력 0등급을 기준으로 년간 2 천만 원을 지급하고 , 직급별로 1천만 원 , 능력 등급별로 5백만 원씩 차등 지급하되 , 연봉의 12 분의 1 을 매달 지급합니다 . 이 회사 전 직원의 정보를 저장하고 , 월급을 계산하여 출력하는 프로그램을 작성하세요 .

이름 직급 급여산출방식 비고

권상우 사원 시급제 월 200 시간근무

조인성 사원 시급제 월 220 시간근무

감우성 대리 월급제 3년차

강동원 대리 월급제 5년차

황정민 과장 연봉제 능력 3등급

박중훈 과장 월급제 15년차

최민식 부장 월급제 20년차

정진영 부장 연봉제 능력 3등급

안성기 이사 시급제 월 50 시간근무

송강호 이사 연봉제 능력 4등급

실습과제 해설 1/8#include <iostream>using namespace std;class text{public:

text(const char *s=NULL);text(const text &s);~text(void);int length() { return len; }text &operator=(const text &s);text &operator+=(const text &s);text operator+(const text &s);bool operator==(const text &s);char &operator[](int index);friend ostream &operator<<(ostream &os, const text &s);friend istream &operator>>(istream &is, text &s);

private:char *str; // 문자열 저장int len; // 문자열의 길이 저장

};


class Employee{public:

Employee(char *name, int position, int salarytype);~Employee(void);

char *GetName(); // 이름 얻기char *GetPosition(); // 직급 얻기char *GetSalaryType(); // 급여 산출 방식 얻기virtual int GetSalary()=0; // 급여 얻기

protected:char *name; // 이름 저장int position; // 직급 저장int salarytype; // 급여 산출 방식 저장

};


#include <string.h>#include <malloc.h>#include "Employee.h“

Employee::Employee(char *name, int position, int salarytype){

this->name = (char *)malloc(strlen(name)+1);strcpy(this->name, name);this->position = position;this->salarytype = salarytype;

}

Employee::~Employee(void){

delete [] name;}


char *Employee::GetName(){

return name;}

char *Employee::GetPosition(){

char *titles[] = {" 사원 ", " 대리 ", " 과장 ", " 부장 ", "임원 "};return titles[position];

}

char *Employee::GetSalaryType(){

char *types[] = {" 시급제 ", " 월급제 ", " 연봉제 "};return types[salarytype];

}

실습과제 해설 5/8class EmployeeHourly : public Employee{public:

EmployeeHourly(char *name, int position, int workinghours);virtual int GetSalary(); // 급여 얻기

private:int workinghours; // 월간 근무시간

};

class EmployeeMonthly : public Employee{public:

EmployeeMonthly(char *name, int position, int serviceyears);virtual int GetSalary(); // 급여 얻기

private:int serviceyears; // 연차

};

class EmployeeYearly : public Employee{public:

EmployeeYearly(char *name, int position, int grade);virtual int GetSalary(); // 급여 얻기

private:int grade; // 능력 등급

};


EmployeeHourly::EmployeeHourly(char *name, int position, int workinghours) : Employee(name, position, 0){

this->workinghours = workinghours;}

EmployeeMonthly::EmployeeMonthly(char *name, int position, int serviceyears) : Employee(name, position, 1){

this->serviceyears = serviceyears;}

EmployeeYearly::EmployeeYearly(char *name, int position, int grade) : Employee(name, position, 2){

this->grade = grade;}


int EmployeeHourly::GetSalary(){

int salary = workinghours * 10000; // 기준 금액for(int i=0 ; i<position ; i++){

salary *= 2; // 직급에 따라 2 배씩 차등}return salary;

}int EmployeeMonthly::GetSalary(){

int salary = 2000000; // 기준 금액salary += 200000 * position; // 직급에 따라 20 만원씩 차등salary += 50000 * serviceyears; // 연차에 따라 5 만원씩 차등return salary;

}int EmployeeYearly::GetSalary(){

int salary = 20000000; // 기준 금액salary += 10000000 * position; // 직급에 따라 1천만 원씩 차등salary += 5000000 * grade; // 능력 등급에 따라 5 백만 원씩 차등return salary/12; // 연봉의 12 분의 1 을 매달 지급

}

실습과제 해설 8/8#include <stdio.h>#include "Employee.h"#define EMPLOYEES 10int main(void){

Employee *employee[] = {new EmployeeHourly("권상우 ", 0, 200),new EmployeeHourly(" 조인성 ", 0, 220),...new EmployeeYearly("송강호 ", 4, 4)

};printf("-----------------------------------\n");printf(" 이름 | 직급 | 종류 | 급여 \n");printf("-----------------------------------\n");for(int i=0 ; i<EMPLOYEES ; i++){

printf("%s | ", employee[i]->GetName());printf("%s | ", employee[i]->GetPosition());printf("%s | ", employee[i]->GetSalaryType());printf("%8d\n", employee[i]->GetSalary());delete employee[i];

}return 0;

}

Chapter 14템플릿

템플릿 함수 템플릿 클래스 템플릿

템플릿의 필요성void swap(int &a, int &b){

int temp;temp = a;a = b;b = c;

}

void swap(double &a, double &b){

double temp;temp = a;a = b;b = c;

}

함수 템플릿template <typename T>void swap(T &a, T &b){

T temp;temp = a;a = b;b = c;

}

template <typename T1, typename T2>void Function(T1 a, T2 b){

...}

템플릿의 인스턴스화#include <iostream>using namespace std;template <typename T>void swap(T &a, T &b){

T temp;temp = a;a = b;b = temp;

}

int main(void){

int a=1, b=2;swap(a, b); // int 형을 인자로 받는 swap 함수 호출cout << a << ", " << b << endl;double c=0.1, d=0.2;swap(c, d); // double 형을 인자로 받는 swap 함수 호출cout << c << ", " << d << endl;return 0;

}

템플릿의 특화 1/2


template <typename T>int DataSize(T data){

return sizeof(data);}

int main(void){

int num = 0;double real = 0.0;char *str = "Good morning!";cout << DataSize(num) << endl; // int 형의 크기 출력cout << DataSize(real) << endl; // double 형의 크기 출력cout << DataSize(str) << endl; // 문자열의 크기 출력return 0;

}

템플릿의 특화 2/2#include <iostream>using namespace std;template <typename T>int DataSize(T data){

return sizeof(data);}template <>int DataSize(char *data){

return strlen(data);}int main(void){

int num = 0;double real = 0.0;char *str = "Good morning!";cout << DataSize(num) << endl;cout << DataSize(real) << endl;cout << DataSize(str) << endl;

}

특화된 함수 정의 방법 template <>

int DataSize<char *>(char *data){

return strlen(data);}

template <>int DataSize<>(char *data){


template <>int DataSize(char *data){


클래스 템플릿의 선언 template <typename T>class Array{public:

Array(int size=100); // 생성자~Array(void); // 소멸자bool SetData(int pos, T data); // 데이터 저장bool GetData(int pos, T &data); // 데이터를 얻음

private:T *pData; // 데이터를 저장하기 위한 포인터int maxsize; // 데이터 저장 공간의 크기

};

클래스 템플릿의 정의 1/2

template <typename T>Array<T>::Array(int size){

maxsize = size; // 저장 공간의 크기 설정pData = new T [maxsize]; // 메모리 할당

}

template <typename T>Array<T>::~Array(void){

delete [] pData; // 메모리 반납}

클래스 템플릿의 정의 2/2

template <typename T>bool Array<T>::SetData(int pos, T data){

if(pos < 0 || pos >= maxsize) // 범위를 벗어난 쓰기는 실패return false;

pData[pos] = data; // 데이터 쓰기return true; // 성공

}

template <typename T>bool Array<T>::GetData(int pos, T &data){

if(pos < 0 || pos >= maxsize) // 범위를 벗어난 읽기는 실패return false;

data = pData[pos]; // 데이터 읽기return true; // 성공

}

클래스 템플릿의 인스턴스화#include <iostream>#include "Array.h"using namespace std;

int main(void){

Array <double>data(10);int i;double val;for(i=0 ; i<10 ; i++){

if(!data.SetData(i, i/10.0))cout << "Fail to set data" << endl;

if(!data.GetData(i, val))cout << "Fail to get data" << endl;

elsecout << "Data = " << val << endl;

}return 0;

}

실습과제 스택 (Stack) 을 클래스 템플릿으로 작성하세요 . 스택은 나중에 들어간 데이터가 먼저 나오는 LIFO(Last In First Out) 방식의 데이터 구조입니다 . 생성자의 인자로 스택의 크기를 설정할 수 있도록 하고 , Push 함수로 데이터를 넣고 , Pop 함수로 데이터를 꺼낼 수 있도록 하세요 . 이 클래스를 이용하여 다음과 같이 char 형의 데이터도 저장했다가 꺼낼 수 있고 , int 형 데이터도 저장했다가 꺼낼 수 있어야 합니다 .

char c;

Stack<char> char_stack(10); // 스택 선언char_stack.Push('A'); // 데이터 넣기char_stack.Push('B'); // 데이터 넣기char_stack.Push('C'); // 데이터 넣기while(char_stack.Pop(c)) // 데이터 꺼내기{

cout << c << endl;

}


template <typename T>class Stack{public:

Stack(int size=100);~Stack(void);bool Push(const T &value); // 데이터 넣기bool Pop(T &value); // 데이터 꺼내기

private:int top; // 데이터가 저장되는 위치int size; // 스택의 크기T *data; // 데이터를 저장할 버퍼

};


template <typename T>Stack<T>::Stack(int size){

top = -1;this->size = size;data = new T[size];

}

template <typename T>Stack<T>::~Stack(){

delete [] data;}


template <typename T>bool Stack<T>::Push(const T &value){

if(top >= size-1) // 스택이 꽉 찼으면 ...return false;

data[++top] = value; // 데이터 넣기return true;

}

template <typename T>bool Stack<T>::Pop(T &value){

if(top < 0) // 스택이 텅 비었으면 ...return false;

value = data[top--]; // 데이터 꺼내기return true;

}

실습과제 큐 (Queue) 를 클래스 템플릿으로 작성하세요 . 큐는 먼저 들어간 데이터가 먼저 나오는 FIFO(Fist In First Out) 방식의 데이터 구조입니다 . 생성자의 인자로 큐의 크기를 설정할 수 있도록 하고 , Enqueue 함수로 데이터를 넣고 , Dequeue 함수로 데이터를 꺼낼 수 있도록 하세요 . 이 클래스를 이용하여 다음과 같이 char 형의 데이터도 저장했다가 꺼낼 수 있고 , int 형 데이터도 저장했다가 꺼낼 수 있어야 합니다 .

char c;Queue<char> char_queue(10); // 큐 선언char_queue.Enqueue('A'); // 데이터 넣기char_queue.Enqueue('B'); // 데이터 넣기char_queue.Enqueue('C'); // 데이터 넣기while(char_queue.Dequeue(c)) // 데이터 꺼내기{

cout << c << endl;}


template <typename T>class Queue{public:

Queue(int size=100);~Queue(void);

bool Enqueue(const T &value); // 데이터 넣기bool Dequeue(T &value); // 데이터 꺼내기

private:int front; // 데이터를 넣는 위치int rear; // 데이터를 꺼내는 위치int size; // 큐의 크기int count; // 큐에 저장된 데이터 개수T *data; // 데이터를 저장할 버퍼

};


template <typename T>Queue<T>::Queue(int size){

front = -1;rear = -1;count = 0;this->size = size;data = new T[size];

}

template <typename T>Queue<T>::~Queue(){

delete [] data;}


template <typename T>bool Queue<T>::Enqueue(const T &value){

if(count >= size) // 큐가 꽉 찼으면 ...return false;

front = (front+1)%size; // 데이터를 넣을 위치 이동count++; // 큐에 저장된 데이터 개수 증가data[front] = value; // 데이터 넣기return true;

}template <typename T>bool Queue<T>::Dequeue(T &value){

if(count <= 0) // 큐가 텅 비었으면 ...return false;

rear = (rear+1)%size; // 데이터를 꺼낼 위치 이동count--; // 큐에 저장된 데이터 개수 감소value = data[rear]; // 데이터 꺼내기return true;

}

Chapter 15예외처리

예외 외적인 요인이 프로그램의 정상 동작을 방해하는 경우

파일에 쓰려고 하는데 디스크가 가득 차서 쓸 수 없는 경우 프린트를 하려고 하는데 프린터에 종이가 떨어진 경우 통신을 하려고 하는데 네트워크 케이블이 빠진 경우 사용자가 숫자를 입력해야 하는 곳에 문자를 입력한 경우

예외처리의 방법 내부 함수들끼리 예외 상황을 알릴 때

최대한 간단명료하고 효율적인 방법으로

사용자 인터페이스를 통해 사용자에게 전달될 때 사용자가 이해할 수 있는 방식으로

예외처리의 두 가지 방식 함수의 리턴값 throw, try, catch

리턴 값에 의한 예외처리bool Divide(double dividend, double divider, double *result){

if (divider==0) // 예외 발생return false; // 예외가 발생했음을 알림

*result = dividend/divider; // 정상 처리return true; // 정상적으로 처리됐음을 알림

}

int main(void){

double a, b, result;cout << "0 이 아닌 두 수를 입력하세요 : ";cin >> a;cin >> b;if(Divide(a, b, &result)){

cout << a << "/" << b << " = " << result << endl;}else{

cout << " 입력이 잘못되었습니다 ." << endl;}return 0;

}

throw 에 의한 예외처리void Divide(double dividend, double divider, double *result){

if (divider==0) // 예외 발생throw false; // 예외가 발생했음을 알림

*result = dividend/divider; // 정상 처리}

int main(void){

double a, b, result;cout << "0 이 아닌 두 수를 입력하세요 : ";cin >> a;cin >> b;try{

Divide(a, b, &result);cout << a << "/" << b << " = " << result << endl;

}catch (bool exception){

cout << " 입력이 잘못되었습니다 ." << endl;}return 0;

}

예외 주고 받기 1/2

void compute(int num){

if (num==0)throw 0;

else if(num > 100)throw 1;

else if(num%2 == 1)throw 2;

// Do something...}

예외 주고 받기 2/2int main(void){

int num;cout << "0 이 아닌 100 보다 작은 짝수를 입력하세요 : ";cin >> num;try{

compute(num);cout << "잘 처리되었습니다 ." << endl;

}catch (int exception){

switch(exception){case 0: cout << "0 을 입력하면 안됩니다 ." << endl;

break;case 1: cout << "100 이상의 수를 입력하면 안됩니다 ." << endl;

break;case 2: cout << "홀수를 입력하면 안됩니다 ." << endl;

break;}

}return 0;

}

다양한 종류의 예외 주고 받기 1/2

void print(int num){

if(num < 0)throw 'x';

// Printing...}

int main(void){

int num;cout << "0 보다 크고 100 보다 작은 짝수를 입력하세요 : ";cin >> num;try{

compute(num);cout << "잘 처리되었습니다 ." << endl;print(num);cout << " 인쇄 되었습니다 ." << endl;

}...

다양한 종류의 예외 주고 받기 2/2

...catch (int compute_exception){

switch(compute_exception){case 0: cout << "0 을 입력하면 안됩니다 ." << endl;

break;case 1: cout << "100 이상의 수를 입력하면 안됩니다 ." << endl;

break;case 2: cout << "홀수를 입력하면 안됩니다 ." << endl;

break;}

}catch (char print_exception){

cout << " 음수는 인쇄할 수 없습니다 ." << endl;}return 0;

}

모든 예외 받기int main(void){



}catch (...){

cout << " 입력이 잘못 되었습니다 ." << endl;}return 0;

}

예외의 타입 표시

void compute(int num) throw (int);

void print(int num) throw (char);

void func1() throw(int, char, double);

void func2() throw();

예외 클래스 1/4

// Exception.hclass Exception{public:

enum ExceptionType {ZERO, TOO_BIG, ODD_NUM, NEGATIVE};Exception(ExceptionType type);void message(void);

private:ExceptionType type; // 예외 종류 저장

};


Exception::Exception(ExceptionType type){

this->type = type;}

void Exception::message(void){

switch(type){case ZERO: cout << "0 을 입력하면 안됩니다 ." << endl;

break;case TOO_BIG: cout << "100 이상의 수를 입력하면 안됩니다 ." << endl;

break;case ODD_NUM: cout << "홀수를 입력하면 안됩니다 ." << endl;

break;case NEGATIVE: cout << " 음수는 인쇄할 수 없습니다 ." << endl;

break;}

}


int main(void){



}catch (Exception e){

e.message();}return 0;

}


void compute(int num) throw (Exception){

if (num==0)throw Exception(Exception::ZERO);

else if(num > 100)throw Exception(Exception::TOO_BIG);

else if(num%2 == 1)throw Exception(Exception::ODD_NUM);

// Do something...}

void print(int num) throw (Exception){

if(num < 0)throw Exception(Exception::NEGATIVE);

// Printing...}

예외 클래스의 상속 1/3

Exception UserException FileException NetworkException


int main(void){

try{

...}catch (FileException fe){

fe.message(); // FileException 타입이 처리됨}catch (Exception e){

e.message(); // Exception 타입이 처리됨}return 0;

}


int main(void){

try{

...}catch (Exception e){

e.message(); // Exception, FileException 처리}catch (FileException fe){

fe.message(); // 이 부분은 절대 실행되지 않음}return 0;

}

예외 발생시 프로그램의 흐름 1/4void level1(void){

level2();cout << "level1 - 완료 " << endl;

}void level2(void){

cout << "level2 - 완료 " << endl;}int main(void){

try{

level1();cout << " main - 완료 " << endl;


cout << "main – 예외발생 " << endl;}return 0;

}

int main(void)

{

try

{

level1();

}

catch

{

...

}

}

void level1()

{

level2();

}

void level2()

{

...

}



}void level2(void){

cout << "level2 – 예외 발생 " << endl;throw 0;cout << " level2 – 완료 " << endl;

}int main(void){

try{




}

int main(void)

{

try

{

level1();

}

catch

{

...

}

}

void level1()

{

level2();

}

void level2()

{

throw 0;

}


try{


}catch(int exception){

cout << "level1 - 예외 발생 " << endl;}

}void level2(void){


}int main(void){

try{




}

int main(void)

{

try

{

level1();

}

catch

{

...

}

}

void level1()

{

try

{

level2();

}

catch

{

...

}

}

void level2()

{

throw 0;

}


try{


}catch(int exception){

cout << "level1 - 예외 발생 " << endl;

throw;}

}void level2(void){


}int main(void){

try{




}

int main(void)

{

try

{

level1();

}

catch

{

...

}

}

void level1()

{

try

{

level2();

}

catch

{

...

throw;

}

}

void level2()

{

throw 0;

}

스택 풀기 1/2

class Data{public:

Data();~Data();

};

Data::Data(){

cout << "Data constructor" << endl;}

Data::~Data(){

cout << "Data destructor" << endl;}

스택 풀기 2/2

void level1(void){

Data d1;level2();cout << "level1 - 완료 " << endl;

}

void level2(void){

Data d2;cout << "level2 - 예외 발생 " << endl;throw 0;cout << "level2 - 완료 " << endl;

}

예외처리 시 주의점void level1(void){

int *ptr = new int [100];level2();delete [] ptr;

}

void level2(void){

throw 0;}

예외처리 방식 비교 리턴 값을 이용한 예외처리

예외 발생의 원인이 호출되는 함수에 직접적으로 관련된 경우 수행 속도가 매우 중요해서 오버헤드를 허용할 수 없는 경우 C 문법만을 이용해서 프로그래밍해야 하는 경우

throw 문을 이용한 예외처리 예외 발생의 원인이 호출되는 함수에 직접적인 관련이 없는 경우 호출하는 쪽에서 예상하지 못하는 순간에 예외가 발생하는 경우 일단 예외가 발생하면 그 다음에 이어지는 일련의 기능들을 수행할 수 없는 경우 예외를 그때그때 처리하기에는 처리해야 할 곳이 너무 많은 경우 여러 군데서 예외가 발생할 수 있지만 처리 방법은 한가지인 경우 생성자 , 소멸자 , 연산자 함수와 같이 리턴 값으로 예외를 전달할 수 없는 경우

1. 프로그래밍의 이해

Documents

Transcript of 1. 프로그래밍의 이해