Embed Size (px)
Citation preview
C 언어 강의교재
(2003년 2학기)
2003. 8
목 차 page
서 문
제Ⅰ장 C 언어 개요 1
제Ⅱ장 프로그램의 구성요소 9
제Ⅲ장 자료 형태와 입출력 함수 13
제Ⅳ장 배열(Array)과 포인터(Pointer) 19
제Ⅴ장 함수(Function) 23
제Ⅵ장 파일의 입출력 31
제Ⅶ장 연산자와 조건문 36
제Ⅷ장 제어문 46
제Ⅸ장 C++ 프로그래밍 기초 54
부 록 A. 연산자 71
B. 입출력 함수 72
C. 제어문 73
제I장
1.
2.
3.
가)
C 언어 개요
C 언어의 역사
• 1960년 유럽에서 ALGOrithmic Language (ALGOL) 발표
• 1963년 영국 Cambridge 대학과 London 대학에서 Combined
Programming Language (CPL) 개발
• 1967년 Cambridge 대학의 Martin Richard 가 Basic CPL(BCPL) 개발
• 1970년 AT&T Bell Lab.의 Ken Tompson 이 B language 개발
• 1972년 AT&T Bell Lab.의 Dennis Ritchie 가 C language 개발
• 1980년 미국 벨연구소의 Bjarne Stroustrup박사 Object Oriented
Programming (OOP) 개념을 추가한 “C with class” 개발하였고
1983년부터 “C++” 명칭 사용 시작
C 언어의 특징
• Unix 운영체제를 위해 만들어진 이후 시스템, 문서 및 파일 작성/처리,
수식계산, 그래픽, 데이터 베이스 등 모든 용도에 사용되는 만능 언어
• 고급언어와 기계제어가 가능한 저급언어의 특성을 모두 갖춘 언어
• 함수로 구성되어 프로그램의 오류추적과 수정이 용이한 구조화된 언어
• 사용자에 많은 자유가 보장되고 확장이 용이한 언어
• 프로그램의 물리적인 크기가 작고 계산속도가 빠른 언어
• CPU, OS 등에 구애 받지 않고 다른 시스템에서도 거의 그대로 사용할
수 있는 이식성이 강한 언어
• 프로그램의 조작 대상이 되는 데이터(객체)의 기능과 의미를
중요시하는 기능이 보강된 C++는 C를 모두 포함하는 상위 객체 지향
언어
프로그래밍 언어의 발전
1세대 언어 : Machine Language
컴퓨터가 직접 이해할 수 있는 binary code 와 byte 로 구성되며
1
논리/수치/문자 등의 연산과 함께 기계적인 입출력/저장위치 등을
모두 표현 가능. 기계 자체의 언어이므로 번역할 필요가 없어
수행시간이 빠름.
나)
다)
라)
4.
2세대 언어 : Assembly Language
기계어의 프로그래밍 시간을 줄이고 오류를 찾기 쉽도록 3-4 글자의
약어로 구성된 단일명령어(mv, add, read, write, put 등)를 조합한
프로그래밍 언어
3세대 언어 : Procedural Language
문제를 해결하기 위한 논리적인 절차를 구체적으로 표현가능한 절차
중심의 언어로서 source code를 컴퓨터가 인식할 수 있는 object
code로 변환시키기 위한 compile 과정을 필요로 한다. 영어와
유사한 명령어를 사용함에 따라 프로그래밍이 쉽고 오류를 찾기
쉽지만 기계적인 제어에 약점이 있다. ( 표1. 제3세대 언어의 종류
참조 )
4세대 언어 : 4GL , Nonprocedural Language
반복적인 절차가 미리 프로그래밍되어 메뉴 또는 단축 키 입력과
같이 입력절차를 단순화 시킨 언어이다. 배우기 쉽고 프로그램
개발시간이 단축되나, 언어 자체에 필요한 Resource Size 가 큰
단점이 있다. ( 예: C++, JAVA, Delphi )
프로그래밍 언어의 요구조건
• 언어의 구조와 개념이 단순하고 명료해야 함
• 언어의 개념이 확장성이 있어야 함
• 신뢰성이 있어야 함
• 다른 기종과 호환이 돼야 하며, 다른 언어에 쉽게 이식성이 있어야 함
• 추상을 지원할 수 있어야 하고, 검증하기 쉬워야 함
• 작성비용, 번역비용, 실행비용, 운영 및 유지 보수 등 각종 비용이 적게
들어야 함
2
표1. 제3세대 언어의 종류
FOTRAN 과학기술용 언어. FORTRAN Ⅳ → FORTRAN 77로 발전
ALGOL60 최초의 블록 중심언어로 수치 자료와 동질의 배열을 강조한 과학 계산용
언어
COBOL 인사, 자재, 판매, 회계, 생산관리 등에 주로 사용되는 상업용 자료처리
언어. 영어 문장 형태로 프로그램을 작성하므로 프로그램 작성이 쉬움.
LISP 인공 지능 분야에 사용되는 언어. 프로그램과 자료를 동일하게 표현하는
새로운 개념이 도입됨.
PL/I FORTRAN, COBOL, ALGOL 등의 장점을 포함하려고 시도한 범용언어
SNOBOL4 어떤 기계에도 종속되지 않는 매크로 언어를 가진 인터프리터 형 언어
APL 배열을 기본요소로 하여 배열 자체의 연산을 지원하는 언어
BASIC Beginner's All-purpose Symbolic Instruction Code의 약어. 초보자들이
배우기 쉬운 언어로, 대화형 인터프리터 언어
PASCAL 학생들에게 쉽게 프로그래밍 언어를 가르치기 위한 언어. 구조화
프로그래밍을 가능하게 하는 언어로 교육용 언어로 많이 쓰임.
C UNIX 운영체제를 위해 개발한 시스템 프로그램 언어. CPL → BCPL → B
→ C 로 발전함. 저급언어와 고급언어의 특징을 모두 갖춘 언어.
3
5. 프로그램 작성절차
문제 분석 → 입출력 설계 → 순서도 작성 → 프로그램 코딩 → 번역
→ 문법오류 →검사 → 논리오류 →실행 → 평가 및 문서화
• 문제 분석 : 프로그램을 작성할 때 발생되는 제안 문제를 분석
• 입출력 설계 : 입출력에서 사용될 매체의 선정
• 순서도 작성 : 프로그램이 수행될 절차를 정해진 기호에 의해 작성
• 프로그램 코딩 : 순서도를 참고하여 용지에 프로그램을 작성
• 프로그램 입력 : 코딩한 용지를 보고, 컴퓨터에 입력(원시 프로그램)
• 번역 및 오류 체크 : 원시 프로그램을 기계어로 번역하고, 문법오류(syntax
error)를 체크
• 검사 : 가상 데이터를 입력하여 원하는 결과가 나오는지를 체크(논리적
오류를 체크)
• 실행 : 실제 데이터를 입력하여 실행
• 평가 및 문서화 : 만족도를 평가하고 문서화함
6.
가)
프로그래밍 언어의 번역과 번역기
프로그래밍 언어의 일반적인 번역 과정
원시 프로그램 목적 프로그램 로드 모듈 실행
(컴파일러) (링크) (로더)
• 원시 프로그램 (source program) : 사용자가 각종 프로그램 언어로 작성한
프로그램
• 목적 프로그램 (object program) : 번역기에 의해 기계어로 번역된 상태의
프로그램
• 로드 모듈 (load module) : Linkage Editor에 의해 실행 가능한 상태로 된
모듈
4
나) 번역기의 종류
종 류 내 용
컴파일러
(Compiler)
사용자가 고급언어로 작성한 프로그램을 기계가 이해할 수
있는 2 진수 기계어로 번역해 주는 번역기
어셈블러
(Assembler)
어셈블리 언어로 작성한 프로그램을 기계어로 번역해 주는
번역기
링커
(Linker)
기계어로 번역된 목적 프로그램을 실행 프로그램
라이브러리를 이용하여 실행 가능한 형태의 로드 모듈로
번역하는 번역기
로더 (Loader) 로드 모듈을 수행하기 위해 메모리에 적재시켜 주는 기능을
수행
인터프리터
(Interpreter)
고급언어나 코드화된 중간 언어를 입력 받아 목적 프로그램
생성 없이 직접 기계어를 생성, 실행해주는 프로그램
목적 프로그램이 존재하지 않아 매번 다시 번역해야 하므로
수행시간이 느린 반면 기억장소가 절약됨
크로스컴파일러
(Cross Compiler)
원시 프로그램을 다른 컴퓨터의 기계어로 번역하는
프로그램
전처리기
(Preprocessor)
원시 프로그램을 번역하기 전에 미리 언어의 기능을 확장한
원시 프로그램을 생성시켜 주는 시스템 프로그램
(예) C 언어의 #include 문
5
7.
가)
순서도 작성
순서도의 종류
시스템
(System)
순서도
시스템 전반에 걸친 내용을 자료의 흐름과 입출력에 중점을 두어
총괄적으로 나타낸 것
프로그램
(Program)
순서도
프로그램을 작성하기 전에 처리과정에 중점을 두어 작성하는
순서도
개략(general) 순서도 : 프로그램 전체의 흐름이 한눈에 파악될 수
있도록 개략적으로 표현한 것
상세(detail) 순서도 : 코딩하기 직전에 작성되는 것으로, 개략
순서도의 세부사항까지 나타낸 순서도
나) 순서도 기호
기 호 명 칭 의 미
터미널 순서도의 시작과 끝을 표시
준비 배열선언 및 초기 설정에 사용
흐름선 (Flow-line) 순서도 기호간 연결 및 흐름을 표시
반복 (Loop) 반복 수행
6
자기디스크 자기디스크를 매체로 사용
종이테이프 종이테이프를 정렬 할 때 사용
분류 (Sort) 데이터를 정렬할 때 사용
표시 (Display) 화면으로 출력
수작업 Off-line 작업
통신 통신회선으로 접속
온라인(On-line) 기억 온라인 보조기억장치
입출력 데이터의 입출력시 사용
비교, 판단
비교 및 판단에 의한 논리적 분기를
할 경우 사용
결합 같은 페이지에서 순서도 흐름을 연결
서브루틴 서브프로그램 처리
자기테이프 자기테이프 매체로 사용
7
펀치 카드 카드를 매체로 사용
조합 (Merge) 여러 개의 파일을 하나로 합침
수작업 입력 콘솔(Console)에 의한 입력
페이지 결합
순서도 흐름이 다른 페이지로 연결될
경우 사용
주석 주석이나 설명을 표시
오프라인 (Off-line)기억 오프라인 기억장치
8
제II장
1.
프로그램의 구성요소
일반적인 형태
C 프로그램의 일반적인 형태는 함수 main( )으로 시작하여 다음과 같이
중괄호 { } 속에 선언문 및 명령문을 포함한다.
#include <stdio.h> /* Header File */
main( )
{
선언문;
명령문;
명령문;
}
프로그램이란 하나의 task를 처리하는 명령문의 집합이며, 명령문은 선언적
성격, 동사적 성격의 문장으로 나뉘어 진다. 명령문은 ; (세미콜론)으로
구분하여 1라인에 한 개의 명령을 기입하거나 여러 명령을 써도 좋으나,
단어와 단어 사이는 적절히 공백을 줄 수 있다.
다음 예에서 화면에 "Beginning C-Class"라고 출력하는 프로그램을 우선
보자. 이 예에서는 변수의 선언이 없고, 화면에 문자열(string)을 출력하는
함수 printf( )를 사용하였다.
#include <stdio.h>
void main( )
{
printf("Beginning C-Class");
}
[출 력 결 과]
Beginning C-Class
9
2.
가)
나)
다)
규칙과 예약어/식별어
프로그램이란 명령문의 집합이며, 각 명령문은 영문의 알파벳과 기호를 써서
C 언어의 언어 규칙에 맞도록 작성해야 한다. 컴파일러가 언어 규칙에
맞는지를 확인하여 에러가 없는 프로그램만 정상적으로 실행시킬 수 있다.
프로그램 명령문에 사용 가능한 문자
• 영문 소문자 및 대문자 : a, b, c, ..., z, A, B, C, ..., Z(문자: letter)
• 숫자 : 0,1,2,3,4,5,6,7,8,9 (digit)
• 특수 기호 : + - / = ( ) { } < > " ' [ ] ! # $ % & _ | ^ ~ \ . ; : ?
• 기타 : blank, tab 및 new line ( 이 것들을 white space라고 함 )
이러한 문자 들로서 C 프로그램의 언어 요소가 만들어진다. 언어 요소에는
변수, 함수 등을 통칭하는 식별어, 예약어, 상수, 연산자 및 분리 기호가
있다.
프로그램 코딩 규칙
코딩 규칙은 일반적으로 한 명령문이 끝날 때마다 ; (세미콜론)을 쓴다. 1개
라인은 최대 248자(Turbo C++)까지 허용되지만 프로그램을 보기 쉽게
하려면 1개 라인에 하나의 명령문에다 80자 이내로 쓰는 것이 바람직하다.
예약어
C 언어는 내장 명령으로 다음과 같은 예약어로 이루어져 있다. 예약어는
용도가 미리 정해져 있으며, 해당 용도로만 사용한다.
auto double int struct break else long switch case
enum register typedef char extern rerurn union const
float short unsigned for do while
라) 표준함수
예약어와 유사한 성격으로 고유의 기능이 있다. 예를 들면 printf(), scanf()
등 이다
10
마)
3.
식별어
원시 프로그램에서 쓰이는 예약어 이외의 변수, 함수명, 배열명 등을
지칭하는 명칭이다. 예를 들어 x = x + 1 에서 x 는 식별어로서 프로그래머가
정해 쓰는 변수명이다. 식별어의 작성 규칙은 다음과 같다.
• 첫자는 영문자 또는 ‘_’ 로 시작하며, 처음 63자까지의 문자만 식별한다.
• 영문자와 숫자를 혼용할 수 있으며, 영문자의 대문자 및 소문자는 각각
다른 변수로 인식한다.
프로그램 구조
앞에서 언급한 예에서 프로그램의 구조를 살펴보자.
#include <stdio.h>
void main( )
{
printf("Beginning C-Class");
}
• #include <stdio.h> stdio.h 라는 헤더 파일을 main 프로그램에서
사용하겠다는 의미이다. #inlcude는 전처리기(preprocessor) 명령어로서
뒤에 명시된 화일 stdio.h를 찾아 화일의 내용을 지정된 위치에
포함(include)시키라는 컴파일러 지시어이며, stdio는 standard input
output, h는 header file을 의미한다.
• main( ) C 프로그램은 여러 함수로 이루어지며, 모든 프로그램은 이
main( ) 이라는 함수를 항상 포함하여 시작된다.
• { } 둘째 줄의 { 과 마지막 줄의 }는 함수의 시작과 끝을 나타낸다.
• printf( ) printf는 C 시스템의 표준 라이브러리 함수(standard library
function)의 하나이다. 이 함수의 인수는 ( )속에 명시하고, 모든 함수가
인수를 쓰기 때문에 함수명 뒤에는 ( )를 써서, printf( )와 같이 호칭한다.
• "Beginning C-Class" 따라서 함수 printf( )의 인수는 "Beginning C-
Class"가 되며, printf는 겹따옴표 " "로 명시된 인수를 그대로 화면에
출력해 주는 함수이다.
• ; 문장의 끝에는 ;를 표하여 한 명령이 끝났음을 나타낸다. 그러나
11
main( )은 하나의 함수를 정의하는 것으로서 맨 뒤에 ‘;’ 를 붙이지
않는다.
4. 헤더 파일 (header file)
헤더 파일이란 사용자가 컴파일러에게 source code 에 정의된 함수에 대해
알려주는 파일이다.
• 표준 헤더 파일을 지정할 때는 #include <> 를 사용하고 <>안에 파일
이름을 기입한다. (예 : #include <stdio.h> )
• 헤더파일은 .h 로 끝나는 이름을 가지며, 여기에는 함수의
원형(prototype)을 정의한다. 이 부분은 함수를 배울 때 다시 언급하자.
• 표준 헤더 파일 이외에 source code와 같은 directory 에 있는 사용자
정의 헤더 파일을 사용하려면, <> 대신에 “ “ 를 사용한다. (예 :
#include “myheader.h” )
• 다른 directory 에 있는 사용자 정의 헤더 파일을 사용하려면, path 를
지정해야 한다. (예 : #include “c:\c\sample\myheader.h” )
12
제III장
1.
가)
자료 형태와 입출력 함수
변수(variable)
변수는 자료(data)를 저장하기 위한 기억 장소를 의미하며, 임의의 memory
위치에 필요한 바이트 수만큼의 공간을 확보하고 이 기억 공간을 칭하는
이름을 변수라 한다. 즉, 프로그램 안에서 특정한 자료를 나타내는 이름이다.
변수의 종류와 선언
프로그램에서 변수를 사용하기 전에 변수를 선언해 주어야 한다. 변수의
종류는 자료형에 따라 정수형, 문자형, 실수형의 3가지로 구분되며 선언하는
방법은 다음과 같다. 각 자료형에 대한 자세한 선언문 설명은 뒤에서 하자.
자료형 설명 선언 방법
정수형 정수 상수 int Number;
Number = -12;
또는 int Number = -12 ;
문자형 문자 상수
문자열은 배열로 표시함
char Letter;
Letter = ‘B’;
또는 char Letter = ‘M’;
실수형 실수 상수 float Data1 = 3.141592 ;
double Data2 = 3.141592653 ;
나) 변수 이름의 작성 방법
• 변수 이름은 영문자, 숫자, 언더스코어(underscore) ‘_’ 만을 사용한다.
• 변수 이름은 반드시 영문자 또는 언더스코어 ‘_’ 로 시작해야 한다.
• 예약어는 변수 이름으로 사용할 수 없다.
• 변수의 사용 역할에 맞고 사용자가 기억하기 편리한 이름을 사용한다.
• C 언어는 대문자와 소문자를 식별할 수 있기 때문에 변수 이름에
대문자와 소문자를 구분하여 쓴다.
13
2. 정수형
정수형 선언문 크기(bit) 범 위 비 고
int 16 - 32,768 ~ 32,767
unsigned int 16 0 ~ 65,535
short 16 - 32,768 ~ 32,767 short int
unsigned short 16 0 ~ 65,535
long 32 - 2,147,483,648
~2,147,483,647 long int
unsigned long 32 0 ~ 4,294,967,295
short는 short int와 혼용하며, long은 long int와 혼용하여 int를 생략하여
쓴다. 부호 있는(signed) 자료형은 int, short, long이며, 부호
없는(unsigned) 자료형은 unsigned int, unsigned short 및 unsigned long
형이다. 자료의 형에 따른 기본 입출력 함수 scanf( ) 와 printf( )의 입출력
지정자는 다음과 같다.
입출력 지정자 입출력 정수형 비고
%d, %I 부호 있는 정수 int, short, long
%o 부호 없는 8진수 8 진수로 변환
%u 부호 없는 정수 unsigned int, unsigned short
%x 부호 없는 16진수 0, 1, ..., 9, a, b, ..., f로 출력
%X 부호 없는 16진수 0, 1, ..., 9, A, B, ..., F로 출력
3. 실수형
25.6, -72.65, 12345.657 등과 같이 소수점이 있는 수를 실수라고 하며,
엄밀하게 말하면 소수점의 위치가 고정되지 않고 있다는 뜻으로 부동
소수점형(floating point type)을 의미한다. 기억장소의 표현은 다음의 규칙을
따른다.
14
또, 지수형으로 1.234e5는 1.234*105, 123.45E-5는 123.45*10-5 등과 같이
실수를 표시한다. 예를 들어, 123.45E-5는 0.12345E-8과 같고 전체 부호
양을 부호 자리에 기억시키는 원리가 적용된다. float 형을 기초로 하여, MS
Visual C++, Turbo C++는 다음과 같은 실수형을 제공한다. ( ANSI C도 다음
세 가지의 실수형이 있지만 표현 범위는 다르다. )
실수부 크기(bit) 범위(양수 값) 유효숫자의 수
float 32 3.4E-38~3.4E+38 7자리
double 64 1.7E-308~1.7E+308 15자리
long double 80 3.4E-4932~1.1E4932 19자리
scanf( )나 printf( )로 입출력할 때는 지정자 %f, %e, %g를 사용한다.
지정자 출력인수 비 고
%f 부호 있는 실수형 십진표기법 [-] dddd.dddd 출력
%e 부호 있는 실수형 지수표기법 [-]d.ddd...e[+/-]ddd
%g 부호 있는 실수형 출력 공간에 따라 %f 또는 %e 선택
%E,%G 부호 있는 실수형 지수표기를 대문자(E)로 출력
4. 문자형
문자형 식별어[변수]의 선언은 예약어 char를 쓴다. char형 상수나 변수는 1
byte 의 메모리를 차지한다. 문자형의 선언은 정수 int형과 같은 원리이며,
초기값 지정은 홑 따옴표 ‘ ‘ 를 사용한다.
char 변수1, 변수2='문자', ..... ;
문자열을 나타낼 때는 겹 따옴표 " "로 쓰지만 문자(1개)를 나타낼 때는
15
단일 인용부호 ' '를 쓰므로 "A" 와 'A'는 다르다는 것에 유념하여야 한다.
숫자 5와 '5'는 다르며 '5'는 문자5를 의미한다. 그러므로 문자 '5'는 ASCII
코드로 35=(0011 0101)이며 숫자 5는 ASCII 코드 5=(0000 0101)가 된다.
ASCII코드값은 문자의 대소 관계를 부여하여, 문자의 정렬(sort), 단어의
사전식 분류 등에 이용된다 문자를 문자 그대로 출력할 때는 printf( )문
속의 변환 코드를 %c로 명시하면 되고, 문자의 해당하는 ASCII코드 값
자체로 출력하면 정수 변환 코드 %d로 쓴다. 문자 1개는 1 byte, 즉 8 bit
이므로 28=256가지의 다른 값을 나타낼 수 있다.
5. 사용자 정의형(typedef)
사용자는 typedef 문을 이용하여 새로운 자료의 형(type)을 정의(define)할
수 있다. 예를 들어, Integer4 형이라는 것을 long 형으로 정의해 사용하려면
다음과 같이 쓴다.
typedef long Integer4;
6. 기본 입출력 함수 scanf( )와 printf( )
C 프로그램은 함수를 기초로 하여 여러 명령문이 이루어졌다고 할 수 있고,
또 그러한 명령문, 즉 함수들의 용법을 익혀야 한다. 기본 입출력 함수
scanf()와 printf()를 살펴보고, 변수를 어떻게 선언하는지에 대하여 알아보자.
함수 printf( )는 화면에 연속적으로 인수의 내용을 출력해 준다. 또한
scanf( )는 키보드로부터 문자형, 정수형, 실수형의 자료를 입력하는 입력
함수이다. 입력되는 자료의 형에 따라, 다음과 같이 입력 서식을 정의한다.
자료를 입출력 하는 프로그램을 작성해보자.
자료 형 입출력 서식
정수 %d
문자 %c
문자열 %s
실수 %f
16
#include <stdio.h>
void main ( )
{
char Letter1 = ‘B’;
char Name1[18] = “SEJONG UNIVERSITY”;
char Letter2;
unsigned short Number1 = 12000;
short Number2;
float Value1 = 3.141592;
const double Value2;
/* input data from keyboard */
printf("input Number2 ?");
scanf("%d", &Number2);
printf("input Value2 ?");
scanf("%f", &Value2);
printf("input Letter2 ?");
scanf("%*c%c", &Letter2);
/* printing variables Number */
printf("Number2 = %d\n", Number2);
printf("Value2 = %14.7e\n", Value2);
printf("Letter2 = %c\n", Letter2);
}
printf()의 인수로서 \n이 포함되어 있다. 문자 \는 탈출 문자(escape
character)라고 하며, 이 문자는 특별한 용도로 쓰인다. 여기서 \와 n이
연속으로 쓰여 줄바꿈(new line)을 하라는 제어문자로서 쓰인다. 제어문자의
종류와 의미는 다음과 같다.
종류 내용
\0 null 문자 문자열의 끝, 정적문자변수 초기값
\a beep 소리 beep 소리를 낸다
\b Backspace 커서를 한 칸 뒤로 이동
\f form feed 프린터 용지를 한 장 넘긴다
\n new line 커서를 다음 라인으로 이동
\r carriage return 커서를 현재 라인 맨 앞으로 이동
17
\t horizontal tab 커서를 9 칸 정도 오른쪽으로 이동
\\ \ 문자 문자를 표시
\” “ 문자 문자를 표시
7. 문자 입출력 함수 getchar( ) 와 putchar( )
getchar(), putchar() 함수는 변환 코드를 명시하지 않고 사용하며, 오직 1개
문자, 즉 단일 문자를 입/출력하는 함수이다. 이 함수는 매크로(macro)로서
헤드화일 stdio.h에 정의되어 있다. 따라서, 이 함수를 사용하려면 사용
프로그램 서두에 #inlcude <stdio.h>라고 써야 한다.
함수 getchar() 는 키보드로부터 입력한 단일 문자를 기억하고 있는
함수로서 인수는 없으므로 명시하지 않는다.
char Letter1;
Letter1 = getchar () ;
함수 putchar()는 ( )속의 문자 또는 코드를 인수로 하여 화면에
출력한다. 예를 들어 putchar('A') 또는 putchar(65)는 화면에 문자 A를
출력한다. 함수명의 char는 character를 의미한다.
8. 문자열 입출력 함수 gets( ) 과 puts( )
gets(), puts() 함수는 문자열를 입/출력하는 함수이다. 인수로는 문자열
변수(대부분 배열)를 사용한다. 함수 puts()는 ( )속의 문자열을 화면에
출력한다.
char Letter1[20];
Letter1 = getchar (Letter1) ;
puts(Letter1) ;
18
제IV장
1.
배열(Array)과 포인터(Pointer)
배열(array)은 다수의 동일한 자료형을 갖는 자료의 하나로서, 배열의 특정 원소는
첨자(subscript)를 대괄호[ ]속에 정수로 표현하여 지정한다. 배열은 별도로 새로운
자료형이 선언되는 것이 아니며, 이미 배운 int형, float형, double형 등을 연속된
기억장소에 지정된 원소의 수만큼 확보하는 것이다.
1 차원 배열
배열의 선언 방법은 다음과 같다.
float Xvalue[50], Yvalue[50];
배열 이름은 사용자가 정의하는 식별어이며, 자료의 형은 정수형의 int,
unsigned int 등이 모두 가능하며, 실수형도 동일하다. 원소의 총 개수를
지정하여 선언하며, 프로그램의 실행부에서는 첨자로서 0, 1, 2, ...., (N–1)
까지 사용한다.
원소는 첨자를 정수 또는 정수형 변수로 지정할 수 있으므로, 첨자를
변수로 쓸 때는 첨자의 범위가 0부터 선언된 원소 개수에서 1을 뺀 수의
사이에 있는 값을 갖도록 해야 한다.
2. 배열을 이용한 문자열의 표현
문자열을 1차원 배열로 표현할 때 중요한 것은, 문자열의 크기보다 배열의
크기가 하나 더 커야 한다는 것이다. 이 것은 문자열의 끝에 null
문자(\0)를 반드시 넣어야만 컴파일러가 문자열이 끝난 것으로 인식하기
때문이다.
char Name[18] = “SEJONG UNIVERSITY”;
또 다음과 같이 null 문자를 배열의 끝에 넣도록 하여 문자열의 초기값을
설정할 수도 있다. 2차원 이상의 문자형 배열에서는, 각 행의 끝마다 반드시
19
null 문자가 들어가야 한다.
char Surname[4] = {‘K’, ‘I’, ‘M’, ‘\0’};
3. 다차원 배열
동일한 자료형을 갖는 원소를 2차원, 3차원 등과 같이 다차원으로 선언하는
방법은 다음과 같다.
float Coord[30][30][30];
2 차원 이상의 배열은 2 차원 공간 좌표계의 (X, Y) 좌표, 3 차원 공간
좌표계의 (X, Y, Z) 좌표 값 등과 같은 자료들을 동일한 기억장소에
평면적으로 모아 놓은 것을 생각하면 이해하기 쉽다.
4. 배열의 초기값 설정
1 차원 정수형 배열 oneD[5]를 선언하고, 각 원소에 3, 4, 5, 6, 7 을
부여하려면 다음과 같이 중괄호 { }와 , 로 구별하여 각 원소에 초기값을
부여한다.
int oneD[5] = { 3, 4, 5, 6, 7};
2 차원 정수형 배열 int twoD[3][4]는 3*4=12 개의 원소를 갖고 있다.
2 차원 배열의 초기값 설정은 각 행에 속한 원소의 순서에 따라 입력한다.
twoD[0][0]=1 twoD[0][1]=2 twoD[0][2]=3 twoD[0][3]=4
twoD[1][0]=5 twoD[1][1]=6 twoD[1][2]=7 twoD[1][3]=8
twoD[2][0]=9 twoD[2][1]=10 twoD[2][2]=11 twoD[2][3]=12
위의 표와 같이 초기값을 입력하려면, 12 개 원소를 각각 지정하든지,
다음과 같이 입력한다.
20
int twoD[3][4]={{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12} };
또는 다음과 같이 입력할 수도 있다.
int twoD[3][4]={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
배열의 원소는 기억장소에서 선형적으로 할당되며, twoD[3][4]의 경우,
twoD[0][0], twoD[0][1], twoD[0][2], twoD[0][3] 순서 즉, 행 우선으로
결정된다. 이와 같은 초기값 설정이나 기억 장소의 할당 순서는
2 차원 이상의 배열에서도 동일하게 적용된다.
5. sizeof 연산자
sizeof 는 C 의 연산자로서 자료의 형이나 특정 자료명(변수)이 기억
장소에서 몇 바이트를 차지하고 있는지를 구해주는 연산자다.
int Memory1 = sizeof(oneD);
자료형에는 int, float 등은 물론이며, 배열의 크기도 구할 수 있다.
6. 포인터(Pointer)
다른 언어와는 달리 C 언어에서는 변수의 기억 장소를 명시(point) 함으로써
변수를 함수간에 정확하게 전달할 수 있는 기능을 갖고 있다. 또한,
기억공간을 공유함으로써 기억용량을 절약할 수 있다. 포인터의 형태는
일반 변수명 앞에 ‘*’ 를 붙여서 나타낸다.
Void main()
{
char Letter = ‘S’;
char *name2 = "Jane"; <-- 포인터
char *address1 = "Seoul"; <-- 포인터
}
21
위의 예에서 name2, address1 변수는 포인터를 사용한 변수 값 표현이다.
포인터 변수 name2, address1 에는 이 변수 값이 저장되는 메모리 상의
주소가 기억되고, 이들 변수 이름 앞에 역참조(‘*’) 연산자를 붙임으로써 그
변수 값을 전달하는 것이다. 이를 요약하면 다음 표와 같다.
표현 종류 데이터
name2 포인터 변수 주소
&Letter 변수 Letter 의 주소 주소
*name2 포인터 변수의 역참조 값
Letter 일반 변수 값
또한 pointer 는 배열의 함수간 전달에 유용하게 사용된다. 배열의 pointer
변수는, 배열의 첫번째 원소에 해당되는 주소를 갖게 된다.
#include <stdio.h>
void main()
{
float b[3] = {12,13,15} ;
float *ip = b ;
printf("%f\n", *(ip+1));
}
실수형 배열 b 의 pointer 변수 *ip 는 첫번째 원소 b[0]에 해당되는 주소를
갖는다. 따라서 *(ip+1)는 (ip+1)의 주소에 저장되어 있는 b[1]의 자료값
13.0 을 나타낸다.
포인터 자체에 대한 연산을 통해 다양한 기능을 수행할 수 있으며, 배열형
포인터를 사용할 수도 있다. ( 예 *address1[4][5] )
22
제V장 함수(Function)
하나의 프로그램 속에서 같은 내용의 처리를 여러 번 쓸 때는 일반적으로
서브루틴(subroutine)으로 만들어 놓고 필요한 곳에서 호출하여 사용한다. 이
서브루틴은 모듈과 유사한 개념이며, 이를 C 언어에서는 함수라 한다.
함수는 직접적으로 문제를 해결하는 명령문을 포함하고 있으며, 함수가 호출되는
곳에서 함수 내의 명령문이 실행된다. 예를 들어 이미 잘 알고 있는 함수
printf( )는 프로그램 속에서 호출되어 '지정된 인수를 출력'하는 함수의 기능이
수행된다.
이러한 함수는 다른 함수와 결합하여 사용할 수도 있으며, 한 프로그램에서는 모두
main( ) 함수에 종속되어 기능이 수행된다. printf( )나 scanf( ) 등은 C언어
시스템이 제공하는 라이브러리 함수(library function)로서 필요한 곳에서 호출하여
사용하게 된다. 사용자의 용도와 목적에 맞도록 작성하여 쓰는 함수를 사용자 정의
함수 (user-defined function)라고 한다.
C 언어 프로그램은 1개 이상의 함수로 되어 있다. 그 중의 하나가 함수
main( )이다. 호출하는 프로그램(calling program)에서 함수가 호출되면 피호출
함수(called function)가 실행된 후, 다시 호출 프로그램의 호출한 바로 다음으로
복귀하여 진행된다. 호출 프로그램을 호출 환경(calling environment)이라고도 한다.
간단한 함수 printf( )의 경우를 보자.
main(){ printf(“Calling printf”);}
library
함수 printf 실행
호출
복귀
1. 함수의 정의
함수는 머리(header)와 몸체(body)로 구성되며, 몸체는 main( )에서와 같이
블럭이나 복합문이다. 원시 프로그램에서 사용자 정의 함수의 기본형은
다음과 같다.
HS(); /* 함수 원형 선언 */ HS() {
23
main() {
HS(); /* 함수 호출 */
}
명령 1;
명령 2;
}
HS() {
명령 1;
명령 2;
return ;
}
main() {
HS(); /* 함수 호출 */
}
함수가 호출하는 함수보다 아래에 정의되어 있으면, 호출 함수(main) 윗
부분에 함수 원형(Prototype)을 선언한다. 피호출 함수가 호출 함수 보다
먼저 정의되어 있으면 함수 원형을 선언할 필료가 없다. 함수가 최종적으로
갖는 값의 형(type)이 있으면 자료형 이름을 명시하고, HS( ) 안에 전달되는
인수가 있으면 인수의 자료형을 명시한다. 인수(argument)는 매개변수
(parameter)라고도 하며, 호출 프로그램에서 명시되는 인수는 실인수(actual
argument)라고 하고 함수 정의의 머리에 명시된 인수를 가인수(formal
argument)라고 한다. 인수의 형 리스트는 사용되는 인수를 순서에 맞게 각
인수의 형 이름을 컴마 ,로 구분하여 명시한다. 호출함수에 되돌려 주는
값이 없을 때에는 void main( ) 과 마찬가지로 함수 이름 앞에 void를 쓴다.
어떤 한 개의 값을 되돌려 주는 함수의 경우에는 return 문을 사용한다.
아래의 피호출 함수에서 return 문을 만나면 정수곱 K 값을 호출 함수에
돌려준다. 함수의 return 문 다음에는 수식 또는 함수 이름이 올 수도 있다.
int multiply(int I, int J)
{
int K = I*J;
return K;
}
2. 함수간의 인수 전달 방식
한 개 이상의 값을 되돌려 줄 필요가 있는 함수의 경우, 인수를 이용하여
전달할 수 있다. 호출 함수와 피호출 함수 간에 인수를 전달하는 방법에는
다음 3가지가 있다.
24
가)
나)
call by value (값에 의한 전달방식)
호출함수에서 실인수가 피호출 함수로 전달될 때 실제 자료 값이 전달되며,
가인수는 이에 상응하는 기억 장소를 만들어 값을 전달 받는 방법이다.
실인수와 가인수가 각각의 기억 장소를 이용하기 때문에 가인수의 값이
변경되더라도 실인수의 값은 변하지 않고 이중의 기억 장소를 사용함에
따라 기억용량을 낭비하게 된다. 또한 이 방법으로는 하나 이상의 값을
호출함수에 전달할 수 없다. 이의 예는 이전 페이지의 함수이다.
call by pointer (포인터에 의한 전달방식)
호출함수에서 실인수의 주소를 피호출 함수에 전달하여 실인수의
기억장소를 공유하는 방법이다. 피호출 함수에서 포인터의 역참조를
이용하여 실인수 값을 변경할 수 있으므로 하나 이상의 값을 호출함수에
전달할 수 있다. 실인수의 가억 장소를 공유하기 때문에 피호출 함수에서
변경되면 실인수의 값도 그대로 바뀌게 된다.
#include <stdio.h>
void add2(int *I, int *J);
void main () {
int K = 10; int L = 20;
add2(&K, &L);
printf(“%d %d\n”, K, L);
}
void add2(int *I, int *J)
{
int temp = (*I) + (*J) ;
*I = temp;
*J = temp + 3 ;
}
다) call by reference (참조에 의한 전달방식)
25
참조 호출이란 C++ 의 기능으로서, 호출 함수에서 실인수의 주소를
참조자(reference : &)를 사용하여 피호출 함수에 전달함으로써 실인수의
기억장소를 공유하는 방법이다. call by pointer 방식에 비해 포인터 변수를
간접 참조할 필요가 없고 참조자에 전달된 주소는 포인터 상수 값으로
취급되어 피호출 함수 내에서 참조자의 내용이 바뀌지 않는다. 따라서 보다
안전한 자료의 전달을 실현할 수 있다.
#include <stdio.h>
void add2(int &, int &);
void main () {
int K = 10; int L = 20;
add2(K, L);
printf(“%d %d\n”, K, L);
}
void add2(int &I, int &J)
{
int temp = I + J ;
I = temp;
J = temp + 3 ;
}
3. 가인수를 이용한 배열전달
배열을 함수의 인수로 사용할 때는 배열명은 포인터가 된다. 따라서, 배열의
인수전달은 어드레스를 전달하는 Call-by-reference 가 된다. 함수의
가인수가 배열일 때 배열의 원소 갯수를 명시하지 않고 그대로[]를
사용하면, 첫 번째 원소를 나타내는 포인터를 전달 받는 경우가 된다.
배열의 인수는 포인터에 의한 인수 전달이므로 배열에 offset 을 지정하여
첫째 원소부터 연속으로 기억된 배열의 다른 원소를 지정할 수 잇다. 예를
들어 a[10]으로 선언한 배열에서 a+3 은 네 번째 원소가 된다. 어드레스를
지정하는 연산자 &를 사용하여 &a[4]라고 한다. a[4]의 어드레스를
지시하게 된다.
#include <stdio.h>
26
void add2(int IJ[][2]);
void main () {
int X[2][2] = {5,6,7,8};
register int IREG = 333;
add2(X);
printf("%d %d %d %d\n",X[0][0],X[0][1],X[1][0],X[1][1]); }
void add2(int IJ[][2]) {
IJ[0][0] = IJ[1][1] + 10; IJ[1][0] = IJ[0][1] + 10;
static int zzz=999; }
4. auto 변수와 extern 변수
auto 변수(automatic variable : 자동 변수)는 함수 내에서만 참조되는
지역적 범위(scope)를 갖는 기억장소의 종류 중 한가지다. 따라서, 함수의
내부에서만 쓰이는 지역변수(local variable)이다. 이 auto 변수의 경우에는
일반적으로 auto 를 명시하지 않고 변수를 선언하는데, 이는 auto 라는
예약어가 생략된 것이다.
extern 변수(external variable : 외부 변수)는 함수 외부에서 선언된 변수를
말하며, 이 변수가 선언된 하부에 있는 모든 함수에서 동일한 기억 장소를
가진 변수로서 유효성을 가진다. 따라서, 어떤 함수를 탈출해도
extern변수는 그대로 존재하게 되어, 광역변수(global variable : 전역
변수)의 개념과 같다. extern 변수는 #include 문 다음에 선언하게 되며,
단일 프로그램이 종료 될 때까지 기억장소에 존재하며, 함수를 통해서 값이
그대로 존재하는 것과 아울러 extern 변수의 변경된 값을 호출 환경
속에서도 사용할 수 있다. 이러한 것을 부수효과(side effect)라고 하는데
프로그램 모듈간의 독립성을 유지해야 한다는 관점에서 일반적으로는
바람직지 못하다. 대신 인수, 즉 매개변수를 통하여 정보를 전달하는 것이
바람직하다. extern 변수와 auto 변수의 이름이 같은 경우에는 auto 변수가
선언된 함수 내에서 extern 변수는 그 유효성을 잃게 된다.
#inlcude <stdio.h>
int z=5;
27
void main( ) {
int z=10;
static int zzz=999;
printf(" z=%d\n",z);
}
5.
6.
가)
static 변수와 register 변수
static 변수(static variable : 정적 변수)란 함수로 진입해도 지역변수가 그
전에 기억한 값을 그대로(정적으로)지니고 있게 되는 기억장소의 종류를
말한다. 이것은 auto 변수가 함수로부터 탈출하게 되면 기억한 값을
상실하게되는 것과 달리, static 변수는 해당함수로 다시 진입하여도 이전의
탈출 당시의 값을 지니고 있게 되는 차이점이 있다.
기억 영역의 하나로서 register 는 기억 장소의 변수보다 처리속도가 빠르기
때문에 자주 값을 변경해야 할 변수등을 레지스터에 할당해 주는 변수
선언이 register 형 변수 선언이다. 따라서 register 형 변수 선언은 정수형,
실수형 등의 자료형 선언의 성격이 아니라 기억 장소 종류를 지정하는
성격의 것이다. 컴퓨터의 기종에 따라 레지스터의 개수가 제한되어
있으므로, 시스템이 쓰지 않는 레지스터를 초과할 만큼 많은 register
변수를 선언한 경우 초과된 변수는 auto변수로 확보된다.
선행처리기 (Preprocessor)와 매크로 함수
선행처리기(Preprocessor)
선행처리기란 프로그램이 컴파일 되기 전에 미리 처리되는 기능을 의미한다.
프로그램 선언문 main 이전에 선언하며, #로 시작하고 라인 끝에 ; 를
붙이지 않는다. 함수의 경우 호출될 때마다 호출 준비 과정이 필요하므로
프로그램의 실행이 늦어지게 된다. 선행처리기를 이용하면, 한번 컴파일 된
내용이 프로그램 실행 파일에 반복적으로 삽입되므로 실행 프로그램의
크기가 커지지만, 실행속도가 빨라지는 장점이 있다. 선행처리기의 종류에는
다음과 같은 것들이 있다.
28
#define #include #undef #if #else #ifdef #inundef
#elif #endif #line #error #pragma # ##
나) #define (매크로 함수)
#define 문을 이용하면 매크로 및 매크로 함수를 정의할 수 있다. 정의된
문장은 컴파일 전에 프로그램 내에 전부 치환되며 복잡한 수식을 간단히 쓸
수 있다. #define 을 이용한 매크로 함수의 지정에는 인수의 자료형을
기입하지 않는다. 정의된 매크로 함수를 다시 정의할 때는 #undef 문을
사용한다. 사용은 #define 과 동일하다.
#include <stdio.h>
#define AND and
#define CONST 33
#define PRODUCT(a,b) (a*b)
void main( ) {
int A=10; int B = 20;
int TEST = CONST*PRODUCT(A,B);
printf(" %d\n",TEST);
}
다) inline 함수 (또는 확장 함수)
#define 문을 이용한 매크로 함수는 정의가 간단하지만 문제점을 안고 있다.
여러 개의 매크로 함수를 쓸 때는 연산자의 우선 순위와 인수의 자료형의
일치에 많은 신경을 써야 프로그램 오류를 방지할 수 있다. 이러한
문제점을 방지하면서 매크로 함수와 같이 프로그램 실행속도를 향상시키고
편리하게 쓸 수 있는 것이 inline 함수이다. 간단한 수식연산에 사용하면
효과가 크다.
#include <stdio.h>
inline int PRODUCT(int a, int b) {return (a*b) ; }
29
void main( ) {
int A=10; int B = 20;
int TEST = PRODUCT(A,B);
printf(" %d\n",TEST);
}
7. 화면 처리 함수
자료를 키보드로부터 입력할 때 함수 scanf( )를 사용하고, 출력은
printf( )를 사용하여 그 입력 내용과 출력 결과를 화면(screen)에서 볼 수
있다. 그러나, 지금까지 프로그램을 실행해 보면, 실행 결과는 화면의 하단
부에 나타나는데, 커서의 위치를 원하는 좌표로 이동시켜 입/출력 한다면
보기에 더욱 좋을 것이다.
이러한 화면 조작과 관련되어 다음과 같은 함수가 제공되고 있다.
• 함수 clrscr( ) : 인수없이 사용하며, 이 명령에 따라 전에 있던 화면의 모든
내용을 지워준다(clear screen). 이때 커서는 좌표(1, 1)에 위치 한다.
• 함수 gotoxy(x, y) : 커서의 위치만 좌표(x, y)로 이동시킨다.
• 함수 clreol() : 인수없이 사용하며, 커서가 있는 라인의 뒷부분을
지워준다(clear end of line).
30
제VI장
1.
파일의 입출력 입력과 출력은 C 언어의 본질적인 것은 아니지만, 실제 컴퓨터의 프로그램에서는
지금까지 우리가 살펴본 기능보다 주변 장치와 밀접한 기능을 갖고 있다. 이
장에서는 표준 입출력 라이브러리, 즉 디스크 파일의 자료를 읽거나 디스크에
자료를 기록하는 기능과 키보드로부터의 자료 입력 및 화면이나 프린터에 자료를
출력하는 처리 방법을 다룬다.
파일 열기 함수 fopen()
C 언어에서 파일을 인식하기 위하여 (논리적)파일명을 지정해주어야 하며,
파일 포인터형으로 명시하여 선언한다. 이 파일을 읽기 위하여는 일반적인
고급언어와 같이 파일을 열어(open)주어야 한다. 파일의 포인터는 파일을
조작하기 위한 특별한 식별어로서 파일형의 포인터 변수로 정의한 FILE
문을 써서 다음 기본형으로 선언한다. 엄밀하게 말하면, 기본형의 파일
포인터라고 하는 것은 스트림 이다. 지정된 파일을 읽어 나가기 위해서는
파일을 읽는 모드(read mode)로 하여 파일을 열어 놓아야 한다. 파일을
여는 함수는 라이브러리에 함수 fopen( )으로 다음과 같은 용법을 갖고 있다.
화일 포인터명 = fopen("물리적 화일명", mode);
FILE *inputf1;
FILE *outputf1;
*inputf1 = fopen("input.dat", r);
*outputf1 = fopen("output.dat", w);
파일을 열 때의 mode에는 여러 종류가 있으므로, 다음 표를 참조하도록
하고, 단지 읽으려고 할 때는 읽는 상태인 "r"로 명시하고, 출력용 파일로 열
때는 "w"로 명시한다는 것을 기억하면 된다. 모드 인수다음에 t 나 b 를
추가할 수 있다. t는 텍스트(text), b는 바이너리(2진형)으로 파일을 읽거나
생성한다. 사용 예는 rb,wb,r+b,rt등 이와 같이 사용한다.
모드 용도
r 읽는 용도로만 열기(존재하는 파일)
w 출력을 위한 생성(이미 존재한 이전 파일은 소멸됨)
31
a 파일에 추가(append)(파일이 없으면 w와 같음)
r+ 기존 파일을 갱신(update)
w+ 갱신용으로 생성(이미 존재하면 전 파일은 소멸됨)
a+ 파일 끝에 추가용(파일이 없으면 생성)
프로그램을 종료시키기 전에 읽거나 기록한 모든 파일을 닫아두어야 한다.
다른 고급언어와 같이, C 언어도 fclose()를 이용하여 닫을 수 있다. 이때,
파일에 관련된 모든 버퍼는 비워(flush) 진다.
fclose(inputf1);
2. 기본 파일 입출력 함수 fscanf() 과 fprintf()
이전에 기본 입출력 함수 scanf( )와 printf( ) 가 어떤 기능을 수행하는
명령인지는 사용해 보았다. 이 두 함수명의 끝자 f는 format의 첫자를
의미한다. 여기에 파일을 의미하는 f글자가 앞에 붙은 함수 fscanf( ),
fprintf( )는 scanf( ), printf( )와 동일한 문법에 따라 파일에 입출력을
수행한다. fscanf( ) 의 경우 주의 할 점은, 문자열 중에 빈칸 등이 있을
경우 그 이전까지만 읽게 되므로 꼭 프로그램의 결과를 확인해보는 과정이
필요하다는 것이다.
#include <stdio.h>
void main ()
{
FILE *inputf1;
FILE *outputf1;
inputf1 = fopen("input.dat","r");
outputf1 = fopen("output.dat","w");
char Name[25];
char Letter;
fscanf(inputf1, "%c\n", &Letter);
fprintf(outputf1, "%c\n", Letter);
fscanf(inputf1, "%s\n", Name);
32
fprintf(outputf1, "%s\n", Name);
printf("%c\n %s\n", Letter, Name);
fclose(inputf1);
fclose(outputf1);
}
3. 문자형 파일 입출력 함수 fgets() 과 fputs()
함수 fgets( )와 fputs( )는 getc() putc()와 동일한 개념으로 문자열을
파일로부터의 입력 또는 파일에 기록하는 함수다. fgets()는 주어진
스트림(파일)의 끝에서 EOF 마크를 만나면 NULL 값을 되돌려 준다. fputs( )
함수는 지정된 문자열의 내용을 스트림(파일)에 출력, 즉 기록하는 명령이다.
이 명령이 한 번 실행되더라도 줄이 바뀌지 않는다. 또한 파일의 맨 끝의
NULL 문자 또한 기록되지 않는다.
#include <stdio.h>
void main ()
{
FILE *inputf1;
FILE *outputf1;
inputf1 = fopen("input.dat","r");
outputf1 = fopen("output.dat","w");
char Name[25];
char Letter = getc (inputf1);
putc (Letter, outputf1);
fgets(Name, 19, inputf1);
fputs(Name, outputf1);
printf("%c\n %s\n", Letter, Name);
fclose(inputf1);
fclose(outputf1);
}
33
4. 파일 접근 함수 fseek( ) 와 ftell( )
형식화 파일, 즉 버퍼형 파일에는 파일의 포인터를 임의의 위치로
이동시키는 명령으로 fseek( )가 있다. 한 편, 함수 ftell( )은 파일의 현재
위치를 알 수 있는 함수이다. 함수 fseek( )의 기본형은 다음과 같다.
fseek(inputf1, long offset, int whence);
이 함수는 파일의 포인터를 whence로 지정된 파일의 위치에서 offset바이트
만큼 이동된 새로운 위치로 변경하여 자리잡게한다. whence는 정수로서
0,1,2 만 쓸 수 있으며, 이 값은 stdio.h에 다음의 기호 상수로 정해져
있으므로 정수 값 대신 기호를 써도 무방하다.
위치지정(whence) 파일 위치
SEEK_SET (=0)
SEEK_CUR (=1)
SEEK_END (=2)
파일의 처음
현재의 파일 위치
파일의 끝
일반적으로 함수 fseek( )를 쓴 다음에는 파일에 입력 또는 출력조작을 하게
된다. 함수 ftell( )은 현재의 파일 포인터의 값을 되돌려주므로, 파일
포인터가 어디에 위치하는가를 알 수 있는 함수이다.
ftell(inputf1);
5. 파일 접근 함수 fread(), fwrite()와 rewind()
파일로부터 자료를 읽어 들이는 명령으로 fread( )와 기록하는 명령으로
fwrite( )가 있다. rewind( )는 스트림의 맨 앞으로 파일 포인터를 되감아서
이동시키는 명령이다. fread( ) 함수는 파일로부터 지정된 길이의 바이트를
지정된 횟수만큼 읽어들여 그 내용을 포인터가 지시하는 블럭에 기억시켜
둔다. 함수 fwrite( )는 fread( )와 반대의 개념으로 포인터가 지시하는
자료를 지정된 길이의 바이트 만큼씩 지정한 횟수만큼 파일에 기록한다.
34
#include <stdio.h>
size fread(void *ptr, size length, size cnt, inputf1);
size fwrite(void *ptr, size length, size cnt, inputf1);
위의 ptr은 어떠한 자료라도 지시할 수 있는 포인트 변수이다. 기록되는 총
바이트의 수는 cnt *length이다. 함수 rewind( )는 파일의 처음으로
포인터를 옮겨주며 기본형은 다음과 같다.
void rewind(inputf1);
6. 함수 feof( ) 와 ferror( )
함수 feof( )는 파일을 읽어 나가다가 파일의 끝에 도달했을 때를 알 수
있는 함수이며, 함수 ferror( )은 스트림(파일)에 입출력 조작을 할 때 오류등
이상이 발생했는지를 알 수 있는 함수이다.
#include <stdio.h>
int feof(inputf1);
이 feof( )는 명시된 파일의 끝(EOF)을 알 수 있는 매크로이다. 파일의 끝을
만난 후에는 rewind( )나 파일을 닫기 전에는 feof( )값은 변하지 않는다.
getc( )의 경우에는 파일의 끝을 확인하는 용도로 EOF(=-1)를 쓸 수 있다.
#include <stdio.h>
int ferror(FILE *stream);
35
제VII장
1.
연산자와 조건문
산술 연산자
산술 연산자는 4 칙 연산을 비롯하여 정수의 나머지를 구할 수 있는
연산자가 있다.
연산 기본식 의미
덧셈 A + B 두 연산자의 합
뺄셈 A – B A 에서 B 를 빼기
곱셈 A * B A 을 B 로 곱하기
나눗셈 A / B A 을 B 로 나누기
나머지 A % B A/B 나눗셈의 나머지
연산자와 피 연산자인 A, B 사이는 빈칸의 존재유무에 대해 무관하다. 정수
나눗셈의 나머지를 연산하는 연산자 %는 피 연산자로서 정수를 사용하여야
한다. 산술 연산자의 우선 순위는 곱셈, 나눗셈, 나머지(잉여) 연산이 서로
같고, 이들은 덧셈과 뺄셈보다 우위이므로 먼저 연산해 준다. 또,
수학에서와 같이 괄호( )가 있으면 괄호 속의 식을 먼저 연산하고, 함수가
사용되었을 때는 함수가 우선적으로 수행되어야 한다. 연산 순위가 같을
때는 왼쪽에서 오른쪽으로 연산해 준다. 모든 프로그램 언어에서와 같이
식에는 중괄호 { } 나 대괄호 [ ] 는 사용 할 수 없고 ( ) 만을 사용하며,
가장 안에 있는 괄호부터 단계적으로 계산한다.
‘-‘ 는 단항 연산자의 역할을 겸하기 때문에 -a 는 a 의 값에 -1 을 곱한
것과 같다. 따라서, -d%c -j/j*k 는 ((-d)%c)-(j/g)*k)로 안쪽의 괄호부터
연산하면 된다.
2. 할당연산자
산술 연산식을 비롯하여, 관계식, 논리식 등 여러 가지의 식을 연산한 후 그
결과를 지정된 변수에 할당 즉, 기억시키는 연산자로 할당 연산자
36
(assignment operator) = 이 있고, 이 = 는 다른 연산자와 결합된 형태로도
쓰인다. 기본적인 할당 연산은 산술식이 포함된 i=i+j 와 같은 형태로 왼쪽의
식 i+j 의 계산 결과를 오른쪽의 변수 I 에 할당(기억)시키는 것이다.
산술 연산자와 할당 연산자가 결합된 할당 연산자로는 i=i+j 에서와 같이
왼쪽의 변수가 오른쪽 식의 처음에 나타날 때는 i+=j 로 쓸 수 있다. +=뿐
아니라 -=, *= ,/= 및 %= 도 쓸수 있는데, 이러한 연산자를 결합 연산자
(combined operator)라고 한다.
Value 를 변수, eqn 을 산술식, op 를 산술 연산자라 하면 다음과 같이
정리할 수 있다.
Value = eqn : eqn 을 연산 후 변수 Value 에 할당
Value op = eqn : Value = Value op (eqn)와 동일
C 언어는 할당 연산자의 용도가 위에서 보는 것처럼 다양하다. 또, C
언어는 할당 연산자 =를 연속적으로 쓰는 것도 허용된다. sum=k=j와
같이도 쓸 수 있는데, 이런 경우 오른쪽에서 왼쪽으로 연산한다는 =의
기본원칙에 따라, sum=k=j는 j의 값을 k 에 할당 한 후, 그 k의 값을 sum에
할당하는 명령문이 된다. 따라서, 원래 j의 값을 k 에도, 또 sum에도
기억시키므로 세 변수 sum, k, j는 원래의 j값을 기억하게 된다.
3. 증가 연산자와 감소 연산자
변수에 정수값 1 을 증가, 또는 감소시키는 단항 연산자로 ++와 --가 있다.
• j++ --> j 에 1증가, 즉 j=j+1, 증가시키기 전에 우선 j 사용
• ++j --> j 에 1증가, 즉 j=j+1, 우선 j 를 증가시키고 j 사용
두 가지 연산 j++와 ++j 는 유사한 것처럼 보이나, j++는 후치이고, ++j 는
전치로서 연산 순서에 차이점이 있다.
hap = k+ j++;
hap=k+j; /* 우선 연산 */
j=j+1; /* j 는 나중에 증가 */
37
hap = k+ ++j;
j=j+1; /* j 는 먼저 증가 */
hap=k+j; /* 나중에 연산 */
위에서 보는 바와 같이 후치 j++는 j 를 연산에 우선 사용 후 j 를 1 만큼
증가시키며, 전치 ++j 는 연산에 사용하기 전에 1 만큼 증가시키고 난 후
연산에 쓰인다. 물론 두 가지 경우가 모두 j 값은 1 씩 증가되어 있게 된다.
이와 같이 ++와 --는 간단한 연산이 되지만 사용하기 전에 그 용법을 잘
알아두어야 한다. 상수는 증가될 수 없으므로 ++는 상수에는 적용될 수
없어 ++5 등은 쓸 수 없고, --의 경우도 같은 원리로 적용된다. 하나의
문장으로 단순히 ++j;나 j++;로 하는 것은 똑같이 j 를 1 증가하는 연산
식이다. 전치로서의 증가, 감소 연산자는 우선 순위가 단항 연산자 -와
같이 다른 산술 연산자보다 상위이므로 먼저 연산해 준다.
hap +=k* ++j;
hap=hap+(k*j);
hap+=k*j++;
hap=hap+(k*j);
그러면, k=i+++j;를 k=(i++)+j;로 볼 것인가 k=i+(++j);로 볼 것인가 하는
우선 순위에 대한 의문이 따르게 된다. 다음 예에서 살펴보자.
k=3, j=5
식 결과의 값 동일식
m=k+++j m=8, k=4, j=5 m=(k++)+j;
m=k++ +j m=8, k=4, j=5 m=(k++)+j;
m=k+ ++j m=9, k=3, j=6 m=k+(++j);
따라서, 필요한 곳에 ( )를 쓰는 것이 이해하기 좋을 것이며, 증가, 감소
연산자 ++, --나 결합 연산자 +=, *=, -=등은 C 프로그램을 간결하게 하는
목적을 지니고 있을 뿐이다.
38
4. 컴마 연산자
컴마 연산자 , 는 괄호 ( ) 속에서 여러 식을 연산할 때 쓰인다. 괄호 속의
여러 식은 왼쪽에서 오른쪽으로 평가되고, 전체식은 최종적으로 평가된
식의 값을 갖게 된다. 예를 들어, j = ( k = 3, k = k+4 ) 는 j 가 최종 값으로
7 을 갖게 된다.
k = 3;
k = k+4; /* k = 7 */
j = k; /* j = 7 */
5. if 문과 조건식
주어진 조건식이 참이냐 거짓이냐를 판별하여 양자 택일로 문장을 선택하여
실행의 흐름을 결정하는 if 문이 있다. if 문에 쓰이는 조건식은 일반적으로
대소와 같음을 판단하는 관계 연산자로 이루어진 관계식이 있고, 관계식이
결합된 논리 연산식이 있다. if 문의 기본형은 다음과 같다.
If (조건식)
명령문 1; /* True */
else
명령문 2; /* False */
if 문과 else 문의 끝에는 ; 를 붙이지 않는다. if 조건이 참이면 명령문 1을
수행하며, 거짓이면 명령문 2를 수행한다. 거짓인 경우에 처리할 명령문이
없으면 else 이하를 생략할 수 있다. 일반적으로 조건으로 쓰이는 것은
(x>2) 와 같은 관계 연산식이 대표적이며, C 언어는 조건식이 아니더라도
그 값이 0 이냐, 아니냐에 따라 거짓인가 참인가를 판단한다. 조건식이
참일 때 처리할 명령문이 없다면, 명령문 없이 세미콜론 ‘;’ 만 쓴다. 이러한
문장을 empty statement 라고 한다.
39
6. 관계 연산자와 논리 연산자
참이냐 거짓이냐의 결과를 내는 조건식에는 관계 연산자 <, >, =, <=, >=
등이 쓰이는 관계식과 다음 절에서 다룰 논리식이 있다. 이러한 관계식과
논리식은 일반적으로 if 문 등 참, 거짓을 필요로 하는 구문의 조건식으로
쓰이게 된다. 관계 연산자를 이용한 관계식은 두 식 사이의 대소 관계를
판단하는 식으로서 다음과 같은 연산자를 사용한다. A, B 를 수식이라 하자.
관계 연산자 관계식 설명
< A < B A 가 B 보다 작다.
<= A <= B A<B 또는 A=B 이다.
> A > B A 가 B 보다 크다.
>= A >= B A>B 또는 A=B 이다.
== A == B A 와 B 가 같다.
!= A != B A와 B가 같지 않다.
특히, <= 와 >=는 =< 나 =>로 표시 할 수 없고, 또 중간에 빈칸을 넣어서
(< =) 로 써도 안 된다. 동등 관계는 =를 두 번 써서 ==로 쓰며 같지
않는다는 != 이다. 할당 연산자 = 와 동등 관계 연산자 == 와는 다르다는
것에 주의하라.
#include <stdio.h>
main( )
{
int x, y;
char *form="\n x = %3d, y=%3d : %s";
printf("\n Enter two integer ? ");
scanf("%d %d",&x,&y);
if(x>y)
printf( form, x, y,:x>y");
if(x<y)
printf( form, x, y,:x<y");
40
if(x==y)
printf( form, x, y,:x=y");
if(x>y)
printf( form, x, y,"x is greater than y ");
else
printf( from, x, y,"x is not greater than y ");
}
[결과]
Enter two integer ? 2 2
x= 2, y= 2 : x =y
x= 2, y= 2 : x is not greater then y
< 해설 >
7.
결과와 같이 두 정수로 2, 2 를 입력하였다면, 7 라인의 조건은 거짓이므로
8 라인은 실행되지 않는다. 따라서 11 라인의 참이 되는 조건으로서
12 라인이 실행되고, 13 라인의 조건이 거짓 이므로 else 이하인 16 라인이
실행된다.
논리 연산자
논리 연산자로는 &&, || 및 ! 이 있다. A, B 를 수식 또는 하나의
관계식이라고 할 때, 기본적인 논리식은 다음과 같다.
논리 연산자 논리식 의미
&& A && B 논리적 곱(logical and)
|| A || B 논리적 합(logical or)
! ! A 논리적 부정(logical negation)
A, B 가 하나의 관계식일 경우 관계식의 결과가 참일 때 1, 거짓일 때 0을
갖게 되므로 A나 B는 1 아니면 0 을 갖는다. 참은 1, 거짓은 0 으로
표시할 때 논리식의 결과, 즉 진리표는 다음과 같이 정의한다.
41
A B A &&B A || B ! A
1 1 1 1 0
1 0 0 1 0
0 1 0 1 1
0 0 0 0 1
A, B를 산술식으로도 쓸 수 있으며, 이 경우에도 산술식의 값이 0 이면
거짓으로, 0 이 아니면 참으로 본다.
지금 까지 알아본 관계식 및 논리식은 if 문의 조것으로 쓰이고 있으며,
더욱이 C 언어는 타 언어와 달리 수식 자체가 if as의 조건으로 쓰이는
것을 보았다. 이러한 관점에서 if 문의 조건이란 결국 그 값이 0이냐,
아니냐만 판단하여 실행의 순서를 바꾸어 줄 수 있다.
8. 복합문과 다중 if 문
앞의 예제에서 쓴 if 문을 다시 한번 살펴보자.
if (x==y)
printf( form, x, y, " x = y");
if(x>y)
printf( form, x, y, " x is greater than y ");
else
printf( form, x, y, " x is not greater than y ");
첫 번째의 if 문은 x와 y가 같을 때 printf( )를 실행하고, 두 번째 if 문은
x>y 일 때 앞의 printf( )를, 아닐 때는 else 이하의 printf( )문을 실행한다.
위 두 개의 if 문은 모두 조건에 따라 한 개의 명령문을 실행하고 있다.
조건에 따라 실행할 명령이 두 문장 이상일 때는 중괄호 { }를 쓰도록 한다.
다. x>0일 때, 두 개의 명령문 y=x+3; 과 printf("y=%d",y); 를 실행하려고
할 때, 다음과 같이 코딩한다.
42
if (x >0 ) {
y=x+3;
printf(" y = %d",y); }
즉, 조건에 따라 실행할 명령문구를 중괄호 { }로 묶어준다. if 문의
기본형이 다음과 같으므로, 중괄호를 사용하여 두 개의 명령문을 하나의
그룹으로 묶어 하나의 명령문처럼 간주하도록 하는 것이다.
이렇게 중괄호 { }로 묶은 명령문 그룹을 복합문(또는 복문:compound
statement)이라고 한다. 한편, 이에 따라 명령문이 하나일 때는 중괄호 { }
를 쓰지 않는데 이를 단순문(또는 단문: simple statement)이라고 한다. if 문
뿐 아니라, 다음 장에서 다룰 for문, while문, while-do문 등에서도 이
원리는 적용된다.
다음 순서도를 코딩해 보자.
X>0
y=-x+3z=-x-5
y=x+3z=x-5
False(0) True(1)
9. 다중 if 문
다중 if 문(nested if statement)이란 if 문의 명령문 속에 다시 if 문을
사용하는 것을 말한다. if 문이 하나의 명령문이고 조건이 참이거나 거짓에
따라 구분상 명령문이 올 수 있는데, 그 명령문이 새로운 조건을 판단하는
if 문이 오는 경우다.
if ( 식 1 )
if ( 식 2 )
명령 1
43
else
명령 2
else
if(식 3)
명령 3
다중 if 문을 쓰게 될 때는 다음과 같은 점에 대하여 특별히 주의하지
않으면 프로그램 작성 의도와 빗나가게 되는 경우가 발생한다.
• 하나의 else는 else를 갖지 않는 바로 전의 if 문에 걸린다.
• 적절하게 조건에 따른 첫머리 글자를 맞추어 코딩을 한다.
10. switch 와 break
switch 문은 식의 값을 여러 가지로 판단하여 각 값에 따라 실행할 명령을
선택하여 진행시킬 수 있는 조건문의 한 가지이다. 단순 if 문이나 다중 if
문 등은 조건을 참인가 거짓인가에 따라 양자 택일하여 실행하지만, switch
문은 분기 조건을 여러 가지로 명시할 수 있다. switch 문의 기본형은
다음과 같다.
switch ( 식 )
{
case label 1 : 명령문 1 ;
case label 2 : 명령문 2 ;
case label 3 : 명령문 3 ;
: :
default : 명령문 n;
}
switch 문은 선택자(selector)로서 정수식 또는 문자식이 올 수 있으나,
실수형은 사용할 수 없다. switch 문을 순서도로 그리면 다음과 같다.
44
식
명령어 1
명령어 2
명령어 3
명령어 n
식=label1
식=label1
식=label1
기타값
식이 갖고 있는 값이 label 중의 일치하는 것이 있으면 그 label 이하의
명령을 실행하고 계속하여 그 이하의 명령문을 실행한다. 일치하는 label 이
하나도 없는 경우 실행할 명령은 레이블 default 이하에 있는 명령문을
실행하며, 실행할 명령이 없을 때는 껍질 문으로 만들어 세미콜론 ‘;’ 만
명시한다.
앞의 예에서 처음으로 일치하는 레이블을 만나면, 그 이후의 레이블과
일치하지 않더라도 계속 실행하므로, 일치하는 레이블의 명령만 실행하고
같지 않은 레이블의 명령을 건너 뛰는 기능을 실행하려면, 해당 레이블에
속하는 실행 문 끝에 break 문을 사용한다. break 문은 다음 장에서
설명한다.
45
제VIII장
1.
제어문
for 반복문
정수 변수 k 를 1 부터 k가 10 일 때까지 1 씩 증가시키면서, 이 k 를 변수
hap 에 더해 나간 후 그 합 hap 을 화면에 출력해 보자. 이와 같이 하나의
변수를 일정한 값 만큼 변경하면서 반복처리 할 경우에는 for 문을
사용한다.
main( )
{
int k, hap=0;
for ( k = 1 ; k <= 10 ; k = k + 1 )
hap = hap + k ;
printf ( "Sum from 1 to 10 = %d \n", hap ) ;
}
[결 과]
Sum from 1 to 10 = 55
[설 명]
for문 속의 ( )안에 있는 식을 살펴 보면,
k = 1 : k 에 최초 1을 기억시킴(초기화),
k <= 10 : k가 10 이하인가를 확인하여 참 일 때 수행(조건식)
k = k+1 : 반복 범위를 한번 실행 후 k 값을 1 증가시킴 (재초기화)
이에 따라, k를 1, 2, 3, 4, ... ,10 으로 변경하면서 hap = hap + k ; 문을
10회 반복하게 된다.
반복문 for의 기본형은 다음과 같다.
for (식 1; 식 2; 식 3)
명령문 1;
46
명령문 1은 단순문 뿐 아니라 중괄호로 묶인 복합문도 가능하다. 식 1은
초기화식, 식 2는 반복 여부를 판단하는 조건식으로서 참(0 이 아닌 값)일
때 반복 실행하고 거짓(값 0) 일 때, for문은 끝난다. 식 3은 반복 범위
(보통 loop라 함) 를 한 번 실행한 후 식 2를 '판단하기 전'에 재초기화
하는 식이다. 앞의 예에서 k 를 순환 변수 또는 제어 변수라고 한다.
for문은 다음 순서도에 따라 반복되는 구조를 갖는다. 한편, 식 1로 초기화
한 후, 식 2 가 처음부터 거짓이라면 명령문은 한번도 실행되지 않는
경우도 있다.
식 2
식 1
명령문 1식 1
true
false
위의 기본 형에서 초기화 식 1이 없을 때는 ; 만으로 대신할 수 있으며, 식
2, 식 3의 경우도 생략할 경우에는 ; 만 쓴다. 예를 들어, for( k=1; ;)... 는
k는 1로 초기화하지만 식 2가 없으므로 무한루프가 되고, 식 3이 없으므로
재초기화는 나타나 있지 않다.
2. while 문
while 문은 조건식이 참인 동안(while) 루프를 반복하는 반복문이다. for
문은 제어 변수의 값을 보통 일정한 값 만큼 증가(또는 감소)시켜 나가면서
반복하는 것이지만 while은 이러한 제어 변수가 없으므로 보다 일반적인
반복문으로 사용할 수 있다. 반복문 while의 기본형은 다음과 같다.
while ( 식 1 )
명령문 1;
47
식1이 먼저 평가 판단되어 참(0이 아닌)일 때에 명령문 1을 실행하고, 다시
식1이 평가되어 참인 동안 계속 반복되다가 거짓(값 0)이면 while문 다음의
명령으로 진행된다. 명령문 1이 하나의 명령문이 아닌 여러 명령문일 때는
구문상 복합문으로 써야 한다. while문의 진행 흐름을 순서도로 그리면
다음과 같다.
식 1
명령문 1
true
식1이 먼저 판단되므로 경우에 따라 루프는 한 번도 실행되지 않을 때가
있으며, 일반적으로 명령문 1속에 식 1을 참으로 하는 명령문이 포함되어
있다.
while 문을 알고 나면 모든 프로그램 제어구조는 while문 만으로도 구현할
수 있다는 것을 알게 될 것이다. 그러나, 프로그래머에게 편의를 제공하기
위하여 for 문이 있고, 또 다음절에서 다루는 do-while 문도 있기 때문에
보다 간편하고 적절한 제어 구조를 프로그램 작성에 도입할 수 있다.
3. do while 문
while 문의 변형인 do-while 문도 반복문의 하나이다. while 문과
마찬가지로 반복 여부를 판단하는 조건식 1을 while 문 다음에 명시하여,
조건이 참 인 동안(while) 루프 범위를 반복하게 된다. 기본 형식은 다음과
같다.
do
명령문 1;
while ( 조건식 1 );
48
이 do- while 문은 처음에는 무조건 명령문 1을 실행하고 난 후, 조건식1
을 판단하여 참(0이 아닌 값)이면 반복하고, 거짓(값 0)이면 다음의
명령으로 진행한다. 명령문 1은 단순문 또는 복합문이다.
따라서, while 문은 루프로 들어가기 전에 조건을 먼저 확인하므로 한 번도
루프의 명령문을 실행하지 않을 경우가 있으나, do-while 문은 우선 명령문
1을 실행한 후 조건식을 확인하므로 최소한 한 번은 명령문 1을 실행하게
된다. do-while문은 순서도로 나타내면 다음과 같다.
식 1
명령문 1
true
false
4. break 와 continue
break 문과 continue 문은 반복 구문이 나타나는 for 문, while 문 및 do-
while 문의 반복 부분, 즉 루프 속에서 반복 수행의 제어를 변경하는
용도로 쓰인다.
break 문은 switch 문의 명령문 속에서도 쓰며, 해당 switch 문을 탈출할
때도 사용된다. break 문은 반복 루프 내에서만 쓸 수 있고, 이 break문을
만나면 해당 반복 구문을 조건식과 관계 없이 완전히 탈출한다.
for (i=1; ;i++)
{
hap=hap+i;
if(hap>=50) break;
}
printf("hap= %d",hap);
위의 경우 hap>=50 의 조건이 만족되면 for 의 범위를 벗어나서, 다음에
49
있는 printf( ) 문으로 제어가 바뀐다. for 문이 이중으로 쓰인 경우를
살펴보자.
for( i=1, ghap=0 ; ; i++ )
{
for( hap=0, j=1; ;j++)
{
hap=hap+i;
if(j>=5) break;
}
ghap = ghap+hap;
if(ghap >= 100) break;
}
안쪽의 for 문이 break 문을 포함하고, 또 밖의 for 문에도 break 문을
포함하고 있다. 이러한 경우, 속의 break 문을 만날 때는 안쪽의 for 문의
루프를 벗어날 뿐이고, 밖의 for 문을 다시 진행한다.
만약 위의 코딩 예에서 break 문이 없다면 for 문의 조건식이
없으므로 무한 루프가 된다. 명령문의 처리 내용은 ghap 을 0 으로 한 후,
최초 i=1로 하여 hap=1+2+3+......+j를 j가 5가 될 때까지 반복하고 j>=5
이면 i를 1증가한 후, 다시 hap = hap + j( j= 1, 2, 3, .., 5)를 계산하면서
hap을 ghap 에 더해 나가다가 ghap이 100 이상이 되면 끝나는 프로그램
수행이다. 순서도를 그리면 다음과 같다.
50
hap=0, j=1;
i=1, ghap=0;
hap = hap + j;
J>=5
j = j + i
ghap= ghap + hap
ghap>=100
i = i + 1
true(break)
false
true(break)
false
내부 for 루프
외부 for 루프
"계속한다"는 뜻의 continue 문은 for 문, while 문 및 do-while 문의 루프
속에서만 쓰이며 반복 루프와 안쪽에 있는 일부의 명령을 건너 뛰어
조건식을 확인하고 다시 루프를 반복하는 용도로 쓰인다. 물론 조건식이
거짓이면 루프를 탈출한다.
아래의 순서도는 i값이 홀수일 때, 반복 루프를 끝까지 진행하지 않고
조건식을 확인하려고 continue 문을 사용한 것이다.
51
i=0, hap=0;
Hap<100
i = i + 1
i=홀수
hap = hap + 1
true
false
truecontinue
false
while (hap < 100)
{
if((i%2)==1)
{
i++;
continue;
}
else
hap +=i++;
}
5. goto 문
지금까지 배워온 break, continue 문은 for 문, while 문, do-while 문의
루프 속에서 사용되는 제어문이다. 이와 달리 제어 위치를 무조건 바꾸는
명령으로 goto문이 있다.
goto문은 지정된 위치로 제어를 바꾸는데, 분기될 명령문 앞에는 레이블
(label)을 명시해 주어야 한다. 일반적으로 goto 문은 프로그램의 추적을
곤란하게 하므로 구조적 프로그래밍 기법에서는 바람직하지 못한
명령어지만, 부득이 필요한 경우도 간혹 있다.
52
again: i=i+1;
goto again;
레이블 은 영문이 포함된 식별어로 사용자가 정하며, 레이블명의 바로
뒤에는 ‘:’ (콜론)을 쓴다.
53
제IX장
1.
가)
나)
다)
C++ 프로그래밍 기초
C++의 개요
특징
“C with class”란 이름처럼 C의 문형을 쓸 수 있으며 객체 지향 개
념 포함
연산자와 함수의 다중정의가 가능
C보다 타입을 엄격하게 체크한다.
추가된 예약어
class : 클래스를 정의
new : 메모리 영역을 할당
delete : 메모리 영역을 해제
friend : 클래스를 다른 클래스나 함수의 친구로 선언
inline : 인라인 함수를 정의
operator : 연산자를 다중정의
this : 해당 클래스의 객체 자신을 가리키는 포인터
private : 클래스의 비공개 멤버를 선언
protected : 클래스의 보호 멤버를 선언
public : 클래스의 공개 멤버를 선언
virtual : 클래스의 가상 함수를 선언
C++ 컴파일러(Windows용)
Borland C++ compiler
(http://www.borland.com/bcppbuilder/freecompiler)
Microsoft Visual C++ compiler
(http://msdn.microsoft.com/visualc)
MSDOS C++ compiler (http://www.delorie.com/djgpp)
54
라) 개발 환경
C++ 언어를 사용하여 프로그램을 개발하기 위해서는 C++소스를 기계어로
번역하는 프로그램과 소스를 작성하는 에디터 프로그램이 필요하다. 유닉스 계
열에서는 VI 에디터나, Emacs를 이용하여 소스를 편집하고, 컴파일러를 이용해
컴파일 하여 프로그램을 제작하는 것이 일반적이다. 윈도우 계열에선 Visual
C++이나 Boralnd C++ Builder를 많이 사용하며 에디터와 컴파일러가 통합된
IDE(Integrated Development Environment)환경에서 개발을 하는 것이 일반적이
다.
그림 1. MS-Visual C++ IDE
55
2.
가)
C++의 기본구조와 문법
기본구조
#include <iostream.h>
int main(){
cout << “Hello World\n”;
return 0;
}
위의 예에서 보듯이 C언어로 작성한 프로그램과 비슷한 형태를 가지고 있다.
나)
첫번째 라인에서 iostream.h를 포함하고 있다. iostream.h파일은
C++에서 사용하는 기본적인 io(input/output)을 정의하고 있다.
프로그램의 가장 기본적인 main함수는 C와 비슷하게 구현된다.
3번째 라인에서와 같이 C++에서는 기본적으로 Output을 cout을 이
용하여 구현하게 된다.(자세한 내용은 C++의 스트림을 참고)
C++의 기본적인 문법은 C와 완전히 같다고 볼 수는 없지만 거의
같다고 보면 된다. 라인의 끝은 ;(세미콜론)으로 끝나며, 함수가 종
료 될 때 값의 되돌리기는 return 함수를 사용하며 블록의 구분은
{ }을 사용한다.
주석
프로그램을 작성할 때에는 항상 소스를 깔끔하고 명확하게 작성하려는 습관
을 가져야 한다. 특히나 프로그램을 작성한 본인이 몇 일 후에나 아니면 몇 주
후에 들여 보았을 때 소스를 알아 볼 수 없다거나, 다른 사람에게 소스를 넘겨
주었을 때 알아 볼 수 가 없다면 상당히 곤란 할 것 이다. 이런 경우에 주석을
달아 놓는 다면 문제를 줄일 수 있을 것이다.
C++에는 //(이중 슬래시)나 /*(슬래시 별표)주석이 있다. ‘//’은
C++ 스타일의 주석인데, 이 주석을 사용하면 ‘//’이후에 나오는 것
을 라인이 끝날 때 까지 주석으로 처리한다.
‘/*’는 ‘*/’와 한 쌍으로 하여 주석을 표시한다. 주로 블록 단위로
주석을 표시 할 때 사용 한다.
주석 사용하기
56
/******************************************************************
프로그램 : Hello World
파일 : Hello.cpp
만든날 : 2002.7.1
설 명 : 화면상에 Hello World를 출력하는 프로그램
********************************************************************/
#include <iostream.h>
/* 여기서부터 주석 시작
여기서 주석 종료*/
int main(){ // 이 부분부터 이 라인의 끝까지 무시
cout << “Hello World\n”; // 화면에 Hello World 출력
return 0;
}
다)
소스를 작성을 하면 항상 파일의 첫 부분에 위와 같이 설명을 다는
것이 파일에 대한 내용을 파악 하기 쉽기 때문에 파일의 첫 부분에
주석을 다는 것은 매우 좋은 습관이다.
또한 함수의 시작 부분 프로그램의 시작 부분에 주석을 달아 놓으
면 프로그램의 구조를 쉽게 설명 할 수 있다.
기본 출력
#include <iostream.h>
int main(){
char test[]="hi";
cout << "This is C++ Program\n";
cout << test << "\n";
return 0;
}
C++에서는 기본적인 입출력 헤더 파일을 iostream.h를 사용하며, 기본적인
출력을 cout을 사용해서 결과를 출력하게 된다. cout사용할 때에는 “<<”(방향
지정자)을 사용하여 출력을 시킨다.또한 변수의 내용을 출력 시키려 할 때에도
“<<”만을 이용하여 char 배열형 변수인 test의 내용을 출력을 시켰다. 다른 형
태의 변수에서 이것과 비슷하게 출력을 시킬 수 있다. C++에서도 C에서와 마
찬가지로 Printf문을 써서 출력을 할 수 있다. 하지만 여기서의 주제는 C++에
57
관해서 다루고 있으므로 C++에서 기본적으로 사용되는 cout으로 출력을 할 것
이다. pritnf문으로 정교한 포멧의 출력을 원한다면 그렇게 할 수도 있다. 하지
만 cout으로도 얼마든지 원하는 대로 출력을 할 수 가 있으며 C++에서 추가된
객체의 내용을 출력하려 할 때 문제가 발생 할 수 있다.
이제 cout의 사용법을 살펴 보자 cout의 뒤에 “<<” 따라오고 그 뒤에 “(큰
따옴표)로 둘러 싸인 문자열이 온다. 기본적으로 문자열을 출력 시키기 위해서
는 다음과 같이 하면 된다.
cout << “문자열” ;
또한 캐리지 리턴이나 탭문자 같은 개행 문자를 사용하려면 C에서와 마찬가
지로 “\n”이나 “\t”을 사용 하여 출력 할 수 있다.
cout << “문자열\t문자열\n”;
우선은 출력을 할 때 사용하는 “<<”를 잘 기억하도록 하자. 이것은 출력 뿐
만이 아니라 입력에서도 쓰인다.
라) 기본 입력
#include <iostream.h>
#include <conio.h>
int main(){
clrscr();
cout << "This is C++ Program\n";
cout << "test\n";
char a[256];
cin >> a;
cout << a << endl;
cin >> a;
return 0;
}
이번에는 프로그램에서 입력을 받기 위해서 cin을 이용하였다. 이것은 cout
과 마찬가지로 iostream.h에서 선언이 되어있으며 “>>”을 이용하여 입력의 방
향을 지정하게 된다. 위의 소스는 문자열을 출력한 후에 사용자 입력을 받고,
58
입력 받은 내용을 보여주는 프로그램이다. 변수를 기준으로 cin에서 데이터를
가져 와서 a라는 변수에 담는다.
C++에서 기본적인 프로그램의 입출력을 살펴 보았다. 위에서 볼 수 있듯이
출력에서는 cout을 입력에서는 cin을 이용하여 입력과 출력을 수행 하게 된다.
여기에서 주의해야 할 사항은 “<<”의 방향이다. 프로그램을 기준으로 cout은
내용을 출력 할 대상이다. 따라서 “<<”의 방향이 변수에서 cout을 향하고 있는
것 처럼 되어 있다. 이와 마찬가지로 입력에서는 cin에서 변수로 방향이 지정이
되어야 한다. 즉 사용자 입력에서 변수로 방향을 지정해 준다.
cout을 사용할 때 printf에서 처럼 굳이 형식을 지정해 주지 않아도 출력을
시켜준다. 사용자 측면에서는 훨씬 편하게 쓸 수 있으며, 개행문자는 printf 함
수에서와 마찬가지로 쓸 수 있으며 다음과 같이 여러 개의 문자열를 붙여서 쓸
수 있다.
cout << “Hi\t” << “This is My C++ Program” << “\n”;
마) 사용자 변수의 정의
변수를 정의할 때 사용할 수 있는 것이 typedef이다. Visual C++의 헤더 파
일 중에서 windef.h를 보면 typedef를 이용하여 새로운 이름으로 선언이 되어
있는 것을 볼 수가 있다.
typedef unsigned long ULONG;
typedef ULONG *PULONG;
typedef unsigned short USHORT;
typedef USHORT *PUSHORT;
typedef unsigned char UCHAR;
typedef UCHAR *PUCHAR;
typedef char *PSZ;
따라서 이 것을 이용하면 프로그램을 간편하게 작성할 수가 있다.
#include <iostream.h>
typedef unsigned long ULONG;
typedef unsigned short USHORT;
int main(){
USHORT itsWidth=100;
59
USHORT int itsHeight=10;
ULONG itsArea=0;
itsArea = itsWidth * itsHeight;
cout << itsArea;
return 0;
}
바) 상수의 선언과 사용
상수는 변수와 마찬가지로 프로그램에서의 저장 공간을 의미하지만, 이름에
서 알 수 있듯이 상수에 값을 넣으면 값을 변화 시킬 수 없다.
#define WIDTH_FACTOR 20
하지만 C++에서는 새로운 방법으로 상수를 선언할 수 있다.
const unsigned int WIDTH_FACTOR=20;
대체적으로 C++에서 상수를 선언하는 방법은 두 번째 방법을 추천한다. 두
번째 방법은 상수가 형(Type)을 가지고 있으므로 컴파일러가 그 형에 따라 고
정되어 사용되도록 하여 프로그램 상의 버그를 줄일 수 있기 때문이다.
3. 객체 지향 프로그래밍
C++이 C 언어와 가장 크게 구분이 되어지는 특징이 객체지향 프로그램이라
는 점이다. 프로그래밍 언어의 범주는 크게 절차적 언어, 구조적 언어, 객체 지
향언어로 나누어 질 수 있다. 절차적인 언어는 프로그램을 작성할 때 순차적으
로 진행을 하도록 작성을 하는 것이 특징이다. 즉 프로그램의 흐름이 절차적으
로 진행이 된다. 구조적인 언어는 C, Pascal 등에서 볼 수 있듯이 블록 단위로
작성이 된다. 특히 C에서는 함수라는 블록으로 구성이 된다.
객체 지향 언어(OOP)는 C++, Smalltalk, Java 등이 있으며 가장 편리하다는
평가를 받고 있다. 객체 지향 언어는 기존의 절차적인 언어에서 가지지 못했던
여러 가지 장점을 가지고 있으며, 여러가지 복잡한 개발 과정이나 수정 과정을
용이 하게 해주는 장점이 있다. 프로그램이 비대하게 되는 단점은 가지고 있으
나 컴퓨터의 파워가 날이 갈수록 강력해 지므로 이러한 단점은 점점 무시되어
60
지고 있다.
가)
나)
객체의 상속
객체는 생명체가 후손을 남기는 것처럼 상속을 할 수 있다. 객체가 상속을
하게 되면 상속을 받는 객체는 부모 객체로부터 메소드와 변수들을 상속 받게
된다.
자동차를 만드는 것을 예를 들어보자 새로운 차를 만들려고 할 때 아무것도
없는 무의 상태에서 자동차를 만들려고 한다면 너무나도 많은 시간과 노력이
필요 하게 될 것이다. 우선은 자동차의 형태를 결정을 해야 하고, 기본적인 자
동차에 대한 데이터를 얻기 위해 지금까지 자동차 공업에서 파생된 모든 자료
를 새로 연구하든가 다시 공부해야 할 것이다. 이러한 문제를 피하기 위해서는
기존의 모델에 수정을 가하든가, 기존의 모델에서 새로운 모델을 만든다면 노
력과 시간과 비용의 훨씬 적게 들것이다.
소프트웨어 분야에서도 마찬가지로 새로운 프로그램을 만든다고 생각을 했
을 경우에 기존의 소스에서 변형만을 가한 후에 프로그램을 만들어낸다면 프
로그램을 만드는데 드는 비용과 노력과 시간은 훨씬 줄어 들 것 이다. 객체지
향적 언어에서는 이러한 것을 상속이라는 것을 통해서 이러한 재사용성을 제공
해 준다. 또한 여기에서 모든 특성을 상속 받을 수 있으며, 또한 필요한 특성을
추가 할 수 있다.
객체를 이용 했을 때의 장점
독립적인 단위의 속성을 캡슐화라 부른다. 엔진을 예를 들자면 엔진을 사용
하기 위해서는 엔진의 동작원리나 내부 구조를 모두 알지 못하더라도 엔진을
사용 할 수는 있다. 이 것처럼 객체 지향 언어에서도 객체의 생성을 통해서 캡
슐화와 숨김의 속성을 지원한다. 잘 정의된 객체는 완전히 캡슐화된 형태로 동
작하고, 완전한 단위로 사용이 된다. 이 때 사용자는 객체의 내부를 알 필요없
이 사용하는 방법만 알면 된다.
객체에서 상속을 받게 되면 모든 특징이 상속이 된다. 하지만 상속이 된 것
만으로 충분 한 것은 아니다. 만일 이것으로 충분하다면 굳이 상속을 할 이유
도 없을 것이다. 다형성은 상속받은 객체가 상위 객체에서 가지지 못한 특성을
추가해서 새로운 기능을 추가 하게 해주는 것이다.
C에서는 헤더 파일을 포함을 시키고 함수를 이용해서 프로그램을 작성하게
61
된다. 예를 들어 문자열을 조작 하는 프로그램을 작성한다고 가정을 해볼 때
다음의 소스를 살펴 보자
#include <stdio.h>
#include <string.h>
int main(){
char text_a[256] = "Hello this is my Program";
char text_b[256] = "";
if(strcmp(text_a,text_b)!=0){
printf("This is Text_a : %s\n",text_a);
printf("This is Text_b : %s\n",text_b);
}else{
printf("This is Text : %s\n",text_a);
}
return 0;
}
이것은 C언어로 작성된 것으로 간단하게 문자열을 비교하여 출력 하는 것이
다. 다음은 C++에서 CString 객체를 이용하는 것이다.
#include <iostream.h>
#include <string.h>
int main(){
CString text_a = "Hello this is my Program";
CString text_b = "";
if(text_a != text_b){
cout << text_a << "\n";
cout << text_b << "\n";
}else{
cout << text_a << "\n";
}
return 0;
}
62
두개의 소스를 비교를 하면 분명히 두 가지 언어의 차이는 확연히 드러나게
된다. 두 번째의 C++의 소스는 CString형을 이용하여 문자열을 조작을 하는 것
이다. C에서와는 달리 문자열을 다룰 때 골치아픈 포인터나 메모리 누수, 배열
에 대한 고민이 필요없이 컴파일러에 기본적으로 제공이 되는 CString 객체를
이용하는 방법만 조금 알게 되면 문자열을 자유롭게 다룰 수 있다. 이처럼 객
체는 좀더 빠르고 편리하게 프로그램을 작성 할 수 있도록 도와 준다.
다) 객체의 생성과 이용
이번에는 클래스를 이용해서 객체를 만들어 보자. 클래스와 객체는 혼돈하
기 쉬운 개념이다. 우선은 클래스는 객체를 만들기 위한 명세, 객체는 클래스에
의해서 만들어진 실제로 동작하는 개체라고 이해하면 쉬울 것이다. 클래스도
다른 변수와 마찬가지로 선언을 해야만 사용이 가능하다. 우선 간단한 클래스
를 만들어 보면 다음과 같다.
class Cat
{
unsigned int itsAge;
unsigned int itsWeight;
Meow();
}
이것으로 아주 간단한 고양이 클래스를 만들어 보았다. 이 고양이 클래스를
이용 할 때에는 다른 변수를 이용할 때와 같다.
Cat MyCat;
이런 식으로 선언해서 사용하면 사용을 할 수 있다. 하지만 이것만 으로는 이
클래스를 이용을 할 수가 없다. 지금은 선언만 해놓았을 뿐 정의를 하지 않았기
때문이다. 위의 클래스를 사용 하도록 아래와 같이 바꿀 수 있다.
#include <iostream.h>
typedef unsigned int UINT;
class Cat{
public:
UINT itsAge;
63
UINT itsWeight;
private:
};
int main(){
Cat Frisky;
Frisky.itsAge = 5;
cout << "Frisky's Age : " << Frisky.itsAge <<"\n";
return 0;
}
라) public/private
클래스 선언에서 가장 중요한 두가지가 키워드가 바로 public/private 키워드
이다. 클래스의 모든 멤버는 기본적으로 private이며, private로 선언된 모든 변
수와 메소드는 외부에서 호출이 불가능 하며 내부적으로만 사용이 가능하다.
이것은 객체 지향 언어의 특징인 캡슐화와 은닉성을 보장해 준다. 내부적으로
만 사용하게 될 변수나 메소드들을 위해서 준비된 키워드라고 할 수 있다.
외부에서 사용할 변수나 메소드들을 위해서 준비된 키워드는 public이다.
public으로 메소드를 선언 하게 되면 외부에서 접근이 가능하게 된다.
class Cat{
public:
UINT itsWeight;
private:
UINT itsAge;
};
클래스를 다음과 같이 바꿔서 실행을 해보자. 그러면 컴파일시에 에러가 발
생 할 것이다.
Frisky.itsAge = 5;
cout << "Frisky's Age : " << Frisky.itsAge <<"\n";
이 부분에서 private로 선언이 되어있는 부분에 접근 하려 했기 때문에 생기
는 에러이다. 위 처럼 접근하기 위해서는 public으로 선언이 되어있어야 한다.
64
마) private/protected
클래스에서 private으로 선언된 멤버 변수나 메소드들은 외부에서 접근이 안
되기도 하지만 상속을 시켰을 경우에 상속이 되지 않는다. 이러한 경우에 내부
적으로만 접근을 허용해야 하는 멤버들은 상속을 시키지 못해서 문제가 발생
할 수 있다. 이때 사용할 수 있는 것이 바로 protected 키워드 이다. protected
로 선언을 해 놓으면 객체를 생성을 했을 경우에 외부에 곧바로 접근은 안되지
만 상속은 가능하게 된다. 따라서 내부 멤버지만 상속이 필요한 경우에는
protected로 선언을 하면 된다.
#include <iostream.h>
typedef unsigned int UINT;
class Mammal{
public:
void Move() {cout << "Mammal Move\n";}
void Run() {cout << "Mammal Run\n";}
void eat() {cout << "Mammal eat... \n";}
private:
UINT itsHome;
protected:
UINT itsAge;
};
class Cat : public Mammal{
public:
void Meow() {cout << "Meow... \n";}
void SetAge(UINT age) {itsAge = age;}
UINT GetAge() {return itsAge;}
void Move() {cout << "Cat Move\n";}
virtual void Run() {cout << "Cat Run\n";}
private:
UINT itsWeight;
};
65
int main(){
Cat Frisky;
Mammal M;
char a;
// Frisky.Meow();
Frisky.SetAge(5);
cout << "Frisky's Age : " << Frisky.GetAge() <<"\n";
M.Move();
M.Run();
Frisky.Move();
Frisky.Run();
cin >> a;
return 0;
}
이 소스는 앞에서의 설명을 토대로 Mammal이라는 클래스를 만들고 그 클래스를 상
속을 받아서 Cat이라는 클래스를 만드는 것을 예로 보였다. Mammal에서 하나의 멤버를
protected로 선언을 하였고 나머지는 public으로 선언을 하였다. Mammal 클래스에서는
Move(), Run(),eat() 메소드를 정의 하였고, Cat에서는 Meow()를 정의 하고 Move(),Run()
을 재정의, itsAge 변수를 상속을 받았다. Main함수에서는 이러한 것들을 확인 하고있다.
바) 메소드
메소드가 클래스와 구조체를 구분 짓는 가장 큰 특징이라고 할 수 있다. 구
조체는 변수들만의 집합이며 클래스는 변수들과 메소드라 불리는 함수를 포함
한다.
위의 고양이 클래스에서 고양이가 운다는 행동을 정의해 보자
class Cat{
public:
UINT itsWeight;
UINT itsAge;
void Meow();
private:
};
66
클래스를 위와 같이 고치고 다음 라인을 추가해 보자
void Cat::Meow()
{
cout << "Meow... \n";
}
그리고 메인 함수 부분에 다음을 추가 하자
Frisky.Meow();
이것으로 고양이가 운다라는 행동을 정의 했다. 메소드도 또한 private 키워
드로 선언이 된다면 외부에서 접근은 불가능 하다.
사) 생성자와 소멸자
정수형 변수나 문자형 변수등은 변수를 선언을 하면서 다음과 같이 초기화
가 가능하다.
Int itsAge=0;
그렇다면 클래스에 포함된 변수들은 어떻게 초기화를 시킬 것인가, 지금 위
의 소스를 가지고 테스트를 해보라 테스트를 하면 에러가 발생할 것이다. 또한
값의 초기화가 굳이 필요한지 느끼지 못하겠지만 변수를 사용하기 전에 또는
포인터를 사용하기 전에 초기화 하는 것은 매우 중요한 문제이다.
클래스에서는 생성자(constructor)라는 특수한 함수를 제공해 준다. 생성자
는 매개변수를 가질 수 있지만 반환값을 가질 수 없으며, 클래스의 이름과 같
은 이름을 가진다. 또한 생성자는 객체가 생성이 될 때 실행이 된다.
또한 생성자가 값의 초기화를 책임 진다면, 객체가 메모리 상에서 지워지기
이전에 뒷정리를 담당하는 소멸자(destructor)가 마무리를 책임진다. 소멸자는
객체가 사라질 때 실행이 되며 생성자와 마찬가지로 반환값을 가지지 않으며
클래스와 동일 이름을 가지며 이름앞에 틸트(~)가 붙는다.
앞에서 만든 고양이 클래스에 생성자와 소멸자를 붙여 아래와 같이 고칠 수
있다.
class Cat{
public:
67
Cat();
~Cat();
UINT itsWeight;
UINT itsAge;
void Meow();
private:
};
Cat::Cat(){
Cout << “Cat is Constructed…\n”;
}
Cat::~Cat(){
Cout << “Cat is Destructed…\n”;
}
void Cat::Meow(){
cout << “Meow…\n”;
}
4.
가)
함수에 관하여
C/C++에서는 함수로 시작해서 함수로 끝이 난다고 해도 과언이 아닐 정도
로 프로그램의 구조는 상위 함수와 하위 함수로 구성이 되어 있다. C/C++ 프로
그램은 main함수에서 시작 해야만 하고 또한 거기서 끝이 나야 한다. 함수를
정의하면 데이터와 작용해서 값을 반환하는 하위 프로그램이라고 할 수 있다.
함수는 내장 함수와 사용자 정의 함수가 있으며, 내장함수는 컴파일러 자체의
일부이고, 개발사에서 제공해주는 함수이다. 또한 사용자 정의 함수는 사용자가
만들어 쓰는 함수이다.
헤더파일과 함수의 관계
프로그램에서 함수를 사용하기 위해선, 먼저 함수를 선언을 하고 그 다음에
함수를 정의해야 한다. 선언은 컴파일러에게 함수의 이름과 반환 값의 형태 및
매개변수를 알리는 것이다. 어떤 함수도 먼저 선언이 되지 않으면, 어떤 다른
68
함수로부터 호출 할 수 없다. 함수의 선언은 함수의 원형(Prototype)이라고 한
다.
내장 함수를 사용하기 위해서는 우선 그 것의 원형을 포함하고 있는 헤더를
#include을 이용해서 선언을 해야 한다. 간단한 예로 아래 소스의 오류를 분석
해 봄으로써 알 수 있다.
#include <iostream.h>
int main()
{
printf(“Hello World\n”);
return 0
}
나) 함수 정의 하기
앞에서 기술했던 것처럼 함수를 사용하기 위해서는 함수를 선언하고 정의
하는 것이 필요하다. 함수를 선언하는 방법은 다음과 같다
반환타입 함수이름(매개변수);
함수를 사용하면 매개변수를 받고 반환형이 void 타입이 아니라면 반환값을
가지게 된다. 함수 블록에서 함수는 return문으로 함수의 반환값을 돌려주고 함
수를 종료하게 된다. 다음은 함수를 정의 하고 값을 반환하는 예제이다.
#include <iostream.h>
typedef unsigned int UINT;
UINT Add(UINT Value1,UINT Value2);
int main(){
UINT Total = Add(10,20);
cout << Total << "\n";
return 0;
}
UINT Add(UINT Value1,UINT Value2){
UINT TotalValue=0;
TotalValue = Value1 + Value2;
69
return TotalValue;
}
다) 함수의 오버 로딩
C++에서는 같은 이름의 함수를 정의해서 쓸 수 있도록 한다. 함수의 오버
로딩(overloading)이라고 하는 방법을 제공한다. 이경우에는 함수를 구분을
할 때에는 매개변수로 구분을 한다. 즉 함수의 매개 변수형이나 매개변수의
갯수에 따라 함수를 구분 할 수 있다.
#include <iostream.h>
typedef unsigned int UINT;
UINT Add(UINT Value1,UINT Value2);
UINT Add(UINT Value1,UINT Value2,UINT Value3);
}
int main(){
UINT Total = Add(10,20);
cout << Total << "\n";
return 0;
}
UINT Add(UINT Value1,UINT Value2){
UINT TotalValue=0;
TotalValue = Value1 + Value2;
return TotalValue;
}
UINT Add(UINT Value1,UINT Value2,UINT Value3){
UINT TotalValue=0;
TotalValue = Value1 + Value2 + Value3;
return TotalValue;
}
70
부 록
A. 연산자
종 류 내 용
산술연산자
* : 곱셈
/ : 나눗셈
% : 나머지 계산
+ : 덧셈
- : 뺄셈
관계 연산자
> : ~보다 크다.
>= : ~보다 크거나 같다.
< : ~보다 작다.
<= : ~보다 작거나 같다.
== : 같다.
!= : 다르다.
논리 연산자
| (단항) : 부정(NOT)
&& (이항) : 그리고(AND)
|| (이항) : 또는(OR)
3 항 연산자
((조건식)? a:b);
a : 조건식이 참일 때 수행 할 내용
b : 조건식이 거짓일 때 수행 할 내용
증감연산자
++a : a값에 먼저 1 증가시킨 후 계산
a++ : a값을 먼저 계산한 후 1 증가
--a : a값을 먼저 1 감소시킨 후 계산
a-- : a 값을 먼저 계산 후 1 감소
71
B. 입출력 함수
종 류 의 미
scanf( )
표준입력함수로 키보드를 통해 입력
숫자 또는 단일 문자 변수에 값을 읽어 들이려면 변수
앞에 '&'를 붙임
getchar( ) 한 문자 입력
gets( ) 문자열 입력
printf( ) 표준 출력함수
putchar( ) 한 문자 출력함수로, 출력 후 개행하지 않음
puts( ) 문자열 출력함수로, 출력 후 자동개행
72
73
C. 제어문
명 령 내 용
goto 무조건 분기
break
for, while, do~while, switch 문과 같은 반복문이나
조건문 수행 중 범위를 완전히 벗어나고자 할 경우
사용
continue 반복문에서 continue 문을 만나면 continue 문 이후
문장을 무시하고, 반복 조건식으로 제어권을 이동
if~else if 문의 조건식이 맞으면 if 문 다음 문장을 수행하고,
틀리면 else 다음 문장을 수행
switch~case 각각의 조건(case)에 따른 처리를 하고자 할 경우 사용
for 조건식이 만족하지 않을 때까지 for 문 안의 내용을
반복
while
조건식이 만족하는 동안 while 문 안의 내용을 반복
수행(조건이 만족하지 않으면 한 번도 수행하지 않을
수도 있음)
do~while 일단은 한 번 수행한 후 조건식이 만족하는 동안
while 문 안의 내용을 반복 수행
