[김태용의 C 언어 프로그래밍 입문 소스 코드]

[1장]

[first.c 소스 코드]

#include <stdio.h>

int main(void) {

printf("Hello C Language\n");

printf("안녕하세요?");

return 0;

}

[first.c 소스 코드 수정]

#include <stdio.h>

#include <stdlib.h>

int main(void) {

printf("Hello C Language\n");

printf("안녕하세요?");

system("PAUSE");

return 0;

}

[2장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	// 한 행 주석(Comment) – 파일명: first.c /* 한 행 주석 – 파일명: first.c */ /* (주석 시작) 여러 행 주석 – 파일명: first.c (주석 끝) */ #include <stdio.h> // 입출력 함수를 사용하기 위해 필요한 헤더 파일 포함 int main(void) { // C 언어의 시작 함수인 main() 함수 정의 printf("Hello C Language\n"); printf("안녕하세요?"); return 0; } // main() 함수 종료

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12	#include <stdio.h> int main(void) { // 한 문장을 여러 행에 걸쳐서 작성할 수 있음 printf( "Hello C Language\n" ); // 한 문장의 끝 // 여러 문장을 한 행에 작성할 수 있음 printf("Hello "); printf("C Language\n"); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8	#include <stdio.h> int main(void) { printf("Hello C Language\n"); printf("안녕하세요?"); // "\n" 이 없음 printf("Excellent"); return 0; }

[소스 코드]

1 2 3 4 5 6 7	#include <stdio.h> // 입출력 함수를 사용하기 위한 헤더 파일 포함 int main(void) { printf("C 언어 입문\n"); printf("Great Dragon. Kim\n"); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	#include <stdio.h> int main(void) { // 변수를 선언한다. int x; // 정수를 저장할 수 있는 변수 x의 메모리 공간 생성 int y; // 정수를 저장할 수 있는 변수 y의 메모리 공간 생성 int sum; // 두 정수의 합을 저장할 수 있는 변수 sum의 메모리 공간 생성 // 변수에 값을 저장. 즉, 변수명으로 명명된 메모리 공간에 값을 저장 x = 100; y = 500; // 두 수의 합을 구하고, 이 값을 변수 sum으로 명명된 메모리 공간에 저장 sum = x + y; // sum 변수의 값을 화면에 출력 printf("두 수의 합: %d\n", sum); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10	#include <stdio.h> int main(void) { printf("\t Hello C Language!\n"); printf("큰따옴표: " " \n"); printf("작은따옴표: ' ' \n"); printf("백슬래시: \ \n"); printf("물음표: ? \n"); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10	#include <stdio.h> int main(void) { printf("\t Hello C Language!\n"); printf("큰따옴표: \" \" \n"); printf("작은따옴표: \' \' \n"); printf("백슬래시: \\ \n"); printf("물음표: \? \n"); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> int main(void) { int num1, num2, sum; num1 = 0; num2 = 0; sum = 0; printf("두 개의 정수를 입력하면 합을 구합니다.([예] 10 5) : "); scanf("%d %d", &num1, &num2); sum = num1 + num2; printf("%d + %d = %d\n", num1, num2, sum); return 0; }

[3장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20	#include <stdio.h> int main(void) { int a, b; // 콤마(,) 연산자를 사용하여 2개 이상의 변수 선언 가능 int c = 3; // 변수 선언과 동시에 값 저장 가능, 정수 3은 상수 // 콤마(,) 연산자를 사용하여 2개 이상의 변수를 선언함과 동시에 // 값 저장 가능, 정수 4와 5는 상수 int d = 4, e = 5; int result; // 정수 1과 2는 상수 a = 1; b = 2; // 정수 2는 상수 result = (a + b + c + d + e) * 2; printf("%d + %d + %d + %d + %d = %d\n", a, b, c, d, e, result); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18	#include <stdio.h> int main(void) { int x; // 변수 x를 int형으로 생성 x = 0; // 변수 x에 0을 저장 printf("변수 x의 메모리 공간 크기:\t %d byte\n", sizeof(x)); printf("char형 크기:\t\t\t %d byte\n", sizeof(char)); printf("short형 크기:\t\t\t %d byte\n", sizeof(short)); printf("int형 크기:\t\t\t %d byte\n", sizeof(int)); printf("long형 크기:\t\t\t %d byte\n", sizeof(long)); printf("long long형 크기:\t\t %d byte\n", sizeof(long long)); printf("float형 크기:\t\t\t %d byte\n", sizeof(float)); printf("double형 크기:\t\t\t %d byte\n", sizeof(double)); printf("long double형 크기:\t\t %d byte\n", sizeof(long double)); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14	#include <stdio.h> int main(void) { int dollar; // 변수 dollar를 생성 int won; // 변수 won을 생성 printf("달러화 금액을 입력하면 원화로 계산합니다.: "); scanf("%d", &dollar); // 변수 dollar에 1081을 곱한 값을 변수 won에 저장 won = dollar * 1081; printf("현재 %d달러는 %d원입니다.\n", dollar, won); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20	#include <stdio.h> int main(void) { short num1 = 32767; // short형 최대값 short num2 = -32768; // short형 최소값 unsigned short num3 = 65535; // unsigned short형 최대값 unsigned short num4 = 0; // unsigned short형 최소값 num1 = num1 + 1; // 오버플로 발생 num2 = num2 - 1; // 언더플로 발생 num3 = num3 + 1; // 오버플로 발생 num4 = num4 - 1; // 언더플로 발생 printf("num1 = %d\n", num1); printf("num2 = %d\n", num2); printf("num3 = %d\n", num3); printf("num4 = %d\n", num4); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> #include <limits.h> int main(void) { short num1 = SHRT_MAX; // short형 최대값 short num2 = SHRT_MIN; // short형 최소값 unsigned short num3 = USHRT_MAX; // unsigned short형 최대값 unsigned short num4 = 0; // unsigned short형 최소값 num1 = num1 + 1; // 오버플로 발생 num2 = num2 - 1; // 언더플로 발생 num3 = num3 + 1; // 오버플로 발생 num4 = num4 - 1; // 언더플로 발생 printf("num1 = %d\n", num1); printf("num2 = %d\n", num2); printf("num3 = %d\n", num3); printf("num4 = %d\n", num4); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11	#include <stdio.h> int main(void) { float f = 1234567890123456789; double d = 1234567890123456789; printf("%f\n", f); printf("%lf\n", d); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11	#include <stdio.h> int main(void) { float x = 1e39; float y = 1.23456e-46; printf("x=%e\n", x); printf("y=%e\n", y); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10	#include <stdio.h> int main(void) { double d; d = (2.0e20 + 7.0) - 2.0e20; printf("d = %f\n", d); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12	#include <stdio.h> int main(void) { char ch; printf("알파벳 문자 하나를 입력하세요: "); scanf("%c", &ch); printf("입력된 문자의 아스키 코드 숫자는 %d입니다.\n", ch); printf("입력된 문자는 %c입니다.\n", ch); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10	#include <stdio.h> int main(void) { char ch = 'A'; printf("%c의 아스키 코드는 %d 입니다.\n", ch, ch); ch = ch + 1; // 문자 'A' 의 아스키 코드 숫자는 65이므로 65 + 1 연산 printf("%c의 아스키 코드는 %d 입니다.\n", ch, ch); return 0; }

[소스 코드]

1 2 3 4 5 6 7	#include <stdio.h> int main(void) { int i = 1234; printf("변수 i의 값은 \"%d\" 입니다.\n", i); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10	#include <stdio.h> int main(void) { char ch = 'A'; printf("%d %d %d\n", ch + 1, ch + 2, ch + 3); printf("%c %c %c\n", ch + 1, ch + 2, ch + 3); return 0; }

[4장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> // 표준 입출력 함수의 정보가 있는 헤더 파일 포함 #include <string.h> // strlen() 함수의 정보가 있는 헤더 파일 포함 int main(void) { int num = 100; // 리터럴 상수 100은 수식 int num1 = num; // 값을 가지는 변수이므로 수식 int num2 = num + 100; // 연산식이 결과값을 가지므로 수식 int num3 = num + num2; // 연산식이 결과값을 가지므로 수식 // strlen() 함수 호출에 의해 반환값 13을 가지므로 수식 int num4 = strlen("c_programming"); printf("%d, %d, %d, %d\n", num, num1, num2, num3); printf("\"c_programming\" 문자열 길이: %d\n", num4); return 0; }

[소스 코드]

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	#include <stdio.h> int main(void) { int x, y, result; printf("2개의 정수를 입력하세요.[예]5 2: "); scanf("%d %d", &x, &y); result = x + y; // 덧셈 연산 printf("%d + %d = %d\n", x, y, result); result = x - y; // 뺄셈 연산 printf("%d - %d = %d\n", x, y, result); result = x * y; // 곱셈 연산 printf("%d * %d = %d\n", x, y, result); result = x / y; // 나눗셈 연산 printf("%d / %d = %d\n", x, y, result); result = x % y; // 나머지 연산 printf("%d %% %d = %d\n", x, y, result); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23	#include <stdio.h> int main(void) { double x, y, result; printf("2개의 실수를 입력하세요.[예]5 2: "); // scanf() 함수에서 double 값을 받으려면 %lf를 사용해야 한다. scanf("%lf %lf", &x, &y); result = x + y; // 덧셈 연산 printf("%f + %f = %f\n", x, y, result); result = x - y; // 뺄셈 연산 printf("%f - %f = %f\n", x, y, result); result = x * y; // 곱셈 연산 printf("%f * %f = %f\n", x, y, result); result = x / y; // 나눗셈 연산 printf("%f / %f = %f\n", x, y, result); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12	#include <stdio.h> int main(void) { int x = 19, y = 10, result = 99; x += 1; // x = x + 1; x에 20 저장 y *= 3; // y = y * 3; y에 30 저장 result %= x + y; // result = result % (x + y); result에 49 저장 printf("x = %d, y = %d, result = %d\n", x, y, result); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	#include <stdio.h> int main(void) { int num1 = 7; int num2 = -14; num1 = -num1; // num1의 부호를 변경하기 위해 - 부호 연산자 사용 num2 = -num2; // num2의 부호를 변경하기 위해 - 부호 연산자 사용 printf("num1 = %d\n", num1); printf("num2 = %d\n", num2); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23	#include <stdio.h> int main(void) { int x = 9, result_x = 9; // 변수 초기화 x = 9; // 변수 x에 9 저장 result_x = ++x; // 선 증가 printf("result_x = %d, x = %d\n", result_x, x); x = 9; // 변수 x에 9 저장 result_x = x++; // 후 증가 printf("result_x = %d, x = %d\n", result_x, x); x = 9; // 변수 x에 9 저장 result_x = --x; // 선 감소 printf("result_x = %d, x = %d\n", result_x, x); x = 9; // 변수 x에 9 저장 result_x = x--; // 후 감소 printf("result_x = %d, x = %d\n", result_x, x); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9	#include <stdio.h> int main(void) { int x = 1, y = 2, result = 3; result = -x++ + ++y; printf("result = %d , x = %d, y = %d\n", result, x, y); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> int main(void) { int x, y; printf("2개의 정수를 입력하세요.[2 5]: "); scanf("%d %d", &x, &y); printf("x == y의 결과값: %d\n", x == y); printf("x != y의 결과값: %d\n", x != y); printf("x > y의 결과값: %d\n", x > y); printf("x < y의 결과값: %d\n", x < y); printf("x >= y의 결과값: %d\n", x >= y); printf("x <= y의 결과값: %d\n", x <= y); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10	#include <stdio.h> int main(void) { int score = 85; printf("90 <= score < 95: %d\n", 90 <= score < 95); printf("90 <= score && score < 95: %d\n", 90 <= score && score < 95); printf("90 <= score || score < 95: %d\n", 90 <= score || score < 95); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14	#include <stdio.h> int main(void) { int x, y; printf("2개의 정수를 입력하세요.[2 5]: "); scanf("%d %d", &x, &y); printf("%d && %d의 결과값: %d\n", x, y, x && y); printf("%d || %d의 결과값: %d\n", x, y, x || y); printf("!%d의 결과값: %d\n", x, !x); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	#include <stdio.h> int main(void) { int x, y; printf("2개의 정수를 입력하세요.[2 5]: "); scanf("%d %d", &x, &y); printf("최대값: %d\n", (x > y) ? x : y); printf("최소값: %d\n", (x < y) ? x : y); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24	#include <stdio.h> int main(void) { int x = 1, y = 2; int result; result = x + y * y % 2; printf("result = %d\n", result); result = x > y && y > 0; printf("result = %d\n", result); result = x > y || y > 0; printf("result = %d\n", result); result = ++x * y--; printf("result = %d\n", result); printf("x = %d, y = %d\n", x, y); result = x = y = 3; printf("result = %d\n", result); return 0; }

[소스 코드]

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	#include <stdio.h> int main(void) { int x; double d; d = 9 / 2; printf("d = %f\n", d); d = (double) 9 / 2; printf("d = %f\n", d); d = (double) 9 / (double) 2; printf("d = %f\n", d); d = 9.9 + 2.2; printf("x = %f\n", d); x = (int) (9.9 + 2.2); printf("x = %d\n", x); x = (int) 9.9 + (int) 2.2; printf("x = %d\n", x); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	#include <stdio.h> int main(void) { int value = 10, address; int *ptr; ptr = &value; address = *ptr; printf("포인터 변수 ptr에 저장된 주소값: %p\n", ptr); printf("address에 저장된 값: %d\n", address); return 0; }

[5장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14	#include <stdio.h> int main(void) { int num; // int형 변수 num을 선언한다. printf("정수를 입력하세요: "); scanf("%d", &num); if (num > 0) printf("양수입니다.\n"); printf("입력한 정수는 %d입니다.\n", num); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	#include <stdio.h> int main(void) { int num; printf("정수를 입력하세요: "); scanf("%d", &num); if (num > 0) { printf("양수입니다.\n"); printf("입력한 정수는 %d입니다.\n", num); } printf("if문 외부입니다.\n"); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18	#include <stdio.h> int main(void) { int num; printf("정수를 입력하세요: "); scanf("%d", &num); if (num % 2 == 0) { printf("짝수입니다.\n"); printf("입력한 정수는 %d입니다.\n", num); } else { printf("홀수입니다.\n"); printf("입력한 정수는 %d입니다.\n", num); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20	#include <stdio.h> int main(void) { int x, y, result; printf("나눗셈의 분자 정수값을 입력하세요: "); scanf("%d", &x); printf("나눗셈의 분모 정수값을 입력하세요: "); scanf("%d", &y); if (y == 0) { printf("0으로 나눌 수 없습니다.\n"); } else { result = x / y; printf("%d / %d의 결과값은 %d입니다.\n", x, y, result); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> int main(void) { char ch; printf("알파벳 문자 하나를 입력하세요: "); scanf("%c", &ch); if (ch >= 'a' && ch <= 'z') { printf("입력한 문자는 소문자입니다.\n"); } else { printf("입력한 문자는 대문자입니다.\n"); } printf("입력한 문자의 아스키 코드값은 %d입니다.\n", ch); return 0; }

[소스 코드]

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	#include <stdio.h> int main(void) { int score; // 성정 char grade; // 학점 printf("성적을 입력하세요. [0 ~ 100]: "); scanf("%d", &score); if (score >= 90) { grade = 'A'; } else if (score >= 80) { grade = 'B'; } else if (score >= 70) { grade = 'C'; } else if (score >= 60) { grade = 'D'; } else { grade = 'F'; } printf("학점은 %c입니다.\n", grade); return 0; }

[소스 코드]

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	#include <stdio.h> int main(void) { int score; char grade; printf("성적을 입력하세요. [0 ~ 100]: "); scanf("%d", &score); if (score < 0 || score > 100) { // 0부터 100사이의 값인지 검사 printf("입력하신 정수는 %d 입니다.\n", score); printf("0부터 100까지의 정수를 입력하셔야 합니다.\n"); } else { if (score >= 90) { grade = 'A'; } else if (score >= 80) { grade = 'B'; } else if (score >= 70) { grade = 'C'; } else if (score >= 60) { grade = 'D'; } else { grade = 'F'; } printf("학점은 %c입니다.\n", grade); } return 0; }

[소스 코드]

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	#include <stdio.h> int main(void) { int num = 0; printf("1에서 3사이의 정수를 입력하세요: "); scanf("%d", &num); switch (num) { case 1: printf("1을 입력하셨습니다.\n"); break; case 2: printf("2를 입력하셨습니다.\n"); break; case 3: printf("3을 입력하셨습니다.\n"); break; default: printf("잘못 입력하셨습니다.\n"); printf("1에서 3사이의 숫자를 입력하세요.\n"); break; } return 0; }

[소스 코드]

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	#include <stdio.h> int main(void) { int num = 0; printf("1에서 3사이의 정수를 입력하세요: "); scanf("%d", &num); switch (num) { case 1: printf("1을 입력하셨습니다.\n"); // break; 주석 처리함 case 2: printf("2를 입력하셨습니다.\n"); // break; 주석 처리함 case 3: printf("3을 입력하셨습니다.\n"); break; default: printf("잘못 입력하셨습니다.\n"); printf("1에서 3사이의 숫자를 입력하세요.\n"); break; } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> int main(void) { int num = 0; printf("1에서 3사이의 정수를 입력하세요: "); scanf("%d", &num); if (num == 1) { printf("1을 입력하셨습니다.\n"); } else if (num == 2) { printf("2를 입력하셨습니다.\n"); } else if (num == 3) { printf("3을 입력하셨습니다.\n"); } else { printf("잘못 입력하셨습니다.\n"); printf("1에서 3사이의 숫자를 입력하세요.\n"); } return 0; }

[6장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14	#include <stdio.h> int main(void) { int i; int sum = 0; for (i = 1; i <= 100; i++) { // 1부터 100까지 증가 sum += i; // sum = sum + i; } printf("1부터 100까지 정수의 합은 %d\n", sum); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14	#include <stdio.h> int main(void) { int i; int fact = 1; for (i = 1; i <= 10; i++) { // i가 1부터 10까지 증가 fact *= i; // fact = fact * i; } printf("1부터 10까지의 곱, 10! = %d\n", fact); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> int main(void) { int x, i; for( ; ; ) { // 무한 반복 printf("구구단 몇단을 출력할까요? [0 입력 시 종료]: "); scanf("%d", &x); if (x == 0) { break; // for 문을 빠져나간다. } else { for (i = 1; i < 10; i++) { printf("%d*%d=%d ", x, i, x * i); } printf("\n"); } } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14	#include <stdio.h> int main(void) { int i, j; for (i = 1; i < 10; i++) { // 외부 반복문 for (j = 1; j < 10; j++) { // 내부 반복문 printf("%d*%d=%d ", i, j, i * j); } printf("\n"); // 내부 반복문이 종료될 때마다 수행 } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	#include <stdio.h> int main(void) { int i, j; int width, height; printf("*를 사용하여 직사각형을 만듭니다.\n"); printf("가로: "); scanf("%d", &width); printf("세로: "); scanf("%d", &height); for (i = 1; i <= height; i++) { for (j = 1; j <= width; j++) { printf("*"); } printf("\n"); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> int main(void) { int i, j, height; printf("*를 사용하여 피라미드를 만듭니다.\n"); printf("몇 단을 만들까요?: "); scanf("%d", &height); for (i = 1; i <= height; i++) { for (j = 1; j <= height - i; j++) { // height - i개를 공백으로 출력 printf(" "); } for (j = 1; j <= (i * 2) - 1; j++) { // (i * 2) - 1개의 *를 출력 printf("*"); } printf("\n"); // 개행 } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	#include <stdio.h> int main(void) { int i = 1; int j = 1; while (i < 10) { while(j < 10) { printf("%d*%d=%d ", i, j, i * j ); ++j; } printf("\n"); j = 1; ++i; } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	#include <stdio.h> int main(void) { int i = 1, sum = 0; while (i <= 100) { sum += i; // sum = sum + i ++i; } printf("1부터 100까지의 합은 %d입니다.\n", sum); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> int main(void) { int x, i; while (1) { // 무한 반복 printf("구구단 몇단을 출력할까요? [0 입력 시 종료]: "); scanf("%d", &x); if (x == 0) { break; } else { for (i = 1; i < 10; i++) { printf("%d*%d=%d ", x, i, x * i); } printf("\n"); } } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12	#include <stdio.h> int main(void) { int x = 1; do { printf("%d ", x++); } while (x <= 5); printf("\n"); return 0; }

[소스 코드]

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	#include <stdio.h> int main(void) { long num; printf("입력한 양의 정수를 역순으로 출력합니다.\n"); printf("====================\n"); do { printf("양의 정수를 입력하세요: "); scanf("%d", &num); if (num < 0) { printf("양의 정수를 입력해주세요.\n"); } } while (num < 0); printf("%d 정수를 역순으로 읽으면 ", num); do { printf("%d", num % 10); num = num / 10; } while (num > 0); printf("입니다.\n"); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14	#include <stdio.h> int main(void) { int i; for (i = 1; i <= 100; i++) { printf("%d\n", i); if (i == 3) { break; } } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23	#include <stdio.h> int main(void) { int i, num, sum; while (1) { printf("1부터 입력한 정수까지의 합을 출력합니다.\n"); printf("정수를 입력하세요[종료는 0 입력]: "); scanf("%d", &num); // 입력한 정수값을 num 변수에 저장 if (num == 0) { break; // num값이 0이면 반복문을 빠져나간다. } else { sum = 0; for (i = 1; i <= num; i++) { sum += i; // sum = sum + i } printf("1부터 %d까지의 합은 %d입니다.\n", num, sum); } } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> int main(void) { int i, j; for (i = 1; i < 10; i++) { // 외부 반복문 if ((i % 2) == 1) { // i값이 홀수이면 for문의 증감식으로 돌아간다. continue; } for (j = 1; j < 10; j++) { // 내부 반복문 printf("%d*%d=%d ", i, j, i * j); } printf("\n"); // 내부 반복문이 종료될 때마다 수행 } return 0; }

[7장]

[소스 코드]

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	#include <stdio.h> // 함수 원형 선언 void print_gugu(int x); int main(void) { int num; printf("구구단 몇 단을 출력할까요? : "); scanf("%d", &num); if (num != 0) { print_gugu(num); // 함수 호출 } return 0; } // 함수 정의 void print_gugu(int x) { int i; for (i = 1; i < 10; i++) { printf("%d*%d=%d ", x, i, x * i); } printf("\n"); }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	#include <stdio.h> // 함수 원형 선언 void print_test(int num); int main(void) { print_test(20); // 함수 호출 // 변수 x는 print_test() 함수 내의 지역 변수이므로 // 여기서 사용할 수 없다. printf("x = %d\n", x); return 0; } // 함수 정의 void print_test(int num) { int x = 10; // 지역 변수 printf("%d + %d = %d\n", x, num, x + num); }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18	#include <stdio.h> // 함수 원형 선언 void print_test(); int main(void) { print_test(); // 함수 호출 print_test(); // 함수 호출 print_test(); // 함수 호출 return 0; } // 함수 정의 void print_test(void) { int x = 10; printf("++x값은 %d\n", ++x); }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24	#include <stdio.h> void func(void); // 함수 원형 선언 void func2(void); // 함수 원형 선언 int global; // 전역 변수 선언, 초기값은 0, 모든 함수에서 사용 가능 int main(void) { printf("전역 변수 global값: %d\n", global); global = 1234; // 전역 변수 초기화, 값 할당 func(); // 1234 출력 func2(); // 1235 출력 printf("%d\n", global); // 전역 변수 global 사용 가능. 1236 출력 return 0; } void func(void) { printf("%d\n", global++); // 전역 변수 global 사용 가능 } void func2(void) { printf("%d\n", global++); // 전역 변수 global 사용 가능 }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23	#include <stdio.h> void func(void); // 함수 원형 선언 int global = 9; // 전역 변수 int main(void) { int global = 99; // main() 함수 내의 지역 변수 while(1) { // 무한 반복 int global = 999; // while문 내의 지역 변수 printf("while_global = %d\n", ++global); // while문 내의 지역 변수 break; } printf("main_global = %d\n", ++global); // main() 함수 내의 지역 변수 func(); return 0; } void func(void) { printf("global_global = %d\n", ++global); // 프로그램 전역 변수 }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22	#include <stdio.h> void func(void); int main(void) { int i; for (i = 0; i < 5; i++) { func(); } return 0; } void func(void) { int auto_local = 0; // 자동 지역 변수 static int static_local = 0; // 정적 지역 변수 auto_local++; static_local++; printf("auto_local = %d\n", auto_local); printf("static_local = %d\n", static_local); }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23	#include <stdio.h> int factorial(int n); int main(void) { int num; printf("팩토리얼을 구합니다. 정수를 입력하세요.: "); scanf("%d", &num); printf("%d! = %d\n", num, factorial(num)); return 0; } int factorial(int n) { printf("factorial(%d)\n", n); if (n <= 1) { return 1; } else { return n * factorial(n-1); } }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	#include <stdio.h> #include <math.h> // 반드시 math.h 헤더 파일을 포함시켜야 한다. int main(void) { int num; double result; printf("제곱근을 구합니다. 정수를 입력하세요.: "); scanf("%d", &num); printf("%d의 제곱근: %f\n", num, sqrt((double)num)); return 0; }

[8장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> int main(void) { int arr[5]; int i; arr[0] = 0; arr[1] = 10; arr[2] = 20; arr[3] = 30; arr[4] = 40; for (i = 0; i < 5; i++) { printf("arr[%d] = %d\n", i, arr[i]); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18	#include <stdio.h> int main(void) { int arr[5]; // 5개의 원소를 가지는 arr 배열 선언 int i; arr[0] = 0; arr[1] = 10; arr[2] = 20; arr[3] = 30; arr[4] = 40; arr[5] = 50; // 배열 arr에 존재하지 않는 원소에 값을 저장하고 있음 for (i = 0; i < 5; i++) { printf("arr[%d] = %d\n", i, arr[i]); } return 0; }

[소스 코드]

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 32 33 34 35 36 37 38	#include <stdio.h> int arr_global[5]; // 전역 배열 선언 int main(void) { int arr_local[5]; // 지역 배열 선언 int arr[5] = {0, 10, 20, 30, 40}; int arr_2[5] = {0, 10, 2}; int arr_3[] = {0, 10, 2}; int i; for (i = 0; i < 5; i++) { printf("전역 배열 선언, arr_global[%d] = %d\n", i, arr_global[i]); } printf("=====\n"); for (i = 0; i < 5; i++) { printf("지역 배열 선언, arr_local[%d] = %d\n", i, arr_local[i]); } printf("=====\n"); for (i = 0; i < 5; i++) { printf("arr[%d] = %d\n", i, arr[i]); } printf("=====\n"); for (i = 0; i < 5; i++) { printf("arr_2[%d] = %d\n", i, arr_2[i]); } printf("=====\n"); for (i = 0; i < (sizeof(arr_3) / sizeof(int)); i++) { printf("arr_3[%d] = %d\n", i, arr_3[i]); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> #define ARRAY_SIZE 5 // 매크로 상수 int main(void) { int arr[ARRAY_SIZE] = {0, 10, 20, 30, 40}; // 배열 초기화 int i, sum; double avg; // 합계 구하기 // 매크로 상수 ARRAY_SIZE 대신 sizeof(arr) / sizeof(int) 수식 사용 가능 for (i = 0, sum = 0; i < ARRAY_SIZE; i++) { sum += arr[i]; } // 평균 구하기 avg = (double) sum / (double) ARRAY_SIZE; // 평균 printf("합계: %d, 평균: %4.2f\n", sum, avg); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18	#include <stdio.h> int main(void) { int score[] = {50, 80, 90, 40, 70}; // 학생들의 성적, 배열 초기화 int i, min; int arr_size = sizeof(score) / sizeof(int); // 배열 score의 크기 min = score[0]; // 배열의 첫 번째 값을 최소값을 저장할 변수 min에 저장 for (i = 1; i < arr_size; i++) { if (score[i] < min) { min = score[i]; // min값보다 작은값이면 min에 저장 } } printf("성적 최소값은 %d입니다.\n", min); return 0; }

[소스 코드]

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	#include <stdio.h> #define ARRAY_SIZE 5 // 매크로 상수 int main(void) { int score[ARRAY_SIZE]; // 배열 선언 int i, max; printf("[총 %d개의 성적을 입력, 성적 최대값 구하기]\n", ARRAY_SIZE); for (i = 0; i < ARRAY_SIZE; i++) { printf("%d번 성적을 입력하세요: ", ARRAY_SIZE - i); scanf("%d", &score[i]); } max = score[0]; // 첫 번째 입력값을 최대값인 max에 저장 for (i = 1; i < ARRAY_SIZE; i++) { if (score[i] > max) { max = score[i]; // max값보다 큰값이면 max에 저장 } } printf("성적 최대값은 %d입니다.\n", max); return 0; }

[소스 코드]

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 32 33 34 35 36 37 38 39	#include <stdio.h> #define ARRAY_SIZE 10 int main(void) { int arr[ARRAY_SIZE] = {10, 5, 8, 12, 39, 40, 21, 23, 45, 24}; int i, j, temp, min, count = 0; printf("배열 arr 원소: "); for (i = 0; i < ARRAY_SIZE; i++){ printf("%d ", arr[i]); } printf("\n"); for(i = 0; i < ARRAY_SIZE - 1; i++) { min = i; // 최소값 탐색 for(j = i + 1; j < ARRAY_SIZE; j++) { count++; if (arr[j] < arr[min]) { min = j; } } // i번째 원소와 min번째 원소를 교환 temp = arr[i]; arr[i] = arr[min]; arr[min] = temp; } printf("총 비교 횟수는 %d회이다.\n", count); printf("선택 정렬 결과: "); for(i = 0; i < ARRAY_SIZE; i++) { printf("%d ", arr[i]); } printf("\n"); return 0; }

[소스 코드]

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 32 33 34 35 36 37	#include <stdio.h> #define ARRAY_SIZE 10 int main(void) { int arr[ARRAY_SIZE] = {10, 5, 8, 12, 39, 40, 21, 23, 45, 24}; int i, j, temp, count = 0, flag = 1; printf("배열 arr의 원소: "); for (i = 0; i < ARRAY_SIZE; i++){ printf("%d ", arr[i]); } printf("\n"); for(i = 0; i < ARRAY_SIZE - 1; i++) { flag = 1; for(j = 0; j < (ARRAY_SIZE - 1) - i; j++) { count++; if (arr[j] > arr[j + 1]) { flag = 0; temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } if(flag == 1) break; } printf("총 비교 회수는 %d회이다.\n", count); printf("거품 정렬 결과: "); for(i = 0; i < ARRAY_SIZE; i++) { printf("%d ", arr[i]); } printf("\n"); return 0; }

[소스 코드]

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	#include <stdio.h> #define ARRAY_SIZE 10 int main(void) { int i, key, count = 0; int arr[ARRAY_SIZE] = {8, 2, 7, 4, 0, 6, 3, 1, 9, 5}; printf("arr[%d]: ", ARRAY_SIZE); for(i = 0; i < ARRAY_SIZE; i++) { printf("%d ", arr[i]); } printf("\n"); printf("탐색할 정수값을 입력하세요(0 ~ 9): "); scanf("%d", &key); // 배열 원소들 내에서 탐색할 값을 key로 저정 // 배열 원소 중 key 변수값과 동일한 값이 존재하면 인덱스값 반환 for(i = 0; i < ARRAY_SIZE; i++) { count++; if(arr[i] == key) { printf("탐색 성공, 인덱스 값: %d\n", i); break; // for문을 빠져나감 } } printf("탐색 횟수: %d회\n", count); return 0; }

[소스 코드]

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 32	#include <stdio.h> int main(void) { int num[2][3]; // 2차원 배열 선언 int i, j; // for문에서 사용할 변수 int value = 0; // 2중 for문에서 사용할 변수 // 2차원 배열 접근 num[0][0] = 0; num[0][1] = 1; num[0][2] = 2; num[1][0] = 3; num[1][1] = 4; num[1][2] = 5; /* 2중 for문을 사용하여 값을 입력할 수도 있다. for (i = 0; i < 2; i++) { for (j = 0; j < 3; j++) { num[i][j] = value++; } } */ for (i = 0; i < 2; i++) { for (j = 0; j < 3; j++) { printf("%d", num[i][j]); // 2차원 배열 사용 } printf("\n"); } return 0; }

[소스 코드]

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

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

#include <stdio.h>

#define STUDENT 3

#define SUBJECT 3

int main(void) {

int score[STUDENT][SUBJECT] = {

{90, 70, 80}, // 0번 학생의 국영수 점수, 1행

{70, 80, 70}, // 1번 학생의 국영수 점수, 2행

{90, 75, 85} // 2번 학생의 국영수 점수, 3행

};

int i, j;

int subtotal, total = 0;

int subtotal_0 = 0, subtotal_1 = 0, subtotal_2 = 0;

// 학생 한 명의 평균, 전체 평균

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

subtotal = 0;

for(j = 0; j < SUBJECT; j++) {

subtotal += score[i][j];

}

printf("%d번째 학생의 평균 성적: %.2f\n", i, (double) subtotal / SUBJECT);

total += subtotal;

}

printf("전체 학생들의 평균 성적: %.2f\n", (double) total / (STUDENT * SUBJECT));

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

// 국어 평균, 영어 평균, 수학 평균

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

for(j = 0; j < SUBJECT; j++) {

if (j == 0) { // 국어 점수 합계

subtotal_0 += score[i][j];

} else if (j == 1) { // 영어 점수 합계

subtotal_1 += score[i][j];

} else if (j == 2) { // 수학 점수 합계

subtotal_2 += score[i][j];

}

}

}

printf("국어 평균 성적: %.2f\n", (double) subtotal_0 / STUDENT);

printf("영어 평균 성적: %.2f\n", (double) subtotal_1 / STUDENT);

printf("수학 평균 성적: %.2f\n", (double) subtotal_2 / STUDENT);

return 0;

}

[9장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	#include <stdio.h> int main(void) { char c = 'a'; short s = 10; int num = 10; printf("변수 c의 메모리 시작 주소: %x\n", &c); printf("변수 s의 메모리 시작 주소: %x\n", &s); printf("변수 num의 메모리 시작 주소: %x\n", &num); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> int main(void) { char *ptr_c; short *ptr_s; int *ptr_i; float *ptr_f; double *ptr_d; printf("char *의 크기: %d byte\n", sizeof(ptr_c)); printf("short *의 크기: %d byte\n", sizeof(ptr_s)); printf("int *의 크기: %d byte\n", sizeof(ptr_i)); printf("float *의 크기: %d byte\n", sizeof(ptr_f)); printf("double *의 크기: %d byte\n", sizeof(ptr_d)); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> int main(void) { int num = 10; int *ptr = &num; // 포인터 변수 ptr이 가리키는 메모리 공간에 50이라는 값을 저장 *ptr = 50; printf("변수 num의 메모리 시작 주소값: %x\n", &num); printf("포인터 변수 ptr의 메모리 시작 주소값: %x\n", &ptr); printf("포인터 변수 ptr에 저장된 주소값: %x\n", ptr); printf("ptr이 가리키는 메모리 공간에 저장된 값: %d\n", *ptr); return 0; }

[소스 코드]

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	#include <stdio.h> int main(void) { char *ptr_c = (char *)1000; // char * 형변환 short *ptr_s = (short *)1000; // short * 형변환 int *ptr_i = (int *)1000; // int * 형변환 float *ptr_f = (float *)1000; // float * 형변환 double *ptr_d = (double *)1000; // double * 형변환 printf("증가 이전 %d, %d, %d, %d, %d\n", ptr_c, ptr_s, ptr_i, ptr_f, ptr_d); ptr_c = ptr_c + 1; // ++ptr_c ptr_s = ptr_s + 1; // ++ptr_s ptr_i = ptr_i + 1; // ++ptr_i ptr_f = ptr_f + 1; // ++ptr_f ptr_d = ptr_d + 1; // ++ptr_d printf("1 증가 후 %d, %d, %d, %d, %d\n", ptr_c, ptr_s, ptr_i, ptr_f, ptr_d); printf("2 증가 후 %d, %d, %d, %d, %d\n", ptr_c + 2, ptr_s + 2, ptr_i + 2, ptr_f + 2, ptr_d + 2); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	#include <stdio.h> int main(void) { int arr[5] = {10, 20, 30, 40, 50}; // 크기가 5인 정수형 배열 초기화 int *ptr = &arr[0]; // 0번째 배열의 주소값을 포인터 변수 ptr에 저장 int i; for (i = 0; i < 5; i++) { printf("%d\n", *(ptr + i)); // ptr이 가리키는 주소의 값을 출력 } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> int main(void) { int num = 100; int *ptr = &num; printf("num = %d, ptr = %p\n", num, ptr); (*ptr)++; // ptr이 가리키는 대상의 값을 1 증가 printf("num = %d, ptr = %p\n", num, ptr); printf("=====\n"); printf("num = %d, ptr = %p\n", num, ptr); *ptr++; // ptr을 1증가 printf("num = %d, ptr = %p\n", num, ptr); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23	#include <stdio.h> int main(void) { int arr[5] = {10, 20, 30, 40, 50}; printf("&arr[0] = %p\n", &arr[0]); printf("&arr[1] = %p\n", &arr[1]); printf("&arr[2] = %p\n", &arr[2]); // 배열의 이름은 배열의 시작 주소를 가리킨다. printf("arr = %p\n", arr); printf("arr + 1 = %p\n", arr + 1); printf("arr + 2 = %p\n", arr + 2); printf("arr + 3 = %p\n", arr + 3); printf("*arr = %d\n", *arr); printf("*(arr + 1) = %d\n", *(arr + 1)); printf("*(arr + 2) = %d\n", *(arr + 2)); printf("*(arr + 3) = %d\n", *(arr + 3)); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	#include <stdio.h> int main(void) { int arr[3] = {0, 1, 2}; int *ptr; // 포인터 변수 ptr 선언 ptr = arr; // 포인터 변수 ptr에 arr 배열의 주소값을 저장 printf("arr[0]=%d, arr[2]=%d, arr[3]=%d\n", arr[0], arr[1], arr[2]); printf("ptr[0]=%d, ptr[2]=%d, ptr[3]=%d\n", ptr[0], ptr[1], ptr[2]); ptr[0] = 10; ptr[1] = 20; ptr[2] = 30; printf("arr[0]=%d, arr[2]=%d, arr[3]=%d\n", arr[0], arr[1], arr[2]); printf("ptr[0]=%d, ptr[2]=%d, ptr[3]=%d\n", ptr[0], ptr[1], ptr[2]); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24	#include <stdio.h> void swap(int x, int y); int main(void) { int a = 10, b = 20; printf("함수 외부, swap() 함수 호출 전: a=%d, b=%d\n", a, b); swap(a, b); printf("함수 외부, swap() 함수 호출 후: a=%d, b=%d\n", a, b); return 0; } void swap(int x, int y) { int temp; printf("함수 내부, swap() 함수 시작: x=%d, y=%d\n", x, y); temp = x; x = y; y = temp; printf("함수 내부, swap() 함수 끝: x=%d, y=%d\n", x, y); }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22	#include <stdio.h> void swap(int x, int y); int main(void) { int a = 10, b = 20; printf("함수 외부, swap() 함수 호출 전: a=%d, b=%d\n", a, b); swap(&a, &b); printf("함수 외부, swap() 함수 호출 후: a=%d, b=%d\n", a, b); return 0; } void swap(int *ptr_x, int *ptr_y) { int temp; temp = *ptr_x; // temp = a; *ptr_x = *ptr_y; // a = b *ptr_y = temp; // b = a; }

[소스 코드]

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 32 33 34 35 36 37 38 39 40 41 42	#include <stdio.h> #define ARRAY_SIZE 5 double average(int values[], int num); void check_values(int values[], int num); int main(void) { int arr[ARRAY_SIZE]; int i; double result; printf("%d개의 양의 정수값 입력이 필요합니다.\n", ARRAY_SIZE); for (i = 0; i < ARRAY_SIZE; i++) { printf("정수값 하나를 입력하세요: "); scanf("%d", &arr[i]); } check_values(arr, ARRAY_SIZE); // 배열 이름을 인수로 사용 result = average(arr, ARRAY_SIZE); // 배열 이름을 인수로 사용 printf("평균은: %f\n", result); return 0; } double average(int values[], int num) { int i; double sum = 0.0; for (i = 0; i < num; i++) { sum += values[i]; } return sum / num; // 평균값을 반환 } void check_values(int values[], int num) { int i; for (i = 0; i < num ;i++) { if(values[i] < 0) { printf("%d는 0으로 처리함\n", values[i]); values[i] = 0; // 음수 입력값은 0을 저장 } } }

[소스 코드]

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	#include <stdio.h> int plus(int x, int y); int minus(int x, int y); int main(void) { int result; int (*ptr_func)(int, int); ptr_func = plus; result = ptr_func(200, 100); printf("200 + 100 = %d\n", result); ptr_func = minus; result = ptr_func(200, 100); printf("200 - 100 = %d\n", result); return 0; } int plus(int x, int y) { return x + y; } int minus(int x, int y) { return x - y; }

[10장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10	#include <stdio.h> int main(void) { char c1 = 'A'; char c2 = 65; printf("c1 = %c\n", c1); printf("c2 = %c\n", c2); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12	#include <stdio.h> int main(void) { char arr_ch[8] = {'L', 'A', 'N', 'G', 'U', 'A', 'G', 'E'}; int i; for (i = 0; i < 8; i++) { printf("'%c'의 아스키 코드 10진수: %d\n", arr_ch[i], arr_ch[i]); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> int main(void) { char str[6]; int i; str[0] = 'H'; str[1] = 'e'; str[2] = 'l'; str[3] = 'l'; str[4] = 'o'; str[5] = '\0'; for(i = 0; i < 6; i++) { printf("%c", str[i]); printf("^"); } printf("\n"); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> int main(void) { char str1[6] = "Hello"; char str2[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; char str3[10] = "12345"; char str4[] = "C Program"; printf("str1 = %s\n", str1); printf("str2 = %s\n", str2); printf("str3 = %s\n", str3); printf("str4 = %s\n", str4); printf("배열 str4의 크기 = %d\n", sizeof(str4) / sizeof(str4[0])); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	#include <stdio.h> int main(void) { char str[] = "Hello World"; printf("str = %s\n", str); printf("배열 str의 크기 = %d\n", sizeof(str) / sizeof(str[0])); str[6] = 'K'; str[7] = 'o'; str[8] = 'r'; str[9] = 'e'; str[10] = 'a'; printf("str = %s\n", str); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	#include <stdio.h> int main(void) { char str[] = "Hello C Programming"; int i = 0; while(str[i] != 0) { // 널 문자가 아니라면 계속 반복 i++; } printf("문자열 %s의 길이는 %d입니다.\n", str, i); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> // getchar() 함수 사용을 위해 포함 int main(void) { int ch; // int형 변수 선언 printf("문자나 숫자를 입력하세요. q를 입력하면 종료합니다.\n"); while(1) { // 무한 반복, 0이 아니면 항상 참(True) ch = getchar(); // 문자를 입력 받음 if(ch == 'q') { break; } else { putchar(ch); // 문자를 출력함 } } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> int main(void) { char name[100]; char city[100]; printf("이름을 입력하세요: "); scanf("%s", name); printf("현재 거주하는 도시를 입력하세요: "); scanf("%s", city); printf("당신은 %s에 살고 있는 %s입니다.\n", city, name); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> int main(void) { char name[100]; char city[100]; printf("이름을 입력하세요: "); gets(name); // 한 행을 입력받는다. printf("현재 거주하는 도시를 입력하세요: "); gets(city); // 한 행을 입력받는다. puts(name); // 한 행 단위로 출력한다. puts(city); // 한 행 단위로 출력한다. printf("당신은 %s에 살고 있는 %s입니다.\n", city, name); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> #include <ctype.h> // isupper(), tolower() 함수 정보가 있는 헤더 파일 포함 int main(void) { int ch; // getchar() 함수의 반환자료형 while((ch = getchar()) != EOF) { if(isupper(ch)) { ch = tolower(ch); } putchar(ch); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23	#include <stdio.h> #include <ctype.h> int main(void) { char ch1 = '1', ch2 = 'A'; if (isdigit(ch1)) { printf("%c은(는) 숫자입니다.\n", ch1); } else { printf("%c은(는) 숫자가 아닙니다.\n", ch1); } if (isalpha(ch2)) { printf("%c은(는) 알파벳입니다.\n", ch2); if (!islower(ch2)) { printf("%c의 소문자는 %c입니다.\n", ch2, tolower(ch2)); } } else { printf("%c는 알파벳이 아닙니다.\n", ch2); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> #include <string.h> int main(void) { char str1[100]; char str2[] = "Hello"; char str3[] = " World"; strcpy(str1, str2); // str2 문자열을 str1으로 복사 printf("str1[5] = %d\n", str1[5]); strcat(str1, str3); // str1 문자열에 str3 문자열을 연결 printf("str1 = %s\n", str1); printf("str1[11] = %d\n", str1[11]); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24	#include <stdio.h> #include <string.h> int main(void) { char str1[100]; char str2[100]; int result; printf("첫 번째 단어를 입력하세요: "); scanf("%s", str1); printf("두 번째 단어를 입력하세요: "); scanf("%s", str2); result = strcmp(str1, str2); // 2개의 문자열들의 순서를 비교 if(result < 0) { // -1 printf("%s는 %s보다 앞에 있습니다.\n", str1, str2); } else if(result == 0) { printf("%s는 %s와 같습니다.\n", str1, str2); } else { // +1 printf("%s는 %s보다 뒤에 있습니다.\n", str1, str2); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	#include <stdio.h> #include <string.h> int main(void) { char str[] = "Hello C Language!"; char delimit[] = " ,\t\n"; // 구분 문자들을 지정한다. char *token; // 토큰 문자열을 저장할 char형 포인터 변수 // delimit 문자를 사용하여 문자열 str을 분리하고 // 처음 토큰의 문자열을 char형 포인터 변수 token에 저장한다. token = strtok(str, delimit); while(token != NULL) { printf("토큰: %s\n", token); token = strtok(NULL, delimit); // 다음 토큰 문자열을 token에 저장 } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> int main(void) { char str1[] = "100"; char str2[] = "3.14"; char str3[100]; int i; double d; double result; sscanf(str1, "%d", &i); // str1에서 정수를 추출하여 변수 i에 저장 sscanf(str2, "%lf", &d); // str2에서 실수를 추출하여 변수 d에 저장 result = i + d; sprintf(str3, "%f", result); // result 값을 실수 형태로 str3에 저장 printf("연산 결과: %s\n", str3); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22	#include <stdio.h> #include <stdlib.h> int main(void) { char str1[] = "100"; char str2[] = "3.14"; char str3[100]; int i; double d; double result; i = atoi(str1); // sscanf(str1, "%d", &i); d = atof(str2); // sscanf(str2, "%lf", &d); result = i + d; sprintf(str3, "%f", result); printf("연산 결과: %s\n", str3); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> int main(void) { int i; char menu[5][10] = { // 2차원 문자 배열에 여러 개의 문자열 저장 "open", "save", "read", "write", "close" }; for(i = 0; i < 5; i++) { // 2차원 문자 배열 모든 행의 문자열 출력 printf("%d번째 메뉴: %s\n", i, menu[i]); } return 0; }

[소스 코드]

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	#include <stdio.h> #include <string.h> #define WORDS 5 int main(void) { int i, index; char dic[WORDS][5][10] = { {"book", "책"}, {"boy", "소년"}, {"girl","소녀"}, {"sun","태양"}, {"cloud", "구름"} }; char word[30]; // 입력받은 단어를 저장할 크기 30인 문자 배열 선언 printf("검색할 단어를 입력하세요: "); scanf("%s", word); index = 0; for(i = 0; i < WORDS; i++) { if(strcmp(dic[index][0], word) == 0) { printf("%s: %s\n", word, dic[index][1]); return 0; } index++; } printf("입력한 단어가 사전에 없습니다.\n"); return 0; }

[11장]

[소스 코드]

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	#include <stdio.h> #include <string.h> // 구조체 정의 struct student { int number; char name[10]; double grade; }; int main(void) { struct student st1, st2; // 구조체 변수 선언 // st1 구조체 멤버 초기화 st1.number = 20110010; strcpy(st1.name, "Mr. Kim"); st1.grade = 4.2; // st2 구조체 멤버 초기화 st2.number = 20110011; strcpy(st2.name, "Mr. Lee"); st2.grade = 3.2; printf("학번:%d, 이름:%s, 학점:%f\n", st1.number, st1.name, st1.grade); printf("학번:%d, 이름:%s, 학점:%f\n", st2.number, st2.name, st2.grade); return 0; }

[소스 코드]

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 32	#include <stdio.h> struct point { int x; int y; }; struct rect { // 구조체 내에 구조체 포함 struct point p1; struct point p2; }; int main(void) { struct rect r; int width, height, area, length; printf("좌측 상단의 좌표를 입력하세요.[2 3]: "); scanf("%d %d", &r.p1.x, &r.p1.y); printf("우측 하단의 좌표를 입력하세요.[2 3]: "); scanf("%d %d", &r.p2.x, &r.p2.y); width = r.p2.x - r.p1.x; // 너비 height = r.p2.y - r.p1.y; // 높이 area = width * height; // 면적 length = (2 * width) + (2 * height); // 둘레 길이 printf("면적: %d, 둘레 길이: %d\n", area, length); return 0; }

[소스 코드]

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 32 33 34 35 36	#include <stdio.h> #define ARR_SIZE 3 struct student { int number; char name[10]; double grade; }; int main(void) { struct student st_list[ARR_SIZE]; int i; for(i = 0; i < ARR_SIZE; i++) { printf("학번을 입력하세요(정수): "); fflush(stdout); scanf("%d", &st_list[i].number); fflush(stdin); printf("이름을 입력하세요(문자열): "); fflush(stdout); scanf("%[^\n]s", st_list[i].name); fflush(stdin); printf("학점을 입력하세요(실수): "); fflush(stdout); scanf("%lf", &st_list[i].grade); fflush(stdin); printf("==========\n"); } for(i = 0; i < ARR_SIZE; i++) { printf("학번: %d, 이름: %s, 학점: %f\n", st_list[i].number, st_list[i].name, st_list[i].grade); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22	#include <stdio.h> struct student { int number; char name[10]; double grade; }; int main(void) { struct student st = {20110010, "Mr. Kim", 4.2}; struct student *ptr; // 구조체를 가리키는 포인터 ptr = &st; printf("학번: %d, 이름: %s, 학점: %f\n", st.number, st.name, st.grade); printf("학번: %d, 이름: %s, 학점: %f\n", (*ptr).number, (*ptr).name, (*ptr).grade); printf("학번: %d, 이름: %s, 학점: %f\n", ptr->number, ptr->name, ptr->grade); return 0; }

[소스 코드]

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	#include <stdio.h> struct birthday { int year; int month; int day; }; struct student { int number; char name[10]; double grade; struct birthday *ptr_birth; }; int main(void) { struct birthday bday = {1990, 2, 15}; struct student st = {20110010, "Mr. Kim", 4.2}; st.ptr_birth = &bday; printf("학번: %d, 이름: %s, 학점: %f\n", st.number, st.name, st.grade); printf("생년월일: %d년 %d월 %d일\n", st.ptr_birth->year, st.ptr_birth->month, st.ptr_birth->day); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18	#include <stdio.h> union share { // 공용체 정의 char c; int i; }; int main(void) { union share my_share; // 공용체 변수 선언 my_share.c = 'Z'; printf("my_share.c: %c, my_share.i: %d\n", my_share.c, my_share.i); my_share.i = 100; printf("my_share.c: %c, my_share.i: %d\n", my_share.c, my_share.i); return 0; }

[소스 코드]

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	#include <stdio.h> enum color{white, red, green, blue, black}; int main(void) { enum color background; // 열거형 변수 선언 background = blue; // 열거형 변수에 열거형 상수값 저장 switch(background) { case white: printf("흰색입니다.\n"); break; case red: printf("빨간색입니다.\n"); break; case green: printf("녹색입니다.\n"); break; case blue: printf("파란색입니다.\n"); break; case black: printf("검은색입니다.\n"); break; } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18	#include <stdio.h> struct point { int x; int y; }; typedef struct point POINT; // 새로운 자료형으로 정의 int main(void) { struct point p1 = {100, 200}; POINT p2; p2 = p1; printf("p2의 좌표: %d, %d\n", p2.x, p2.y); return 0; }

[12장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	#include <stdio.h> int main(void) { printf("[%5d]\n", 7); printf("[%-5d]\n", 7); printf("[%d]\n", 7); printf("[%+d]\n", 7); printf("[%05d]\n", 7); printf("[%-05d]\n", 7); printf("[% -5d]\n", 7); printf("[% -5d]\n", -7); printf("[% +5d]\n", 7); printf("[%#5o]\n", 32); printf("[%-#5o]\n", 32); printf("[%#-5x]\n", 32); return 0; }

[소스 코드]

1 2 3 4 5 6	#include <stdio.h> int main(void) { printf("%11.2f\n", 3.14); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9	#include <stdio.h> int main(void) { printf("10진법: %d\n", 100); printf("8진법: %o\n", 100); printf("16진법: %x\n", 100); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8	#include <stdio.h> int main(void) { printf("일반 표기법: %f\n", 0.0012); printf("과학적 표기법: %e\n", 0.0012); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12	#include <stdio.h> int main(void) { printf("%5d\n", 399); printf("%5d\n", -399); printf("%-5d\n", 399); printf("%-5d\n", -399); printf("%+5d\n", 399); printf("%+5d\n", -399); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14	#include <stdio.h> int main(void) { printf("%7.2f\n", 1.23); printf("%7.2f\n", -1.23); printf("%-7.2f\n", 1.23); printf("%-7.2f\n", -1.23); printf("%+7.2f\n", 1.23); printf("%+7.2f\n", -1.23); printf("%.2f\n", 1.234); printf("%.7f\n", 1.234); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11	#include <stdio.h> int main(void) { int number1, number2; printf("숫자 10자리를 입력하세요: "); scanf("%5d%3d", &number1, &number2); printf("number1 = %d, number2 = %d\n", number1, number2); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11	#include <stdio.h> int main(void) { int d, o, x; printf("숫자 3개를 입력하세요(10진수 8진수 16진수): "); scanf("%d %o %x", &d, &o, &x); printf("10진수로 출력: d = %d, o = %d, x = %d\n", d, o, x); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> int main(void) { char ch; char arr_ch1[100], arr_ch2[100]; printf("공백 문자로 분리된 문자열을 입력하세요: "); scanf("%s%c%s", &arr_ch1, &ch, &arr_ch2); printf("첫 번째 입력 문자열: %s\n", arr_ch1); printf("입력 문자: %c\n", ch); printf("두 번째 입력 문자열: %s\n", arr_ch2); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12	#include <stdio.h> int main(void) { char arr_ch1[100]; printf("문자열을 입력하세요: "); scanf("%[asdf]", &arr_ch1); printf("입력 문자열: %s\n", arr_ch1); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> int main(void) { FILE *fp = NULL; fp = fopen("test.txt", "w"); // 쓰기 모드로 파일을 연다. if(fp == NULL) { printf("파일 열기 실패\n"); }else { printf("파일 열기 성공\n"); } fclose(fp); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	#include <stdio.h> int main(void) { FILE *fp = NULL; fp = fopen("test.txt", "w"); if(fp == NULL) { printf("파일 열기 실패\n"); }else { printf("파일 열기 성공\n"); } fputc('x', fp); // 하나의 문자를 파일 포인터 fp에 쓴다. fputc('y', fp); fputc('z', fp); fclose(fp); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> int main(void) { FILE *fp = NULL; int c; fp = fopen("test.txt", "r"); if(fp == NULL) { printf("파일 열기 실패\n"); } else { printf("파일 열기 성공\n"); } while((c = fgetc(fp)) != EOF) { putchar(c); } printf("\n"); fclose(fp); return 0; }

[소스 코드]

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 32 33 34 35	#include <stdio.h> #include <stdlib.h> int main(void) { FILE *fp1, *fp2; char f1[100], f2[100]; char buffer[100]; printf("원본 파일 이름: "); scanf("%s", f1); printf("복사 파일 이름: "); scanf("%s", f2); // 원본 파일을 읽기 모드로 연다. if((fp1 = fopen(f1, "r")) == NULL) { fprintf(stderr, "원본 파일 %s을 열 수 없습니다.", f1); exit(1); } // 복사 파일을 쓰기 모드로 연다. if((fp2 = fopen(f2, "w")) == NULL) { fprintf(stderr, "복사 파일 %s을 열 수 없습니다.", f2); exit(1); } // 원본 파일을 복사 파일로 복사한다. 행단위로 읽는다. while(fgets(buffer, 100, fp1) != NULL) { fputs(buffer, fp2); } fclose(fp1); fclose(fp2); return 0; }

[소스 코드]

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 32 33 34 35	#include <stdio.h> #include <stdlib.h> #include <string.h> int main(void) { FILE *fp; // 파일 포인터 char fname[100]; // 파일 이름 char buffer[1024]; // 파일 내의 문자열 저장 char word[256]; // 검색할 단어 int line_number = 0; // 행번호 printf("검색할 파일 이름을 입력하세요: "); scanf("%s", fname); printf("검색할 단어를 입력하세요: "); scanf("%s", word); // 파일을 읽기 모드로 연다. if((fp = fopen(fname, "r")) == NULL) { fprintf(stderr, "원본 파일 %s을 열 수 없습니다.", fname); exit(1); } // 원본 파일을 복사 파일로 복사한다. 행단위로 읽는다. while(fgets(buffer, 1024, fp) != NULL) { line_number++; if(strstr(buffer, word)) { // buffer 내에 word가 있으면 참 printf("%s: %d번 행에서 단어 %s를 검색했습니다.\n", fname, line_number, word); } } fclose(fp); return 0; }

[search.txt]

C (pronounced like the letter C) is a general-purpose computer programming language developed between 1969 and 1973 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system. // 1행

// 2행

Although C was designed for implementing system software, it is also widely used for developing portable application software. //3행

// 4행

C is one of the most widely used programming languages of all time and there are very few computer architectures for which a C compiler does not exist. // 5행

C has greatly influenced many other popular programming languages, most notably C++, which began as an extension to C. // 6행

[소스 코드]

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46	#include <stdio.h> #include <stdlib.h> int main(void) { FILE *fp; char fname[100]; int number, count = 0; char name[100]; float score, total = 0.0; printf("저장할 성적 파일 이름을 입력하세요: "); scanf("%s", fname); if((fp = fopen(fname, "w")) == NULL) { fprintf(stderr, "저장할 성적 파일 %s를 열 수 없습니다.\n", fname); exit(1); } while(1) { // 무한 반복 printf("학번 이름 성적 형식으로 입력하세요(-1은 종료): "); scanf("%d", &number); if(number == -1) { break; } scanf("%s %f", &name, &score); fprintf(fp, "%d %s %f\n", number, name, score); } fclose(fp); // 저장한 성적 파일을 읽기 모드로 연다. if((fp = fopen(fname, "r")) == NULL) { fprintf(stderr, "성적 파일 %s를 열 수 없습니다.\n", fname); exit(1); } // 파일에서 정적을 읽어서 평균을 구한다. while(!feof(fp)) { fscanf(fp, "%d %s %f", &number, name, &score); total += score; count++; } printf("평균 = %f\n", total/count); fclose(fp); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> int main(void) { int buffer[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; FILE *fp = NULL; size_t size, count; fp = fopen("binary.dat", "wb"); // 바이너리 파일 쓰기 모드로 연다. if(fp == NULL) { fprintf(stderr, "파일을 열 수 없습니다."); return 1; } size = sizeof(buffer[0]); // 항목 하나의 크기 count = sizeof(buffer) / sizeof(buffer[0]); // 항목 개수 fwrite(&buffer, size, count, fp); // count 항목 개수를 buffer에 쓴다. fclose(fp); printf("파일로 저장하였습니다.\n"); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23	#include <stdio.h> #include <stdlib.h> #define SIZE 10 int main(void) { int buffer[SIZE]; FILE *fp = NULL; int i; fp = fopen("binary.dat", "rb"); // 바이너리 파일 읽기 모드로 연다. if(fp == NULL) { fprintf(stderr, "파일을 열 수 없습니다."); return 1; } for(i = 0; i < SIZE; i++) { fread(&buffer[i], sizeof(int), 1, fp); // 한 개의 정수를 읽는다. printf("%d ", buffer[i]); } printf("\n"); return 0; }

[소스 코드]

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46	#include <stdio.h> #include <stdlib.h> #define SIZE 3 struct student { // 학생 자료를 구조체로 정의 int number; // 학번 char name[20]; // 이름 double grade; // 평점 }; int main(void) { // 구조체를 배열 원소로 가지는 배열 정의 struct student arr[SIZE] = { {20110010, "KIM", 4.22}, {20110011, "LEE", 3.56}, {20110012, "PARK", 4.34} }; struct student st; // 구조체 st 선언 FILE *fp = NULL; // 파일 포인터 선언과 초기화 int i; // 바이너리 파일 쓰기 모드로 열기 if((fp = fopen("student.dat", "wb")) == NULL) { fprintf(stderr, "파일을 열 수 없습니다."); exit(1); } // arr 배열의 내용을 파일 포인터 fp에 저장 fwrite(arr, sizeof(struct student), SIZE, fp); fclose(fp); // 바이너리 파일 읽기 모드로 열기 if((fp = fopen("student.dat", "rb")) == NULL) { fprintf(stderr, "파일을 열 수 없습니다."); exit(1); } // 파일 포인터 fp에 저장되어 있는 항목 하나씩 읽어오기 for(i = 0; i < SIZE; i++) { fread(&st, sizeof(struct student), 1, fp); printf("학번:%d,이름:%s,평점:%f\n", st.number, st.name, st.grade); } fclose(fp); return 0; }

[소스 코드]

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53	#include <stdio.h> #include <stdlib.h> #define SIZE 1000 void init_arr(int arr[], int size); int main(void) { int arr[SIZE]; int n, data; long pos; FILE *fp; // 배열을 초기화한다. init_arr(arr, SIZE); // 바이너리 파일을 쓰기 모드로 연다. if((fp = fopen("fssek.dat", "wb")) == NULL) { fprintf(stderr, "파일을 열 수 없습니다.\n"); exit(1); } // 배열을 바이너리 모드로 파일에 저장한다. fwrite(arr, sizeof(int), SIZE, fp); fclose(fp); // 바이너리 파일을 읽기 모드로 연다. if((fp = fopen("fssek.dat", "rb")) == NULL) { fprintf(stderr, "파일을 열 수 없습니다.\n"); exit(1); } while(1) { printf("위치를 입력하세요(0부터 %d, 종료: -1): ", SIZE - 1); scanf("%d", &n); if(n == -1) { break; } pos = (long) (n * sizeof(int)); fseek(fp, pos, SEEK_SET); // pos 위치로 위치 표시자 이동 fread(&data, sizeof(int), 1, fp); printf("%d 위치의 값은 %d입니다.\n", n, data); } fclose(fp); return 0; } // 배열 인덱스의 제곱을 저장한다. void init_arr(int arr[], int size) { int i; for(i = 0; i < size; i++) { arr[i] = i * i; } }

[13장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13	#include <stdio.h> int main(void) { int MAX = 1234; #define MAX 100 printf("MAX = %d\n", MAX); #undef MAX //#define MAX 50 printf("MAX = %d\n", MAX); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> #define SQUARE(x) ((x) * (x)) int main(void) { int x = 5; printf("%d\n", SQUARE(x)); printf("%d\n", SQUARE(3)); printf("%f\n", SQUARE(3.1)); // 실수도 적용 가능 printf("%d\n", SQUARE(x + 5)); // 수식도 적용 가능 printf("%d\n", 100 / SQUARE(x)); printf("%d\n", SQUARE(++x)); // 논리 오류 return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	#include <stdio.h> #define MACRO_1(x) \ printf("%s = %d, %d의 제곱은 %d\n", #x, x, x, ((x)*(x))) #define MACRO_2(x, y) \ printf("2개의 문자열을 ##으로 결합하면 %s\n", x ## y) #define MACRO_3(x, y, z) \ printf("3개의 정수를 ##으로 결합하면 %d\n", x ## y ## z) int main(void) { int num = 9; MACRO_1(num); MACRO_2("C ", "Language!"); MACRO_3(1, 2, 3); return 0; }

[main.c]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> #include "plus.h" int main(void) { int x, y; printf("x값을 입력하세요: "); scanf("%d", &x); printf("y값을 입력하세요: "); scanf("%d", &y); printf("%d + %d = %d\n", x, y, plus(x, y)); return 0; }

[plus.c]

1 2 3 4 5 6 7 8	#include "plus.h" int plus(int x, int y) { int result; result = x + y; return result; }

[plus.h]

1 2 3 4 5	#ifndef PLUS_H #define PLUS_H int plus(int x, int y); #endif

[소스 코드]

1 2 3 4 5 6 7 8 9 10	#include <stdio.h> int main(int argc, char *argv[]) { int i; for(i = 0; i < argc; i++) { printf("명령라인에서 %d번째 문자열은 %s입니다.\n", i, argv[i]); } return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21	#include <stdio.h> int main(void) { int x = 12; // 1100 int y = 6; // 0110 int result; result = x & y; // 0100 printf("%d & %d = %08x(%d)\n", x, y, result, result); result = x | y; // 1110 printf("%d | %d = %08x(%d)\n", x, y, result, result); result = x ^ y; // 1010 printf("%d ^ %d = %08x(%d)\n", x, y, result, result); result = ~x; // 0011 printf("~%d = %08x(%d)\n", x, result, result); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	#include <stdio.h> int main(void) { int x = 10; int y = 2; int result; result = x << y; printf("%d << %d = %08x(%d)\n", x, y, result, result); result = x >> y; printf("%d >> %d = %08x(%d)\n", x, y, result, result); return 0; }

[14장]

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	#include <stdio.h> #include <stdlib.h> int main(void) { int *ptr; // 동적 메모리의 시작 주소를 가리키는 포인터 선언 ptr = (int *)malloc(sizeof(int)); // ① 동적 메모리 할당 if(ptr == NULL) { // 반환값이 NULL인지 검사 printf("동적 메모리 할당 오류\n"); exit(1); } *ptr = 1000; // ② 동적 메모리에 정수값 1000을 저장 printf("%d\n", *ptr); // 동적 메모리에 저장된 값 출력 free(ptr); // ③ 동적 메모리 반납 return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	#include <stdio.h> #include <stdlib.h> int main(void) { char *ptr = NULL; ptr = (char *)malloc(sizeof(char)); // 동적 메모리 할당 if(ptr == NULL) { printf("동적 메모리 할당 오류\n"); exit(1); } *ptr = 'c'; printf("*ptr = %c\n", *ptr); free(ptr); // 동적 메모리 반납 return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24	#include <stdio.h> #include <stdlib.h> int main(void) { char *ptr = NULL; int i; ptr = (char *)malloc(sizeof(char) * 100); // 동적 메모리 할당 if(ptr == NULL) { printf("동적 메모리 할당 오류\n"); exit(1); } for(i = 0; i < 26; i++) { *(ptr + i) = 'A' + i; // 알파벳 대문자를 순서대로 저장 } *(ptr + i) = 0; // 널 문자 추가(문자열의 끝은 널 문자) printf("%s\n", ptr); free(ptr); // 동적 메모리 반납 return 0; }

[소스 코드]

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	#include <stdio.h> #include <stdlib.h> int main(void) { int *ptr = NULL; int i; ptr = (int *)malloc(sizeof(int) * 4); // 동적 메모리 할당 if(ptr == NULL) { printf("동적 메모리 할당 오류\n"); exit(1); } ptr[0] = 10; // *(ptr + 0) = 10;과 같다. ptr[1] = 20; // *(ptr + 1) = 20;과 같다. ptr[2] = 30; // *(ptr + 2) = 30;과 같다. ptr[3] = 40; // *(ptr + 3) = 40;과 같다. for(i = 0; i < 4; i++) { printf("*(ptr + %d) = %d\n", i, *(ptr + i)); } free(ptr); // 동적 메모리 반납 return 0; }

[소스 코드]

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51	#include <stdio.h> #include <stdlib.h> #include <string.h> struct BOOK { int number; char title[100]; char writer[100]; }; int main(void) { struct BOOK *ptr; int i; ptr = (struct BOOK *)malloc(sizeof(struct BOOK) * 5); if(ptr == NULL) { printf("동적 메모리 할당 오류\n"); exit(1); } ptr->number = 1; strcpy(ptr->title, "CentOS 리눅스 구축관리 실무"); strcpy(ptr->writer, "김태용"); (ptr + 1)->number = 2; strcpy((ptr + 1)->title, "gcc로 공부하는 C++ 프로그래밍"); strcpy((ptr + 1)->writer, "김태용"); (ptr + 2)->number = 3; strcpy((ptr + 2)->title, "리눅스 쉘 스크립트 프로그래밍 입문"); strcpy((ptr + 2)->writer, "김태용"); (ptr + 3)->number = 4; strcpy((ptr + 3)->title, "김태용의 JSP 웹 프로그래밍 입문"); strcpy((ptr + 3)->writer, "김태용"); (ptr + 4)->number = 5; strcpy((ptr + 4)->title, "김태용의 C 언어 프로그래밍 입문"); strcpy((ptr + 4)->writer, "김태용"); for(i = 0; i < 5; i++) { printf("번호: %d\n", (ptr + i)->number); printf("책 제목: %s\n", (ptr + i)->title); printf("책 저자: %s\n", (ptr + i)->writer); printf("=====\n"); } free(ptr); return 0; }

[소스 코드]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24	#include <stdio.h> #include <stdlib.h> int main(void) { int *ptr = NULL; int i; ptr = (int *)calloc(4, sizeof(int)); // 동적 메모리 할당 if(ptr == NULL) { printf("동적 메모리 할당 오류\n"); exit(1); } ptr[0] = 10; // *(ptr + 0) = 10;과 같다. ptr[1] = 20; // *(ptr + 1) = 20;과 같다. for(i = 0; i < 4; i++) { printf("*(ptr + %d) = %d\n", i, *(ptr + i)); } free(ptr); // 동적 메모리 반납 return 0; }

[소스 코드]

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	#include <stdio.h> #include <stdlib.h> int main(void) { int *ptr = NULL; int i; ptr = (int *)malloc(sizeof(int) * 4); // 동적 메모리 할당 if(ptr == NULL) { printf("동적 메모리 할당 오류\n"); exit(1); } ptr[0] = 10; // *(ptr + 0) = 10;과 같다. ptr[1] = 20; // *(ptr + 1) = 20;과 같다. ptr[2] = 30; // *(ptr + 2) = 30;과 같다. ptr[3] = 40; // *(ptr + 3) = 40;과 같다. ptr = (int *)realloc(ptr, sizeof(int) * 8); for(i = 0; i < 8; i++) { printf("*(ptr + %d) = %d\n", i, *(ptr + i)); } free(ptr); // 동적 메모리 반납 return 0; }

[소스 코드]

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51	#include <stdio.h> #include <stdlib.h> #include <string.h> #define SIZE_NAME 102 #define SIZE_PHONE 102 #define MAX_PHONEBOOK 10 struct phonebook { int number; char name[SIZE_NAME]; char phone[SIZE_PHONE]; }; int main(void) { struct phonebook arr[MAX_PHONEBOOK]; // 구조체 배열 사용 char str[SIZE_NAME]; // 입력 문자를 저장할 char형 배열 선언 int num = 0, i; printf("[전화번호부를 만듭니다. 해당 정보를 입력해주세요.]\n"); while(num < MAX_PHONEBOOK) { printf("이름을 입력하세요.(q 입력 시 종료): "); fgets(str, SIZE_NAME, stdin); // new line을 NULL로 교체 str[strlen(str) - 1] = '\0'; if(str[0] == 'q') { break; } arr[num].number = num + 1; strcpy(arr[num].name, str); printf("휴대폰 번호를 입력하세요.: "); fgets(str, SIZE_NAME, stdin); // new line을 NULL로 교체 str[strlen(str) - 1] = '\0'; strcpy(arr[num].phone, str); num++; printf("=====\n"); } printf("\n"); for(i = 0; i < num; i++) { printf("번호: %d\n", arr[i].number); printf("이름: %s\n", arr[i].name); printf("휴대폰번호: %s\n", arr[i].phone); printf("=====\n"); } return 0; }

[소스 코드]

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

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

#include <stdio.h>

#include <stdlib.h>

typedef struct node {

int number;

struct node *link;

} NODE;

int get_total(NODE *ptr_head);

void print_all(NODE *ptr_head);

NODE *search_node(NODE *ptr_head, int pos);

NODE *search_last(NODE *ptr_head);

NODE *search_prev(NODE *ptr_head, int pos);

NODE *append_node(NODE *ptr_head, NODE *ptr_new);

NODE *insert_node(NODE *ptr_head, NODE *ptr_prev, NODE *ptr_new);

NODE *delete_node(NODE *ptr_head, NODE *ptr_prev, NODE *ptr_curr);

NODE *reverse_node(NODE *ptr_head);

int main(void) {

NODE *ptr_head = NULL;

NODE *ptr_new = NULL;

ptr_new = (NODE *)malloc(sizeof(NODE));

ptr_new->number = 10;

ptr_new->link = NULL;

ptr_head = append_node(ptr_head, ptr_new);

ptr_new = (NODE *)malloc(sizeof(NODE));

ptr_new->number = 20;

ptr_new->link = NULL;

ptr_head = append_node(ptr_head, ptr_new);

ptr_new = (NODE *)malloc(sizeof(NODE));

ptr_new->number = 30;

ptr_new->link = NULL;

ptr_head = append_node(ptr_head, ptr_new);

ptr_new = (NODE *)malloc(sizeof(NODE));

ptr_new->number = 40;

ptr_new->link = NULL;

ptr_head = append_node(ptr_head, ptr_new);

ptr_new = (NODE *)malloc(sizeof(NODE));

ptr_new->number = 50;

ptr_new->link = NULL;

ptr_head = insert_node(ptr_head, search_prev(ptr_head, 3), ptr_new);

// 삭제 함수, 검색 함수들을 사용

// ptr_head = delete_node(ptr_head, search_prev(ptr_head, 4), search_node(ptr_head, 4));

print_all(ptr_head);

printf("\n[역순 정렬]\n");

reverse_node(ptr_head);

return 0;

}

int get_total(NODE *ptr_head) {

int total = 0;

NODE *ptr_curr = ptr_head;

while (ptr_curr != NULL) {

total++;

ptr_curr = ptr_curr->link;

}

return total;

}

void print_all(NODE *ptr_head) {

int num = 1;

NODE *ptr_curr = ptr_head;

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

printf("번호\t 주소\t 데이터 필드\t 링크 필드\n");

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

while (ptr_curr != NULL) {

printf("  %d\t%x\t     %d\t\t   %x\n",

num++, ptr_curr, ptr_curr->number, ptr_curr->link);

ptr_curr = ptr_curr->link;

}

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

printf("총 %d개\n", get_total(ptr_head));

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

}

NODE *search_node(NODE *ptr_head, int pos) {

NODE *ptr_curr = ptr_head;

int i = 0;

if (pos > 0 && pos <= get_total(ptr_head)) {

for(i = 1; i < pos; i++) {

ptr_curr = ptr_curr->link;

}

}

return ptr_curr;

}

NODE *search_last(NODE *ptr_head) {

NODE *ptr_last = ptr_head;

if (ptr_head == NULL) {

ptr_last = ptr_head;

} else {

while(ptr_last->link != NULL) {

ptr_last = ptr_last->link;

}

}

return ptr_last;

}

NODE *search_prev(NODE *ptr_head, int pos) {

int i;

NODE *ptr_prev = ptr_head;

if (pos <= 1) {

ptr_prev = NULL;

} else if (pos > 1 && pos <= get_total(ptr_head)) {

for(i = 1; i < pos - 1; i++) {

ptr_prev = ptr_prev->link;

}

} else {

ptr_prev = search_last(ptr_head);

}

return ptr_prev;

}

NODE *append_node(NODE *ptr_head, NODE *ptr_new) {

NODE *ptr_last = NULL;

if (ptr_head == NULL) {

ptr_head = ptr_new;

} else {

ptr_last = search_last(ptr_head);

ptr_last->link = ptr_new;

}

return ptr_head;

}

NODE *insert_node(NODE *ptr_head, NODE *ptr_prev, NODE *ptr_new) {

if (ptr_prev == NULL) {

ptr_new->link = ptr_head;

ptr_head = ptr_new;

} else {

ptr_new->link = ptr_prev->link;

ptr_prev->link = ptr_new;

}

return ptr_head;

}

NODE *delete_node(NODE *ptr_head, NODE *ptr_prev, NODE *ptr_curr) {

if (ptr_prev == NULL) {

ptr_head = ptr_curr->link;

} else {

ptr_prev->link = ptr_curr->link;

}

free(ptr_curr);

return ptr_head;

}

NODE *reverse_node(NODE *ptr_head) {

NODE *ptr_prev, *ptr_curr, *ptr_next;

ptr_prev = NULL;

ptr_next = NULL;

ptr_curr = ptr_head;

if (ptr_head == NULL) {

puts("** 노드가 비어있습니다 **");

getchar();

exit(1);

}

while (ptr_curr != NULL) {

ptr_next = ptr_curr->link;

ptr_curr->link = ptr_prev;

ptr_prev = ptr_curr;

ptr_curr = ptr_next;

}

ptr_head = ptr_prev;

print_all(ptr_head);

return ptr_head;

}

[소스 코드]

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

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

/*

C 언어 - 구조체를 사용하는 링크드 리스트

[전화번호부 예제]

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define SIZE_NAME 102

#define SIZE_PHONE 102

typedef struct node {

char name[SIZE_NAME]; // 이름

char phone[SIZE_PHONE]; // 휴대폰 번호

struct node *link; // 자기참조구조체

} NODE;

NODE *ptr_head = NULL; // 헤더 포인터

void init(void);

int show_menu(void);

void init_node(char *name, char *phone);

void append_node(void);

void display_all(void);

void insert_node(void);

void delete_node(void);

void search_node(void);

void reverse_node(void);

int get_total(void);

int main(void) {

init();

while(1) {

switch(show_menu()) {

case 1:

append_node();

break;

case 2:

display_all();

puts("\t** 엔터키를 누르세요 **");

getchar();

break;

case 3:

insert_node();

break;

case 4:

delete_node();

break;

case 5:

search_node();

getchar();

break;

case 6:

reverse_node();

break;

case 7:

puts("프로그램을 종료하였습니다.");

return 0;

default :

puts("메뉴 번호를 잘못 선택하셨습니다!");

break;

}

}

return 0;

}

int show_menu(void) {

int num = 0;

char str[12];

#if defined(_WIN32) || defined(_WIN64)

system("cls");

#elif defined(linux)

system("clear");

#endif

puts("========== [전화번호부 메뉴] ==========");

puts("\t1. 추가하기[Append data to the end]");

puts("\t2. 출력하기[Display all]");

puts("\t3. 삽입하기[Insert data]");

puts("\t4. 삭제하기[Delete data]");

puts("\t5. 검색하기[Search data]");

puts("\t6. 역순으로 정렬하기[Reverse list]");

puts("\t7. 종료하기[Quit]");

puts("=======================================");

printf("[현재 총 %d개의 자료가 저장되어 있습니다.]\n", get_total());

printf("# 메뉴 번호 선택 [   ]\b\b\b");

fgets(str, sizeof(str) / sizeof(char), stdin);

// new line을 NULL로 교체

str[strlen(str) - 1] = '\0';

num = atoi(str);

return num;

}

void init(void) {

// 3개의 초기 자료 입력

init_node("홍길동", "010-0000-0000");

init_node("김길동", "010-1111-1111");

init_node("박길동", "010-2222-2222");

}

void init_node(char *name, char *phone) {

NODE *ptr_curr = ptr_head;

// 마지막 노드에 추가될 구조체 자료 생성

// 마지막 노드는 항상 링크 필드가 NULL이다.

NODE *ptr_new = (NODE *)malloc(sizeof(NODE));

strcpy(ptr_new->name, name);

strcpy(ptr_new->phone, phone);

ptr_new->link = NULL;

if (ptr_head == NULL) {

ptr_head = ptr_new;

} else {

while(ptr_curr->link != NULL) {

ptr_curr = ptr_curr->link;

}

ptr_curr->link = ptr_new;

}

}

void append_node(void) {

NODE *ptr_curr = ptr_head;

// 마지막 노드에 추가될 구조체 자료 생성

// 마지막 노드는 항상 링크 필드가 NULL이다.

NODE *ptr_new = (NODE *)malloc(sizeof(NODE));

ptr_new->link = NULL;

printf("이름을 입력하세요. : ");

fgets(ptr_new->name, SIZE_NAME, stdin);

// new line을 NULL로 교체

ptr_new->name[strlen(ptr_new->name) - 1] = '\0';

printf("휴대폰 번호를 입력하세요. : ");

fgets(ptr_new->phone, SIZE_PHONE, stdin);

// new line을 NULL로 교체

ptr_new->phone[strlen(ptr_new->phone) - 1] = '\0';

if (ptr_head == NULL) {

ptr_head = ptr_new;

} else {

while(ptr_curr->link != NULL) {

ptr_curr = ptr_curr->link;

}

ptr_curr->link = ptr_new;

}

}

void display_all(void) {

NODE *ptr_curr = ptr_head;

int i = 1;

puts("\t     \t[전화번호부 목록]");

puts("\t-------------------------------");

puts("\t [no]\t [이름]\t [휴대폰 번호]");

puts("\t-------------------------------");

while(ptr_curr != NULL) {

printf("\t %d\t %s\t %s \n", i++, ptr_curr->name, ptr_curr->phone);

ptr_curr = ptr_curr->link;

}

puts("\t-------------------------------");

printf("\t[총 %d개]\n", get_total());

}

void insert_node(void) {

int pos;

NODE *ptr_curr = ptr_head;

NODE *ptr_new = (NODE *)malloc(sizeof(NODE));

display_all();

while(1) {

printf("\n삽입할 번호는(입력 번호 이전에 삽입됨) : ");

scanf("%d",&pos);

getchar();

if(pos > 0 && pos <= get_total()) {

printf("이름을 입력하세요 : ");

fgets(ptr_new->name, SIZE_NAME, stdin);

// new line을 NULL로 교체

ptr_new->name[strlen(ptr_new->name) - 1] = '\0';

printf("휴대폰 번호를 입력하세요 : ");

fgets(ptr_new->phone, SIZE_PHONE, stdin);

// new line을 NULL로 교체

ptr_new->phone[strlen(ptr_new->phone) - 1] = '\0';

if(pos == 1) {

ptr_new->link = ptr_curr;

ptr_head = ptr_new;

} else {

int i;

for(i = 1; i < pos - 1; i++) {

ptr_curr = ptr_curr->link;

}

ptr_new->link = ptr_curr->link;

ptr_curr->link = ptr_new;

}

break;

} else {

puts("잘못 입력하셨습니다. 다시 입력해주세요!");

continue;

}

}

}

void delete_node(void) {

NODE *ptr_curr = ptr_head;

int pos;

if(ptr_head == NULL) {

puts("** 노드가 비어있습니다 **");

getchar();

return;

}

display_all();

while(1) {

printf("삭제할 번호[no]는 : ");

scanf("%d",&pos);

if(pos > 0 && pos <= get_total()) {

if(pos == 1) {

ptr_head = ptr_curr->link;

free(ptr_curr);

} else {

int i = 0;

NODE *temp;

for(i = 1; i < pos - 1; i++) {

ptr_curr = ptr_curr->link;

}

temp = ptr_curr->link;

ptr_curr->link = ptr_curr->link->link;

free(temp);

}

break;

} else {

puts("잘못 입력하셨습니다. 다시 입력해주세요!");

continue;

}

}

}

void search_node(void) {

NODE *ptr_curr = ptr_head;

char name[SIZE_NAME];

int found = 0;

if(ptr_head == NULL) {

puts("** 노드가 비어있습니다 **");

getchar();

return;

}

printf("검색할 이름을 입력하세요 : ");

fgets(name, SIZE_NAME, stdin);

// new line을 NULL로 교체

name[strlen(name) - 1] = '\0';

while(ptr_curr != NULL) {

if(strcmp(name, ptr_curr->name) == 0) {

found = 1;

printf("\n%s님의 휴대폰 번호는 %s입니다.\n",

ptr_curr->name, ptr_curr->phone);

puts("\t** 엔터키를 누르세요 **");

}

ptr_curr = ptr_curr->link;

}

if(!found) {

puts("** 존재하지 않습니다!! **");

}

}

void reverse_node(void) {

NODE *ptr_prev, *ptr_curr, *ptr_next;

ptr_prev = NULL;

ptr_next = NULL;

ptr_curr = ptr_head;

if(ptr_head == NULL) {

puts("** 노드가 비어있습니다 **");

getchar();

return;

}

while(ptr_curr != NULL) {

ptr_next = ptr_curr->link;

ptr_curr->link = ptr_prev;

ptr_prev = ptr_curr;

ptr_curr = ptr_next;

}

ptr_head = ptr_prev;

display_all();

puts("\t** 엔터키를 누르세요 **");

getchar();

}

int get_total(void) {

NODE *ptr_curr = ptr_head;

int total = 0;

while(ptr_curr != NULL) {

ptr_curr = ptr_curr->link;

total++;

}

return total;

}

[소스 코드]

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

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

#include <stdio.h>

#include <stdlib.h>

int is_full();

int is_empty();

void print_full();

void print_empty();

int push(int item);

int pop();

int top; // 스택의 최상단 원소 인덱스

const int max = 10; // 변수의 상수화

int *stack; // 스택 포인터(int형 배열)

int main(void) {

int i;

stack = (int *)malloc(sizeof(int) * max);

if (stack == NULL) {

printf("Error: Out Of Memory\n");

exit(-1);

}

printf("스택에 입력되는 순서: ");

for (i = 0; i <= max - 1; i++) {

printf("%d ", push(i));

}

printf("\n스택에서 삭제되는 순서: ");

for (i = 0; i <= max - 1; i++) {

printf("%d ", pop());

}

printf("\n");

return 0;

}

int is_full() { // 스택이 가득 차서 넘치는지 검사

if (top > max - 1) {

return 1; // 참

} else {

return 0; // 거짓

}

}

int is_empty() { // 스택이 비어 있는지 검사

if (top == -1) {

return 1; // 참

} else {

return 0; // 거짓

}

}

void print_full() { // 스택이 가득 차 있음을 알림

printf("Stack is Full\n");

exit(-1);

}

void print_empty() { // 스택이 비어 있음을 알림

printf("Stack is Empty\n");

exit(-1);

}

int push(int item) { // 스택의 top에 정수값 삽입

if (is_full()) {

print_full();

} else {

return stack[++top] = item;

}

}

int pop() { // 스택의 top에 있는 정수값 삭제 및 반환

if (is_empty()) {

print_empty();

}

return stack[top--];

}

[소스 코드]

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

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

#include <stdio.h>

#include <stdlib.h>

typedef int DATA;

typedef struct stack_node {

DATA data;

struct stack_node *link;

} NODE;

NODE *top;

void print_empty(void);

DATA push(DATA data);

DATA pop(void);

void del(void);

int main(void) {

int i;

printf("스택에 입력되는 순서: ");

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

printf("%c", push('a' + i));

}

printf("\n");

printf("스택에서 삭제되는 순서: ");

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

printf("%c", pop());

}

del();

printf("\n");

return 0;

}

void print_empty(void) {

printf("Stack is Empty\n");

exit(-1);

}

DATA push(DATA data) {

NODE *temp;

temp = (NODE *)malloc(sizeof(NODE));

if (!temp) {

printf("동적 메모리 할당 오류!\n");

}

temp->data = data;

temp->link = top;

top = temp;

return top->data;

}

DATA pop(void) {

NODE *ptr = top;

DATA ret_value;

if (top == NULL) {

print_empty();

}

ret_value = top->data; // top 노드의 data 필드 얻기

top = ptr->link; // top 노드 제거

free(ptr); // 이전 top 노드가 사용했던 메모리 공간 반환

return ret_value; // 데이터 값 반환

}

void del(void) {

NODE *ptr;

while (top) {

ptr = top;

top = top->link;

free(ptr);

}

}

[소스 코드]

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51	#include <stdio.h> #include <stdlib.h> #include <ctype.h> #define MAX 100 int queue[MAX]; int front = -1, rear = -1; void insert(int x); int del(void); int main(void) { int i, count = 0; char temp[MAX], *ptr; printf("큐 입력: "); gets(temp); ptr = temp; while(*ptr != '\0') { insert(*ptr); *ptr++; count++; } printf("큐 삭제 순서: "); for (i = 0; i < count; i++) { printf("%c", del()); } printf("\n"); return 0; } void insert(int x) { if (rear == MAX - 1) { printf("\nQueue Full!\n"); exit(-1); } else { queue[++rear] = x; } } int del(void) { if (front == rear) { printf("\nQueue Empty!\n"); exit(-1); } else { return queue[++front]; } }

[소스 코드]

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

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

typedef int DATA;

typedef struct queue_node {

DATA data;

struct queue_node *link;

} NODE;

struct queue {

NODE *front;

NODE *rear;

} q;

void print_empty(void);

DATA insert(DATA d);

DATA del(void);

int main(void) {

int i;

printf("큐에 입력되는 순서: ");

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

printf("%c", insert('a' + i));

}

printf("\n큐에서 삭제되는 순서: ");

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

printf("%c", del());

}

printf("\n");

return 0;

}

void print_empty(void) {

printf("Queue is Empty!\n");

exit(-1);

}

DATA insert(DATA d) {

NODE *temp;

temp = (NODE *)malloc(sizeof(NODE));

if (!temp) {

printf("동적 메모리 할당 오류!\n");

exit(-1);

}

temp->data = d;

temp->link = NULL;

if (q.front == NULL) {

q.front = q.rear = temp;

} else {

q.rear = q.rear->link = temp; // 새로운 노드 추가, rear 값 변경

}

return q.rear->data;

}

DATA del(void) {

// 큐 내에 있는 첫 번째 노드를 삭제하고, 그 자료를 반환

DATA ret_value;

NODE *ptr;

if (q.front == NULL) {

print_empty();

}

ptr = q.front;

ret_value = q.front->data; // data를 얻어온다.

q.front = ptr->link; // 첫 번째 노드를 제거

free(ptr); // 이전 front 노드가 사용하던 메모리 공간을 반납

return ret_value;

}