2.5. 꼭 알아야 할 C++언어의 문법
2.5. 꼭 알아야 할 C++언어의 문법
이제 프로그램을 만드는 일이 그렇게 어려운 일이 아니라는 사실을 아셨을 겁니다. C++언어의 문법에 맞게 프로그램을 짜기만 하면 되는 겁니다. 기계가 이해할 수 있는 말로 번역해주는 일은 컴파일러가 해주기 때문에 사람은 사람이 알아들을 수 있게 프로그램을 짜면 됩니다. 물론 영문법을 배워서 영어문장을 쓰는 일이 쉽지 않은 것처럼 C++언어문법을 배워서 C프로그램을 짜는 일도 쉬운 일은 아닙니다. 'I am a boy.'라는 간단한 문법은 쉽게 배워서 금방 응용할 수 있겠지만 점점 더 복잡한 문장으로 갈수록 영어작문이 어려워지는 것처럼 C++언어로 프로그램을 짜는 일도 점점 복잡해지고 어려워지기 때문입니다.
그러나 대부분이 사람들이 짜고자 하는 프로그램은 간단하고 이런 간단한 프로그램 짜는 일은 그렇게 어려운 일이 아닙니다. 아주 복잡하고 어려운 프로그램을 짜려면 일 년 이 년을 배워도 부족할 수 있지만 자신에게 필요한 간단한 프로그램을 짜는 일은 며칠만 배워도 가능할 수 있습니다. 십 년 동안 영어를 배웠지만 말 한 마디 제대로 못하는 것과 마찬가지로 몇 년 동안 C++언어를 배워도 제대로 된 프로그램 하나 짜지 못할 수 있습니다. 반대로 불과 몇 주일만에 기가 막힌 프로그램을 만들 수도 있습니다. 이것은 얼마나 집중력 있게 깊이 파고드느냐에 달린 문제입니다.
하여간 이제 제대로 된 프로그램을 만들기 위해서 기본적인 문법을 익혀나가겠습니다. 그러나 이 책에서 설명한 내용만으로는 C++언어의 100분의 1도 배우지 못할 겁니다. 이 책은 언어에 대한 기본적인 개념을 설명하는데 목적을 두었기 때문입니다. 단지 이 책을 통해서 여러분들이 언어에 대한 두려움을 없앨 수 있다면, 그리고 프로그램을 짜는 일이 신기하면서도 재미있는 작업이라는 인식을 가진다면 저로서는 큰 보람을 느낄 겁니다. 자 그럼 C++언어의 기본문법으로 들어가겠습니다.
2.5.1. 소스파일과 기본문법
소스파일은 C++언어 문법에 맞게 짜야 합니다.
C++언어로 프로그램을 짠다는 말은 C++언어로 소스파일을 만든다는 뜻입니다. 그리고 이렇게 만든 소스파일을 컴파일하고 링크시켜서 실행파일을 만듭니다. 이때 소스파일은 C++언어의 문법에 맞게 만들어야 합니다. 만약 문법에 맞지 않는 구절이 단 한 글자라도 있다면 컴파일이나 링크시에 에러가 발생합니다. 문제가 발생한다는 뜻입니다. 때로는 컴파일이나 링크까지도 잘 되지만 실행시에 문제가 발생하기도 합니다. 또 프로그램 실행시에도 문제는 발생하지 않지만 엉뚱한 결과를 내는 경우도 있습니다.
컴파일할 때 에러가 발생하는 것은 주로 C++언어 문법에 맞지 않게 짰을 때 나오는 에러입니다. 링크시에 에러가 나오는 것은 주로 주변 부속파일을 빼먹고 링크시켰을 때 나타납니다. 그리고 실행시에 에러가 발생하는 이유는 프로그램을 논리적으로 짜지 않았기 때문에 생기는 논리적인 에러입니다.
마지막으로 원하는 결과가 나오지 않고 엉뚱한 결과가 나올 때는 프로그램을 엉뚱하게 짰기 때문입니다. 예를 들어서 2개의 숫자를 입력받아서 더한 결과를 보여주도록 프로그램을 짜려면 'a+b'라는 공식을 집어넣어야 하는데, 'a*b'라고 엉뚱한 공식을 넣었다고 합시다. 이럴 경우에 프로그램을 실행시키면 두 숫자의 곱이 결과로 출력될 겁니다.
그래서 소스파일을 만들 때는 문법에 틀린 것이 없나 꼼꼼하게 살펴봐야 합니다. 그러나 프로그램의 길이가 길어질수록 이 일은 매우 어려운 일이 됩니다.
**요약: 소스파일은 C++언어 문법에 맞게 작성해야 합니다. 컴파일할 때 에러가 발생하는 까닭은 문법에 맞지 않게 짜서이고, 링크할 때 에러가 발생하는 이유는 부속파일을 빼먹었기 때문입니다. 실행파일의 결과가 잘못 나오는 이유는 논리적으로 잘못 작성했기
때문입니다.
먼저 소스파일에 관한 가장 기본적인 문법을 몇 가지 알아보겠습니다.
1. 소스파일의 이름은 마음대로 정해도 되지만 확장자는 C나 CPP로 정합니다. C로 정할 경우에는 컴파일러에서는 C언어의 소스파일로 인식하며 CPP로 정할 경우에는 C++언어의 소스파일로 인식합니다.
2. 소스파일은 반드시 main() 이라는 이름을 가진 함수를 가지고 있어야 합니다.
3. 소스파일의 첫머리에는 프로그램 실행시 필요한 헤더파일을 적어주어야 합니다. 헤더파일을 적어주는 형식은
'#include <헤더파일이름>' 입니다. 헤더파일은 확장자가 H로 되어 있습니다.
4. 함수를 알리는 함수선언문이라면 이름 뒤에 둥근괄호를 열고 닫습니다.
5. 함수의 본체 시작을 알리는 기호는 { 고, 함수 본체의 끝을 알리는 기호는 } 입니다. 함수는 본체를 가질 수도 있지만 안 가질 수도 있습니다.
6. 함수 안에 또 다른 함수를 사용할 수 있습니다.
7. 명령어나 함수는 명령의 끝을 알리기 위해 명령문의 끝에 ; 기호를 넣어주어야 합니다.
8. 프로그램 실행과 관련은 없지만 프로그램의 내용을 쉽게 알아볼 수 있도록 주석을 달 수 있는데, 주석문 기호로는 /* */과 //를 사용합니다. /* */ 기호를 사용할 경우 주석의 시작을 알리는 기호는 /* 이고, 끝을 알리는 기호는 */ 입니다. 컴파일러는
/* 기호와 */ 기호 사이의 모든 문장을 주석문으로 이해하고 컴파일합니다. // 기호를 사용할 경우에는 // 기호 다음의 줄 끝까지 문장을 주석문으로 해석합니다. 주석문은 소스파일의 어느 곳에 적어도 상관 없습니다.
/* 기호와 */ 사이에 주석문을 달 수 있습니다.
위에서 말한 내용은 가장 기본적인 내용입니다. 위의 말만으로는 이해가 되지 않을테니 앞서 만든 test001.c 파일을 보기로 들어서 설명하겠습니다.
test001.c 파일의 두번째 줄은 아래 문장입니다.
/* TEST001.C -- Hello, Kim Joongtae. */
이 문장은 /* 로 시작합니다. 그리고 끝에는 */이 붙어 있습니다. 그러니까 8번에서 제가 말한 내용에 해당합니다. 프로그램 실행시에는 아무런 영향을 미치지 않고 단지 프로그램을 짜는 사람이 알아보기 편하게 달아둔 주석 문장입니다. 다시 말해서 /*와 */ 사이에 들어간 'TEST001.C -- Hello, Kim Joongtae.'라는 문장은 제가 이 파일에 대한 내용을 나중에 이해할 수 있도록 설명을 달아둔 내용입니다.
test001.exe 파일을 실행시켜봐서 알겠지만 test001.exe에서는 'TEST001.C -- Hello, Kim Joongtae.'라는 문장이 화면에 나오지 않습니다. 이처럼 프로그램 실행과 아무련 상관이 없이 단지 프로그래머의 기억력을 돕기 위하여 사용하는 문장을 주석문이라고 합니다.
주석문은 주로 나중에 프로그램을 다시 봤을 때 이해하기 어려운 명령문 뒤에 많이 씁니다. 자신이 짠 프로그램이라고 하더라도 나중에 보면 왜 그렇게 짰는지 이해하기 어려울 때가 있습니다. 그때를 대비해서 '이 명령문은 이런이런 일을 수행하는 명령문이다'라고 적어두면 나중에 큰 도움을 받습니다. 따라서 가능하면 주석문을 많이 다는 습관을 가지는 것이 좋습니다.
/* */ 기호는 한 쌍을 이루어 사용하는데 컴파일러는 /* 기호와 */ 기호 사이에 들어간 모든 문장을 주석문으로 받아들입니다. 따라서 /* 기호가 시작된 후로 몇 줄이 포함된다 하더라도 상관 없이 */ 기호가 나오기 전까지의 모든 문장은 주석문으로 처리됩니다.
C++에서는 // 기호를 이용해 주석문을 달 수도 있습니다.
C에서는 /* */ 기호만 주석문 기호로 사용하지만 C++에서는 주석문의 종류가 하나 더 추가되었습니다.
// 이라는 기호입니다. 이 기호는 줄의 첫번째 칸에 사용하며 // 기호 다음의 문장은 줄 끝까지만 주석문으로 처리됩니다. 주의할 점은 // 기호가 사용된 줄의 끝까지만 주석문으로 처리되고 다음줄 부터는 주석문으로 처리되지 않는다는 점입니다.
test001.cpp의 '// TEST001.CPP -- Hello, Kim JoongTae'라는 문장에 사용된 // 기호는 그 줄의 끝까지만 영향을 미칩니다. 따라서 그 다음 줄에 나오는 '#include <stdio.h>' 문장은 주석문으로 처리되지 않고 명령어로 처리됩니다.
또 test001.c의 첫번째 줄은 '// Borland C++ - (C) Copyright 1991, 1992 by Borland International'이라는 문장입니다. 이 문장은 '/* Borland C++ - (C) Copyright 1991, 1992 by Borland International*/'이라는 문장과 동일합니다.
이런 류의 주석문은 클리퍼와 같은 데이터베이스 프로그램에서 많이 사용하는 주석문입니다. /* 기호로 열고 */ 기호로 닫아야 하는 불편이 없기 때문에 // 기호도 많이 사용합니다.
#include 명령어는 헤더파일을 포함시키라는 명령입니다.
test001.c의 세번째 줄에는 다음과 같은 문장이 있습니다.
이 줄은 stdio.h라는 이름의 헤더파일을 포함하라는 명령어입니다. #include라는 명령어가 헤더파일을 포함하라는 명령어고, 이어서 한 칸을 띄우고
헤더파일은 함수에 관한 정보를 담아놓은 파일입니다.
헤더파일이라는 것은 C의 함수를 사용하기 위한 여러 가지 함수에 관한 각종 정보를 담아놓은 파일이라고 생각하시면 됩니다. C 라이브러리 책을 사서 보시면 모든 함수는 어떤 헤더파일에 반드시 속해 있습니다. 이 말은 헤더파일에 그 함수에 관한 정보를 적어놓는다는 뜻입니다. 그래서 자신이 사용하려는 함수에 대한 정보가 어떤 헤더파일에 적혀있나를 알아본 뒤에 그 함수의 정보를 포함하고 있는 헤더파일을 프로그램의 첫머리에 실어주어야 합니다. 이렇게 하면 C 프로그램은 컴파일할 때 헤더파일을 찾아서 함수에 대한 정보를 얻습니다. 그리고 그 정보를 바탕으로 해서 사용자가 적은 함수명령문이 틀렸나 맞았나 확인합니다.
소스파일은 반드시 main() 함수를 포함해야 합니다.
다음 문장은 아래와 같습니다.
int main()
이 문장은 C로 프로그램을 짤 때 결코 빼먹어서는 안되는 중요한 문장입니다. main()함수를 시작한다는 뜻입니다. C++언어로 만든 소스파일은 반드시 하나 이상의 함수를 포함해야 하는데, 그중에서도 main()이라는 이름을 가진 함수는 반드시 필요합니다. 모든 프로그램의 시작은 main()에서 시작하도록 정했기 때문입니다.
함수 이름 뒤에는 ()를 붙입니다.
main() 함수 이름 앞에 int를 붙인 것은 함수의 데이터형이 int형이라는 뜻입니다. 그리고 main뒤에 ()를 붙였죠. 이 둥근괄호는 main이 함수임을 뜻하는 말입니다. 그러니까 test()라고 하면 test라는 함수가 되는 겁니다. 언어를 처음 배우는 분은 데이터형이 무엇인지 함수가 무엇인지 쉽게 이해되지 않을텐데 이 역시 조금 뒤에 설명드리겠습니다.
함수 본체는 { 기호로 시작합니다.
다음 문장은 아래와 같습니다.
{
{ 표시는 함수의 본체가 시작된다는 것을 알리는 기호입니다. main()은 함수의 이름입니다. 그리고 main() 함수를 시작한다는 뜻을 가지고 있습니다. 그러나 함수의 이름만으로는 아무 것도 하지 못합니다. 본체가 있어야 합니다. 괄호 안에 본체가 들어있는 함수도 있는데 이런 경우에는 { 괄호를 이용해서 본체를 만들어줄 필요가 없습니다. 그러나 괄호 안에 함수 본체를 넣은 함수가 아니라면 본체를 작성해주어야 합니다. 그리고 그 본체의 시작은 { 기호로 알려줍니다. 따라서 { 다음에 나오는 문장은 함수의 본체에 들어 있는 명령어들이 되는 겁니다.
함수 속에 또 다른 함수를 포함시킬 수 있습니다.
다음 문장은 아래와 같습니다.
printf("Hello, Kim JoongTae.\n");
이 문장은 main() 함수의 본체 속에 들어 있는 또 다른 함수입니다. 조금 복잡해보이는 문장이지만 가만 살펴보면 printf라는 이름을 가진 함수라는 것을 알 수 있을 겁니다. 다만 printf()라는 함수의 둥근 괄호 안에 명령문이 들어가 있는 것에 불과합니다. 또는 printf() 함수 안에 함수 본체가 들어 있다고 보셔도 됩니다. printf() 함수는 괄호 안에 있는 내용을 화면에 출력하라는 명령을 실행하는 함수입니다.
객체는 함수와 같은 기능을 수행할 수 있습니다.
그런데 test001.cpp에서는 위의 명령어 대신에 다음과 같은 명령문을 사용했습니다. 그러나 결과는 똑 같이 나왔습니다.
cout는 함수가 아니라 '표준 출력 장치 객체'입니다. 이 말은 이해하기 무척 어렵습니다. 우선 객체라는 말을 이해하기가 어렵고 표준 출력 장치라는 말도 초보자가 이해하기 어렵습니다. C++언어에서는 클래스를 이용한 입출력 스트림을 제공하는데 이 중에서 출력용 스트림에 해당하는 것이 cout 입니다. 클래스를 이용했기 때문에 cout는 객체입니다. 객체와 클래스에 대해서는 이 책의 마지막 장에서 다루게 됩니다. 그때까지는 cout라는 스트림을 이용한 출력 객체의 존재를 사용하기만 할 뿐 어떤 식으로 작용하는지 설명드리지 않습니다. 다만 printf()함수의 기능과 같다는 정도만 알고 넘어가시면 됩니다.
<< 기호는 C언어에서는 왼쪽으로 밀기 비트 연산자였습니다. 그러나 C++언어에서는 기능이 추가되어 출력방향을 지시하는 연산자로 사용합니다. 도스에서 리다이렉션(redirection) 기능을 사용했던 분들은 쉽게 이해할 수 있지만 도스의 리다이렉션 기능을 모르는 분은 이해하기 어려운 개념입니다.
하여간 << 기호는 어떤 내용을 출력해주는 연산자입니다. << 기호는 화살표 방향대로 출력합니다. 그러니까 << 기호는 오른쪽에 있는 내용을 왼쪽으로 출력해주는 기능을 뜻하는 연산자입니다.
따라서 'cout<<"Hello, Kim JoongTae."'라는 명령문이 있다고 하면 "Hello, Kim JoongTae."라는 문장 내용을 cout라는 객체로 출력하라는 뜻입니다. 그런데 cout는 표준 출력 객체로 모니터가 표준 출력 방향으로 설정된 상태입니다. 그래서 "Hello, Kim JoongTae."라는 문장이 모니터로 표시됩니다.
예문을 통해서 짐작하겠지만 cout라는 문장은 << 연산자와 따로따로 생각할 수 없습니다. cout라는 객체에 어떤 내용을 넣어주기 위해서는 << 연산자가 필수적이기 때문입니다. 때문에 cout는 cout<<와 같은 형식으로 사용한다고 그냥 외워두는 것이 편합니다. 그리고 'cout<<내용'의 형식으로 사용하면 << 기호 오른 쪽의 내용을 모니터로 보여주는 명령문이구나 하고 이해하기 바랍니다.
printf()함수는 C언어에서부터 제공되던 명령문이지만 cout와 << 연산자는 C++언어에서부터 제공되는 명령문입니다.
; 기호로 문장의 끝을 알려줍니다.
함수나 명령어의 끝에는 ; 표시가 되어 있습니다. 이를 통해서 이 문장의 끝을 알려주는 겁니다. 즉 명령이 끝났음을 알리는 것입니다. 다시 한 번 말하지만 모든 명령어 뒤에는 ; 표시를 넣어주어야 합니다. 그래야만 컴파일러가 명령문의 끝이라는 것을 알고 다음 명령문을 컴파일하기 위해서 넘어가기 때문입니다. 물론 경우에 따라서는 ; 표시를 하지 않는 명령문도 있습니다. 그러나 그런 경우는 예외적인 경우이므로 기본적으로는 ; 표시를 해야 한다고 생각하셔야 합니다.
return 0;이라는 문장을 통해 복귀값을 알려줍니다.
다음 문장에는 'return 0;'이 있습니다. 이 문장이 뜻하는 내용은 함수의 복귀값 또는 반환값이 0이라는 뜻입니다. 복귀값이란 함수가 처리한 결과내용을 함수를 호출한 프로그램에게 알려주는 값입니다. 그러니까 test()라는 함수 안에서 test2()라는 함수를 사용했다면 test2()라는 함수가 처리한 결과를 test() 함수에게 알려주어야 하는데 이때 사용하는 값입니다. 이 역시 나중에 자세하게 다루겠습니다.
{ 기호로 시작한 함수 본체는 } 기호로 닫아주어야 합니다.
마지막 줄은 아래와 같습니다.
}
이것은 설명하지 않아도 아실 수 있을 겁니다. 함수의 끝을 알리는 기호입니다. 앞서 main()함수 이름이 나오고 { 기호가 나왔으므로 본체의 끝을 알리는 기호를 반드시 넣어주어야 합니다. 그리고 main()이라는 함수는 {} 사이에 명령문을 포함한 본체를 가지고 있지만 printf()함수는 본체를 안 가지고 있습니다. 그래서 함수는 본체를 가질 수도 있고 안 가질 수도 있습니다.
본체란 함수의 정의를 담은 부분을 말하는데, 엄밀하게 이야기하면 어느 함수나 본체를 가지고 있습니다. 본체 없이 이름만 가지고 무슨 기능을 수행하겠습니까. 그러나 프로그램 내에서 본체의 모습이 보이지 않는다면 일단 본체가 없는 함수로 받아들이면서 진행하도록 하겠습니다. 간단한 명령을 실행하는 함수라면 본체가 필요 없습니다. 주로 본체가 필요한 함수는 한 줄로 실행하기 어려운 복잡한 기능을 수행하는 함수들입니다.
확장자는 반드시 *.C나 *.CPP로 붙여야 합니다.
이상의 내용으로 C++언어의 문법에 맞게 소스파일을 만들었습니다. 그리고 마지막으로 이 파일을 test001.c라는 이름으로 저장했습니다. 나중에 만든 소스파일은 test001.cpp로 저장했습니다. C언어에서는 C언어로 된 소스파일의 확장자가 C였습니다. 그러나 C++언어에서는 CPP를 사용합니다.
때문에 확장자가 C이면 컴파일러 프로그램은 C언어 소스파일로 이해하고, 확장자가 CPP이면 C++언어 소스파일로 이해하고 컴파일을 실행합니다. 확장자가 C이면 C언어 프로그램에서도 컴파일이 가능합니다. 또한 C++언어 프로그램에서도 컴파일이 가능합니다. 그러나 확장자가 CPP이면 C++언어 프로그램에서만 컴파일이 가능합니다. 물론 확장자가 C로 되어 있다 하더라도 CPP에서만 사용할 수 있는 문법이 들어있다면 C언어 프로그램에서 컴파일이 되지 않습니다. 컴파일 도중에 에러가 발생합니다.
하여간 이상의 문법규칙을 지키면서 프로그램을 짠다면 컴파일러는 여러분이 짠 소스파일을 아무 이상 없이 컴파일해줄 것이고, 여러분은 exe 파일을 얻을 수 있을 겁니다.
**요약: C++언어로 짠 소스파일은 C나 CPP라는 확장자를 붙여야 하며, 반드시 main() 이라는 이름을 가진 함수를 가지고 있어야 합니다. 함수는 이름 뒤에 ()를 붙여야 하며 , 본체는 { 기호와 } 기호 사이에 가질 수 있고, 다른 함수를 함수 안에 포함시킬 수
있습니다. 명령문의 끝은 ; 기호로 나타냅니다. /*과 */ 사이에 주석문을 넣을 수 있으며, // 기호 다음에 주석문을 넣을 수 있습니다.
2.5.2.함수란 무엇인가?
함수는 명령을 처리해서 결과물을 생산해주는 도구입니다.
'함수란 무엇인가?'를 제대로 이해하는 사람이라면 언어의 절반 이상은 이해하고 있다고 생각합니다. 그만큼 '함수'라는 개념은 중요합니다. 언어는 함수로 시작해서 함수로 끝난다는 말이 결코 과장이 아닐 정도로 함수는 중요한 비중을 차지하고 있습니다. 사실상 우리가 언어를 배우는 시간의 대부분을 함수를 배우는 시간에 투자하고 있으며, 우리가 프로그램을 만드는 시간의 대부분도 함수를 만드는 일에 투자하고 있기 때문입니다. 그렇다면 과연 함수란 무엇인가?
함수를 명쾌하게 한 마디로 설명하기는 어렵습니다. 그러나 간단하게 말하자면 명령을 처리해서 어떤 결과물을 생산해주는 도구 또는 명령어의 집합체라고 말할 수 있습니다.
printf() 함수를 두 번 사용하는 소스파일을 만들어봅니다.
test001.c에서는 함수를 두 개 사용했습니다. main()이라는 함수와 printf()라는 함수입니다. main()이라는 함수는 사실상 프로그램 전체나 다를 바 없는 큰 함수입니다. 이 함수는 printf()라는 함수를 이용해서 'Hello, Kim JoongTae.'라는 문장을 보여주는 함수입니다.
printf() 함수는 ()안의 문장을 화면으로 출력해주는 함수입니다. 즉 printf() 함수는 ()안에 넣어준 내용을 화면으로 보여주도록 명령을 처리하는 함수입니다.
파일메뉴에서 New 메뉴를 선택하면 새로운 소스파일을 입력할 수 있습니다.
그렇다면 다음과 같이 printf() 함수를 하나 더 삽입해서 프로그램을 만들어봅시다. 불러오기로 앞서 만든 test001.c를 불러온 다음에 내용을 추가하는 방법을 사용하면 됩니다.
아예 새로운 파일을 만들 수도 있습니다. File메뉴를 선택하거나 [Alt]+[F]를 누른 다음, New 메뉴를 선택하면 빈 화면으로 바뀝니다. 이 상태에서 아래의 내용을 모두 다시 입력하는 방법을 써도 됩니다.
고친 파일을 test002.c로 저장합니다.
그리고 이 함수를 test002.c라는 이름으로 저장하기 바랍니다. 새이름으로 저장하는 방법은 이미 앞에서 배웠습니다. 기억이 안나시는 분은 앞장을 다시 참고하기 바랍니다. BC나 BCW에서는 File 메뉴에서 'Save as'를 선택한 다음에 test002.c라고 적으면 됩니다.
^^^그림: test001.c를 수정해서 test002.c 파일로 저장합니다.
이제 test002.c로 저장이 되었다면 이 프로그램을 컴파일하고 링크한 다음에 실행해봅시다. [Ctrl]+[F9]를 동시에 누르면 됩니다. 그리고 제대로 실행이 되었나 보기 위해서 [Alt]+[F5]를 눌러 사용자화면으로 넘어갑시다. [Alt]+[F5]를 눌렀을 때 나오는 화면은 사용자화면이라고 해서 조금전에 사용자가 만들어서 실행시킨 프로그램의 최종화면을 보여주는 화면입니다.
이제 BC를 끝내고 도스로 나가서 dir 명령어로 test2.exe가 만들어졌나 살펴봅시다. test002.exe를 발견했다면 프로그램을 실행시켜 보십시요. 다음과 같은 문장이 화면에 나올 겁니다.
^^^그림: test002.exe를 도스에서 실행시킨 화면
printf() 함수는 괄호 안의 문장을 출력해주는 함수입니다.
이제 printf()함수가 어떤 기능을 수행하는 함수인지 알 수 있을 겁니다. 괄호 안에 넣은 문장을 화면에 출력하는 기능을 합니다. 따라서 우리가 화면으로 보여주고 싶은 문장이 있다면 printf()함수를 이용해서 괄호 안에 원하는 문장을 적기만 하면 됩니다.
그리고 test001.c에서 main()함수는 'Hello, Kim JoongTae.'라는 문장만 보여주는 함수였지만 이제는 두 개의 문장을 보여주는 함수가 되었습니다. 즉 printf()함수는 C언에서 제공하는 기본함수지만 main()함수는 우리가 기능을 바꿀 수 있는 함수입니다.
**요약: 함수란 주어진 역할대로 명령을 수행하는 작은 프로그램, 또는 명령을 수행해서 결과물을 생산하는 명령어의 집합체 또는 도구라고 할 수 있습니다.
BCW에서도 같은 내용으로 수정해 test002.c로 저장, 실행합니다.
BCW에서도 앞서 설명한 것과 똑 같은 내용으로 고친 후에 test002.c로 저장하기 바랍니다.
^^^그림: 화면과 같이 고친 후 test002.c로 저장합니다.
[Ctrl]+[F9]를 눌러 실행시키면 다음 화면과 같이 test002.exe가 실행됩니다.
^^^그림: test002.exe가 독립된 창으로 실행된 화면
2.5.3.비주얼C++에서 test001.cpp를 test002.cpp로 저장하기
이쯤에서 비주얼C++에서 작업중인 파일을 다른 이름으로 저장하는 방법을 알아보겠습니다.
먼저 test001.cpp를 불러옵니다. 그런 뒤에 조금전에 '볼랜드C++ 3.1'에서 고친 test002.c와 마찬가지로 고칩니다. 즉 아래와 같이 내용을 수정합니다.
^^^그림: test001.cpp의 내용을 고칩니다.
내용을 고치더라도 제목막대에는 test001.cpp로 나옵니다. 수정된 파일을 다른 이름으로 저장하려면 File 메뉴를 선택하고 'Save As' 메뉴를 선택합니다.
^^^그림: File 메뉴 중에서 'Save As' 메뉴를 선택합니다.
Save As 메뉴를 선택하면 '다른 이름으로 저장' 창이 나타납니다.
^^^그림: '다름 이름으로 저장' 창이 나타납니다.
파일이름을 'test002.cpp'로 고칩니다. 또는 'test002.c'로 고쳐도 좋습니다. 파일이름을 고쳤으면 '저장(S)' 아이콘을 눌러서 저장을마칩니다.
^^^그림: 파일이름을 test002.cpp로 고치고 '저장(S)' 아이콘을 누릅니다.
새로운 이름으로 저장을 마치고 나면 맨 위의 제목막대 부분에 표시되는 파일 이름이 'test002.cpp'로 바뀝니다. 이렇게 해서 수정된 파일을 다른 이름으로 저장할 수 있습니다.
이후 컴파일하고 실행하는 과정은 앞서 설명드린 hello.c나 test001.cpp를 실행하는 과정과 동일합니다.
비주얼C++의 사용법은 여기까지만 설명을 드리겠습니다. 파일을 만들고 저장하고, 고치고, 다른 이름으로 저장하고, 컴파일, 링크, 실행하는 방법까지 설명을 드렸으므로 더 이상의 설명은 필요없을 것으로 생각합니다. 이후에 나오는 예제는 '볼랜드C++ 3.1'에서도 컴파일이 되지만 비주얼C++에서도 컴파일이 됩니다. 따라서 이후 나오는 예제는 볼랜드C++의 화면을 기준으로 설명드리지만 비주얼C++ 사용자분에게도 똑 같이 적용되는 내용이라고 생각하고 책을 읽으시면 됩니다.
^^^그림: 제목막대 부분의 파일이름이 'test002.cpp'로 바뀌었습니다.
[연습문제]
test001.cpp의 소스파일 내용을 고쳐서 ex01.cpp로 저장합니다. 프로그램의 실행결과는 첫번째 줄에 'My name is Kim JoongTae.'라는 문장이 나오고, 두번째 줄에는 'This 2nd Line.'라는 문장이 나오고, 세번째 줄에는 'This 3rd Line. End.'라는 문장이 나오도록 합니다. 단 첫번째 줄과 두번째 줄을 화면에 보여주기 위하여 cout 명령을 사용하며, 세번째 줄을 보여줄 때는 printf() 함수를 이용합니다.
[연습문제 정답]
// EX01.CPP -- cout와 printf() 함수로 문장 보여주기
#include <stdio.h>
#include <iostream.h>
void main(void)
{
cout<<"My name is Kim JoongTae.\n";
cout<<"This 2nd Line.\n";
printf("This 3rd Line. End.\n");
}
test001.cpp의 소스파일 내용을 고쳐서 ex01.cpp로 저장합니다. 프로그램의 실행결과는 첫번째 줄에 'My name is Kim JoongTae.'라는 문장이 나오고, 두번째 줄에는 'This 2nd Line.'라는 문장이 나오고, 세번째 줄에는 'This 3rd Line. End.'라는 문장이 나오도록 합니다. 단 첫번째 줄과 두번째 줄을 화면에 보여주기 위하여 cout 명령을 사용하며, 세번째 줄을 보여줄 때는 printf() 함수를 이용합니다.
[연습문제 정답]
2.5.4.사용자정의 함수란 무엇인가?
사용자정의 함수란 사용자가 직접 만든 함수를 말합니다.
그럼 아예 사용자정의 함수를 하나 만들어보겠습니다. 사용자정의함수라는 것은 사용자가 직접 만드는 함수를 뜻합니다. 즉 C++언어나 '볼랜드C++ 3.1'에서 제공하는 함수가 아니라는 뜻입니다. BC나 BCW를 이용하여 아래와 같이 문장을 작성한 다음에 test003.c로 저장하시고 컴파일, 링크해봅니다.
^^^그림: BC에서 작성한 test003.c 소스 파일
^^^그림: BCW에서 작성한 test003.c 소스 파일
test003.c의 main()함수는 아래와 같이 3개의 함수를 포함하고 있는 문장입니다. 세 개의 함수는 prinftf()함 수 두 개하고, kim()함수입니다.
직접 만든 kim() 함수가 사용자정의 함수입니다.
그리고 main()함수 밑에는 kim()이라는 함수가 있습니다. 이 kim()함수는 본체가 있는데, 이 본체는 printf()함수를 포함하고 있습니다. 결과만을 놓고 본다면 아래의 두 명령어는 같은 일을 하는 셈입니다.
kim(); = printf("This is Kim's function. \n");
그러나 개념상으로 매우 중요한 차이점이 있습니다. kim()이라는 함수는 사용자가 직접 만든 함수이기 때문입니다. 함수 이름도 kim으로 따로 만들었고 함수 본체도 따로 만들었습니다. kim()함수를 다시 한 번 살펴보면서 처음 말했던 기본문법을 몇 가지 되새겨보겠습니다.
kim();는 kim() 함수를 실행하라는 뜻이고 kim()는 kim() 함수의 본체임을 뜻합니다.
main()함수 안에서는 kim(); 이라고 썼습니다. 이 말은 kim()함수를 실행하라는 뜻입니다. 끝에 명령의 끝을 나타내는 ; 기호가 들어갔기 때문입니다.
그러나 mai()함수 밑에서는 kim()이라고만 썼습니다. ; 기호를 안 쓴 이유는 kim()함수를 실행하라는 뜻이 아니고, kim()함수를 선언한 것이기 때문입니다. 선언했다는 뜻은 매우 중요한 의미를 담고 있습니다. kim()이라는 함수가 이제 사용될 것이라는 뜻을 지니기 때문입니다.
kim다음에 ()를 붙여씀으로써 kim()이라는 함수임을 선언한 것입니다. 그리고 이어서 kim()함수의 본체가 따라옵니다. 함수 본체는 앞서 말씀드린대로 { 기호로 시작하고 } 기호로 끝납니다. 그리고 그 사이에 여러 가지의 함수가 다시 포함되기도 하고 명령어들이 포함되기도 합니다.
이와 같이 기본적인 문법만 그대로 지킨다면 사용자정의 함수를 만드는 일이 그렇게 어려운 일이 아닙니다. 프로그램을 짠다는 것은 곧 C언어나 C언어 프로그램에서 제공하는 함수를 이용해서 사용자정의 함수를 자꾸 만들어나가는 과정이라고 할 수 있습니다.
**요약: 사용자정의함수란 사용자가 직접 만들어서 사용하는 함수를 뜻합니다. C++언어에서 사용하는 기초적인 함수는 기본함수라고 말하며 C언어 프로그램에서 제공하는 기본함수는 보통 내장함수라고 말합니다.
^^^그림: 도스용 실행파일인 test003.exe를 실행시킨 화면
^^^그림: 윈도용 실행파일인 test003.exe를 실행시킨 화면
[연습문제]
test003.c의 소스파일 내용을 고쳐서 ex02.cpp로 저장합니다. test003.c의 main()함수 안에서 kim() 함수를 실행시킨 다음 줄에 park()이라는 사용자정의 함수를 실행시키도록 만듭니다. 물론 이를 위해서는 park()이라는 사용자정의 함수를 만들어야 합니다.
park() 함수는 'This is Park's function.'이라는 내용을 보여주는 함수로 만듭니다. 단 문장을 보여주는 명령어로 cout 명령을 이용합니다.
[연습문제 정답]
// EX02.CPP -- 사용자정의 함수 park() 만들기
#include <stdio.h>
#include <iostream.h>
void main(void)
{
printf("Hello, Kim JoongTae. \n");
printf("Hello, This is 2nd Line. \n");
kim();
park();
}
kim()
{
printf("This is Kim's function. \n");
}
park()
{
cout<<"This Park's function.\n";
}
test003.c의 소스파일 내용을 고쳐서 ex02.cpp로 저장합니다. test003.c의 main()함수 안에서 kim() 함수를 실행시킨 다음 줄에 park()이라는 사용자정의 함수를 실행시키도록 만듭니다. 물론 이를 위해서는 park()이라는 사용자정의 함수를 만들어야 합니다.
park() 함수는 'This is Park's function.'이라는 내용을 보여주는 함수로 만듭니다. 단 문장을 보여주는 명령어로 cout 명령을 이용합니다.
2.5.5.복귀값과 함수의 선언방법, 한글로 주석달기
함수는 기본적으로 복귀값을 돌려주지만 복귀값이 없는 함수도 있습니다.
사용자정의 함수를 만들어봐서 알겠지만 함수는 C++언어 프로그램에서 미리 만들어놓은 것을 사용할 수도 있고 우리가 직접 만들 수도 있습니다. 예를 들어서 어떤 수의 제곱을 구하고자 할 때는 제곱을 구해주는 함수를 만들어야 합니다. 이때 이 함수를 jegob()이라는 이름으로 우리가 만들고 이 함수의 기능은 괄호 안에 든 숫자를 제곱해서 보여주는 것으로 만들 수 있습니다. 즉 jegob(3)이라고 하면 이 함수는 3의 제곱인 9를 결과물로 돌려줍니다.
이때 돌려주는 9라는 결과물을 리턴(return)값 또는 복귀값, 반환값이라고 합니다. 따라서 대부분의 함수는 복귀값을 돌려주게 되어 있습니다. 다만 복귀값을 돌려받을 필요가 없을 경우에는 복귀값이 없을 수도 있습니다. 이럴 경우 보통 복귀값이 없다고 하지만 사실은 복귀값이 없는 것이 아니라 빈 상태의 복귀값을 돌려주는 것입니다.
test003.c를 볼랜드C++에서 컴파일할 때는 경고가 발생합니다.
^^^그림: BCW에서 test003.c를 컴파일할 때 발생하는 경고문구들
^^^그림: BC에서 test003.c를 컴파일할 때 발생하는 경고문구들
복귀값을 돌려받지 않는 함수에는 void라는 말을 붙입니다.
그 까닭은 볼랜드C++에서는 복귀값을 꼭 지정해주어야 하기 때문입니다. 만약 돌려받을 복귀값이 없다면 복귀값이 필요없는 함수라고 알려주어야 합니다. 복귀값이 필요없는 함수라는 의미로 void라는 낱말을 다음과 같이 추가합니다.
^^^그림: test0032.c의 내용
**요약: 함수는 보통 복귀값(=리턴값)을 가지거나 안가질 수 있는데 복귀값을 가지지 않은 함수는 void를 붙여서 void형 함수임을 나타냅니다.
윈95/98에서 '한/영'키나 오른쪽 [Alt]키를 이용해 완성형한글로 주석문을 달 수 있습니다.
이때 소스파일에 한글로 주석문을 달았는데 윈95/98에서 도스창을 이용해 BC를 실행시킨 상태라면 윈95/98에서 사용하는 완성형한글을 사용하면 됩니다. 키보드의 '한/영'키나 오른쪽 [Alt]키를 누르면 한글과 영문을 쓸 수 있는 상태로 토글(toggle) 전환됩니다. 또는 완성형 한글도스를 사용하는 사람 역시 같은 방법으로 한글과 영문 입력상태를 전환해가면서 한글을 입력할 수 있습니다.
BCW를 사용하는 분이라면 윈95/98에서 한글을 입력할 때 사용하는 방법을 그대로 사용하면 됩니다. 역시 키보드의 '한/영'키나 오른쪽 [Alt]키를 누르면 한글과 영문을 쓸 수 있는 상태로 토글(toggle) 전환됩니다.
마이크로소프트사의 윈95/98과 한글도스가 모두 완성형 한글코드를 사용하므로 윈95/98에서 한글을 입력할 경우에는 완성형으로 입력된다는 점을 알아두셔야 합니다.
그리고 영문도스를 사용하는 분이 BC를 사용해서 프로그램을 짠다면 한글을 입력할 수 있는 방법이 없습니다. 영문도스를 사용하는 분들은 한글 구동 프로그램을 실행시킨 후에야 사용이 가능합니다. 태백한글, 한메한글, 한맥 등의 한글구동 프로그램을 먼저 실행시킨 후에 한글 프로그램의 사용법에 따라서 한글을 입력하시기 바랍니다.
**요약: C++언어 소스파일에 한글을 입력하는 방법은 운영체제에서 한글을 입력하는 방법과 같은 방법을 사용합니다.
함수는 미리 선언해주어야 합니다.
test003.c를 test0032.c로 고친 다음에 컴파일하면 이번에는 경고보다 더 큰 문제인 에러가 발생합니다. test003.c에서도 에러는 나오지 않았는데 오히려 고친 소스파일에서 에러가 발생하다니? 에러가 나왔다면 프로그램의 실행이 되지 않습니다. 물론 실행파일이 만들어지지도 않습니다. 원인은 함수 선언이 잘못되었기 때문입니다.
^^^그림: test0032.c를 컴파일해본 결과 에러와 경고가 각각 1개씩 발생했습니다.
**그림: BCW의 경고/에러 메시지 창
^^^그림: BC의 경고/에러 메시지 창
미리 함수를 선언해주어야만 컴파일하는 도중에 함수의 형을 파악할 수 있습니다.
여기서 함수선언에 대해 간단하게 알아보겠습니다. 원칙적으로 C++언어에서 함수는 미리 선언을 해주어야만 사용이 가능합니다. 그러나 test003.c과 test0032.c에서는 kim()함수에 대한 선언을 해주지 않았습니다.
함수를 선언한다는 의미는 앞으로 내가 사용할 함수는 정수형인지 실수형인지, 복귀값은 정수형인지 실수형인지 또는 복귀값 자체가 없는지 등을 미리 알려준다는 뜻입니다. 누구에게 알려줍니까? 컴파일러에게 알려주는 것입니다.
즉 kim() 함수가 정수형이고 복귀값으로 정수형을 돌려받는다고 미리 선언해주면 컴파일러는 이런 선언내용을 기억하고 있다가 나중에 kim() 함수의 실행명령이나 본체를 만났을 때 과연 제대로 정수형으로 복귀값을 돌려주나 확인해서 소스파일이 제대로 작성되었는지 알려줍니다. 물론 사용자가 kim() 함수를 사용할 경우 정수형으로 복귀값을 돌려주도록 컴파일해줍니다. 이것이 함수를 미리 선언해주는 까닭입니다.
그렇다면 test0032.c에서 에러가 발생한 이유를 살펴보겠습니다. test0032.c를 보면 main() 함수에서는 kim(); 이라는 명령문을 사용했습니다. 이때 함수의 앞뒤로 아무런 낱말이 추가되지 않았습니다. 이때문에 컴파일러는 이 함수가 정수형인지 실수형인지 void형인지 알 수 없습니다. 그래서 '에라 모르겠다. 정수형이겠지' 하고 제멋대로 컴파일했다고 합시다.
그런데 kim() 함수의 본체를보면 void라는 말이 함수형과 함수의 인수형에 추가되었습니다. 즉 kim() 함수는 void형인 셈입니다. 이렇게 되면 혼란이 생깁니다. 정수형으로 다루도록 했는데 실제로는 void 형이니 오차가 생기는 것입니다. 이런 오차를 막으려면 main() 함수에서 kim() 함수를 사용하기 전에 kim() 함수의 형을 선언해주어야 합니다. 이렇게 하면 컴파일러가 main() 함수에 있는 kim() 함수를 만나더라도 정확하게 void형으로 판단내려 컴파일해줄 수 있기 때문입니다.
함수 선언은 함수가 사용되기 전에 아무 곳에서나 선언해주면 됩니다.
함수의 선언방법은 간단합니다. 그 함수가 사용되기 전에 아무 곳에나 함수의 형과 인수형을 결정하는 명령줄을 추가해주면 됩니다. 원칙적으로는 아무 곳에서나 선언이 가능하지만 몇 만 줄이나 되는 소스 파일의 아무 곳에나 한 줄 함수선언문을 끼워넣으면 나중에 찾기가 곤란합니다. 때문에 함수형을 쉽게 찾아볼 수 있고, 또한 소스파일에서 사용한 사용자정의 함수로 무엇무엇이 있는지 쉽게 파악할 수 있도록 함수선언문은 소스파일의 앞머리에 적어주는 것이 관례입니다.
보통 소스파일의 맨 앞머리에는 소스파일의 개요를 주석문으로 달아서 설명하고, 다음에는 #include 문을 적습니다. 그 다음에 함수 선언문을 적어주는 것이 관례입니다.
따라서 test0033.c와 같이 #include 문 뒤에 한 줄을 추가해주면 됩니다.
^^^그림: BCW에서 작성한 test0033.c의 소스파일 내용
void kim(void); 이라는 줄이 kim() 함수를 사용하기 전에 추가되었기 때문에 컴파일러는 kim() 함수가 void형이라는 것을 미리 알고 컴파일해나갑니다. 이제 이 파일을 컴파일해보면 에러와 경고가 나타나지 않습니다. 즉 제대로 된 소스파일로 작성된 것입니다. 따라서 test003.c도 문제 없는 소스파일이지만, 아주 엄밀하게 만든 좋은 프로그램은 아니라는 점을 알 수 있습니다. 제대로 된 소스파일은 test0033.c입니다.
^^^그림: test0033.c가 에러 없이 컴파일되었다는 안내문
컴파일에서 사용하는 기본적인 함수의 선언문은 헤더파일에 담겨있으며 확장자는 h입니다.
그런데 main() 함수와 printf() 함수의 선언문은 없습니다. 모든 함수가 미리 선언해주어야 한다면 main() 함수와 printf() 함수도 미리 선언해주는 것이 옳지 않은가? main() 함수는 프로그램의 본체에 해당하는 으뜸 함수니까 제외한다 쳐도 main() 함수 안에서 사용하는 printf() 함수문은 kim() 함수와 같은 등급이니까 미리 선언해주어야 하지 않나? 이런 의심을 가지는 분이 계실겁니다. 맞습니다. C++언어에서는 모든 함수가 미리 선언되어야 합니다.
그렇다면 printf() 함수의 선언문은 어디에 있는 것일까요? stdio.h라는 파일에 있습니다. 소스파일의 첫번째 명령문이 #include <stdio.h>입니다. 이 명령문의 뜻은 stdio.h 파일을 포함시켜서(include) 컴파일하라는 뜻입니다. 그리고 stdio.h 파일의 내용은 볼랜드C++에서 가장 기본적이면서 중요하게 사용하는 몇 가지 함수의 선언문을 담고 있습니다. 일명 헤더파일(Header File)이라고 부르는 것입니다. 헤더파일의 확장자는 h입니다.
헤더파일을 사용하면 경제적이며 보기에도 깔끔합니다.
왜 헤더파일을 사용할까요? 소스파일의 내용을 간결하게 만들기 위해서입니다. 예를 들어서 간단한 소스파일을 하나 짜면서 1000여개의 기본함수를 사용했다고 합시다. 그러면 1000여개의 함수 선언문을 소스파일의 앞머리에 달아주어야 합니다. 모든 소스파일마다 1000여줄이나 되는 함수 선언문을 반복해서 적어주는 일은 시간낭비일 뿐만 아니라 소스파일을 판독하는데도 어려움을 줍니다. 또한 소스파일을 길게 만드는 원인이 됩니다.
따라서 1000여개의 함수선언문을 하나의 파일에 담아둡니다. 함수선언문을 담았다고 해서 이런 파일을 헤더파일이라고 합니다. 그리고 사용자가 짜는 소스파일에는 이렇게 만든 헤더파일을 컴파일할 때 포함시키라는 명령문 한 줄만 쓰면 됩니다. 이렇게 하면 소스파일이 매우 깔끔해집니다.
컴파일러는 컴파일하다 #include <stdio.h>라는 명령문을 만나면 우선 stdio.h 파일을 찾아서 안에 담겨있는 함수선언문을 읽어들입니다. 그리고 stdio.h 파일에서 파악한 함수선언문을 이용해서 test0033.c에서 사용하는 함수의 형을 파악합니다. 즉 #include <stdio.h>는 1000줄의 함수선언문을 대체할 수 있는 명령문입니다.
사용자도 직접 헤더파일을 만들 수 있습니다.
물론 사용자가 만든 사용자정의 함수 역시 헤더파일로 만들 수 있습니다. 예를 들어서 kim() 함수를 비롯해 약 1000개의 사용자정의 함수를 만들었을 경우 소스파일마다 선언문을 삽입하는 것은 낭비입니다. 자신이 만든 사용자정의 함수가 많다고 생각하면 함수선언문만 모아서 'kim.h'라는 헤더파일로 만듭니다. 그리고 소스파일의 앞머리에 #include "kim.h"와 같이 사용합니다. 헤더파일의 이름을 싸는 기호로는 <> 기호 대신 ""기호를 이용해도 됩니다. 보통 컴파일러 프로그램에서 제공하는 헤더파일은 <> 기호로 싸고, 사용자가 만든 헤더파일은 "" 기호로 감싸서 헤더파일의 성격을 구분합니다. 헤더파일에 관해서는 나중에 다시 좀더 자세하게 설명드리겠습니다.
C++언어를 배우는 과정은 곧 사용자정의 함수를 만드는 과정입니다.
하여간 C++언어를 배우는 과정은 결국 함수의 사용법을 배우거나 함수를 만드는 법을 배우는 과정이라고 해도 틀린 말이 아닙니다. 이는 C++언어 뿐만 아니라 모든 언어에 공통적으로 적용되는 말입니다. 간단한 함수는 쉽게 만들 수 있겠지만 복잡한 기능을 수행하는 함수는 점점 더 복잡해지고 사용법이 어렵습니다. 처음에는 main()함수 본체에 딱 한 줄만 들어있었지만 지금은 3줄로 늘어난 것처럼 자신이 원하는 기능을 구현하기 위해서 자꾸 새로운 명령어와 함수가 추가로 들어가는 겁니다.
**요약: 함수는 미리 선언해주어야 하는데 함수가 사용되기 전에 아무 곳에서나 선언이 가능합니다. 그러나 관례상 소스파일의 첫머리에 선언문을 적습니다. 또한 함수선언문을 모아 헤더파일로 만들어 사용하면 프로그램 작성이 훨씬 쉽고 빨라집니다. 헤더파일의
확장자는 h이며, #include <헤더파일이름.h> 라는 명령문을 통해 헤더파일의 내용을 소스파일에 포함시킬 수 있습니다.
[연습문제]
ex02.cpp의 파일 내용을 고쳐서 ex03.cpp로 저장합니다. 컴파일할 때 문제가 없도록 사용자정의 함수의 선언부분을 알맞은 위치에 선언해주기 바랍니다.
[연습문제 정답]
// EX03.CPP -- 사용자정의 함수 선언하기
#include <stdio.h>
#include <iostream.h>
void kim(void); // kim()함수의 선언문
void park(void); // park()함수의 선언문
void main(void)
{
printf("Hello, Kim JoongTae. \n");
printf("Hello, This is 2nd Line. \n");
kim();
park();
}
void kim(void)
{
printf("This is Kim's function. \n");
}
void park(void)
{
cout<<"This Park's function.\n";
}
ex02.cpp의 파일 내용을 고쳐서 ex03.cpp로 저장합니다. 컴파일할 때 문제가 없도록 사용자정의 함수의 선언부분을 알맞은 위치에 선언해주기 바랍니다.
2.5.6.getch()로 키 입력 때까지 멈추게 만들기
getch() 함수를 사용하면 키 입력 때까지 프로그램 실행을 멈출 수 있습니다.
지금까지의 예제를 만들어보니 불편한 점이 하나 있습니다. 윈도용 볼랜드C++에서는 별도의 창이 뜨기 때문에 컴파일 링크 실행까지 한 번에 처리하여 프로그램 결과를 볼 수 있지만, 도스용 볼랜드C++에서는 프로그램 실행이 끝난 뒤에 바로 bc 화면으로 돌아옵니다. 때문에 도스로 빠져나가서 만들어진 실행파일을 실행시켜야 하는 불편함이 있습니다. 따라서 소스파일을 컴파일 링크 실행시켜서 화면에 출력된 내용을 확인한 다음에 다시 bc 화면으로 좋겠다는 생각이 듭니다.
그럴려면 화면에 문장을 보여준 뒤에 사용자가 키를 입력할 때까지 잠시 대기시키는 기능을 추가하면 됩니다. test0033.c의 내용을 다음과 같이 고쳐서 test0035.c로 만들어보기 바랍니다.
getch() 함수를 이용하면 출력 내용을 보고 편집화면으로 돌아올 수 있습니다.
앞으로 나올 소스파일에 getch() 함수를 추가하면 출력내용을 모두 보고 편집상태로 돌아올 수 있습니다.
main() 함수의 맨 끝에 추가한 getch(); 함수는 키입력을 받는 함수인데 위의 예문처럼 사용하면 사용자가 키를 누를 때까지 기다립니다. 따라서 사용자가 아무 키나 눌러야만 다음 명령을 실행합니다.
앞부분에 추가된 '#include <conio.h>' 명령문은 getch() 함수를 사용하기 위해서 추가한 명령어입니다.
get으로 시작하는 함수의 사용법은 꽤 복잡합니다. 그리고 이 책에서는 다루지 않습니다. 때문에 getch()함수의 자세한 사용법 역시 다루지 않습니다. 그런데도 이 함수를 여기에서 소개하는 이유는 프로그램 실행 결과를 도스로 나가서 확인하는 불편을 조금이라도 덜어드리기 위해서입니다.
하여간 함수의 헤더파일 선언문에 '#include <conio.h>' 명령문을 추가하고 main()함수의 맨 마지막 줄에 getch() 함수를 추가하면 프로그램이 끝나기 전에 사용자의 키 입력을 기다립니다.
앞으로 나올 소스파일에서는 '#include <conio.h>' 명령문과 getch() 함수를 사용하지 않은 상태에서 설명합니다. 그러나 매번 도스로 나가서 프로그램 결과를 알아보기가 귀찮은 분은 소스파일 안에 앞의 두 문장을 추가해주기 바랍니다. 그러면 bc나 터보C에서도 화면에 출력된 내용을 확인한 후에 아무 키나 눌러서 원래의 편집화면으로 돌아올 수 있습니다.
**요약: getch() 함수를 추가하여 프로그램 출력결과를 모두 본 뒤에 아무 키나 눌러서 다시 편집화면으로 돌아올 수 있습니다.
2.5.7.정의와 선언의 차이
함수의 선언은 함수의 모습을 미리 알려주는 행위입니다
자 여기서 우리는 함수의 선언과 정의라는 두 가지 용어에 대해서 알아보겠습니다. 언어를 사용하다보면 선언과 정의라는 용어를 자주 접하게 됩니다. 이 두 용어는 보통 같은 의미로 많이 사용합니다. 그러나 두 용어는 뚜렷한 특징을 가지고 있습니다. 함수의 선언은 앞서 설명한대로 앞으로 사용될 함수가 어떤 특징을 가진 함수인지 컴파일러에게 알려주는 행위입니다. 줄여서 말하면 '함수의 선언은 함수의 모습을 미리 알려주는 행위'입니다. 이를 통해 컴파일러는 함수 선언문에 적힌 특징을 참고삼아 컴파일을 실행합니다.
함수의 정의는 함수의 모든 것을 밝혀주는 행위입니다.
그렇다면 선언과 거의 비슷한 의미로 사용하는 정의는 무엇인가? 정의는 함수의 모든 것을 밝혀주는 것입니다. 따라서 함수의 본체 내용을 정의내용이라 할 수 있습니다. 앞서 우리는 test003.c의 세번째 줄에 있는 'void kim(void);' 문장이 kim()함수의 선언문임을 배웠습니다. 그리고 main() 함수 뒤에 나오는 void kim(void) {본체 내용}라는 함수의 본체가 나옵니다. 따라서 이 부분이 함수의 정의 부분에 해당합니다. 그러므로 'void kim(void);' 문장은 kim()함수의 선언문이고, 'void kim(void)'라는 문장은 함수의 정의 문에 해당합니다.
함수의 정의와 선언을 동시에 할 수 있습니다.
이처럼 정의는 함수의 본체를 밝히는 것이고 선언은 본체의 특징을 미리 알려주는 것이라는 차이가 있습니다. 그런데 왜 C언어나 C++언어를 이용하는 프로그래머는 선언과 정의라는 두 용어를 혼동하여 사용할까요? 많은 경우 선언과 정의가 동시에 이루어지기 때문입니다.
앞서 우리가 test0033.c의 소스파일을 통해서 main() 함수에서 kim() 함수를 사용하기 전에 kim() 함수의 특징을 알려주기 위하여 main() 함수 이전에 kim() 함수 선언문이 들어가야 한다고 말씀드렸습니다. 또한 함수의 선언문은 그 함수가 사용되기 전에만 삽입되면 된다고 말씀드렸습니다.
그렇다면 kim() 함수의 정의문, 다시 말해서 본체를 main() 함수 이전에 적어놓으면 어떻게 됩니다. 이렇게 되면 컴파일러는 컴파일을 해가는 과정에서 kim() 함수의 본체를 먼저 컴파일합니다. 따라서 컴파일러는 kim() 함수의 정체를 확실하게 파악한 다음에 main() 함수에 있는 kim() 함수의 명령문을 컴파일합니다. 이처럼 kim() 함수가 사용되기 전에 kim() 함수의 정의가 먼저 이루어지면 함수를 선언할 필요가 없어집니다. 왜냐하면 이때는 정의문이 곧 선언문의 역할을 하기 때문입니다.
이처럼 kim() 함수가 사용되기 전에 kim() 함수의 본체가 위치할 경우 kim() 함수의 본체는 선언과 정의를 동시에 겸하는 셈입니다.
함수 사용 전에 함수의 본체를 삽입하면 정의와 동시에 선언이 이루어집니다.
C++언어로 프로그램을 짜는 프로그래머 중에서 일부는 함수를 따로 선언하는 일을 귀찮아해서 함수가 사용되기 전에 함수를 위치시키는 방법을 사용합니다. 그래서 main() 함수의 본체가 소스파일의 제일 마지막에 위치하는 경우가 많습니다. 이처럼 함수가 사용되기 전에 함수의 본체를 삽입함으로써 함수의 선언과 정의가 동시에 이루어집니다. 때문에 이런 경우 함수의 정의문은 곧 함수의 선언문이 되고, 정의와 선언는 동일한 의미로 사용됩니다. 함수의 선언과 정의가 혼돈되는 까닭도 이 때문입니다. 그러나 기본적으로 두 용어는 명백한 차이를 가지고 있음을 알기 바랍니다.
test0034.c는 함수의 선언과 정의가 동시에 이루어지는 예를 보여줍니다.
^^^그림: test0034.c의 소스파일 내용
^^^그림: test0034.exe를 실행한 화면
배열, 변수 등에서도 정의와 선언의 개념은 같습니다.
한편 정의와 선언은 함수에만 적용되는 이야기가 아닙니다. 변수나 배열 등의 다른 개념에서도 정의와 선언이라는 용어를 사용합니다. 이때도 정의와 선언은 지금 설명한 함수의 정의와 선언의 차이와 동일합니다. 다시 말해서 변수의 선언은 앞으로 이러한 변수가 사용될 것임을 미리 알려줌으로써 그 변수가 사용될 자리를 확보해두는 행위이고, 변수의 정의는 그 변수의 내용이 어떤어떤 내용인지 알려주는 것입니다. 변수의 선언과 정의에 대해서는 나중에 변수 부분을 다루면서 다시 설명드리겠습니다.
**요약: 함수의 선언은 함수의 모습을 미리 알려주는 행위로 컴파일러가 함수 선언문에 적힌 함수의 특징을 참고삼아 컴파일하도록 도와주는 행위입니다. 함수의 정의는 함수의 모든 것을 밝혀주는 것으로 함수의 본체내용을 구성하는 행위입니다. 함수는
사용되기 전에 정의가 이루어질 경우 선언을 겸합니다.
[연습문제]
ex03.cpp의 파일 내용을 고쳐서 ex04.cpp로 저장합니다. 사용자정의 함수의 선언문을 사용하지 않고, 정의와 동시에 선언이 이루어지도록 고칩니다.
[연습문제 정답]
// EX04.CPP -- 사용자정의 함수 정의와 동시에 선언하기
#include <stdio.h>
#include <iostream.h>
void kim(void)
{
printf("This is Kim's function. \n");
}
void park(void)
{
cout<<"This Park's function.\n";
}
void main(void)
{
printf("Hello, Kim JoongTae. \n");
printf("Hello, This is 2nd Line. \n");
kim();
park();
}
ex03.cpp의 파일 내용을 고쳐서 ex04.cpp로 저장합니다. 사용자정의 함수의 선언문을 사용하지 않고, 정의와 동시에 선언이 이루어지도록 고칩니다.
2.5.8.주석문은 가능하면 많이 답시다.
주석문은 실행파일에 포함되지 않으며 프로그램 실행에 영향을 미치지 않습니다.
점점 복잡하게 프로그램을 짜다보면 자신이 짠 프로그램에 대해 주석 즉, 설명을 달아야 할 때가 있습니다. 주석을 달지 않으면 나중에 그 프로그램을 보고 무슨 내용인지 이해하지 못할 때가 있기 때문입니다. 주석은 많이 달수록 좋습니다. 특히 초보시절에는 주석을 다는 습관을 꼭 가져야 합니다.
C++언어는 /* 기호와 */ 사이에 들어있는 모든 문장을 주석문으로 처리합니다. 이 기호는 어디에 있더라도 상관 없습니다. 주석문장은 프로그램을 실행할 때 전혀 나타나지 않습니다. 다시 말해서 소스파일에서만 우리가 볼 수 있을 뿐입니다. 컴파일러가 exe 파일을 만들면서 주석문장은 빼버리고 컴파일하기 때문입니다. 그래서 프로그램의 실행에 아무런 영향도 끼치지 않는 문장이 주석문입니다.
자 그럼 시험삼아 몇 문장에 주석문을 달도록 합시다. test0033.c를 다음과 같이 바꾸고 test004.cpp로 저장하시기 바랍니다. 이제 다른 이름으로 저장하는 방법은 알려주지 않아도 할 수 있을 겁니다만 다시 한 번 알려드리면 [Alt]+[F]를 누르셔서 파일메뉴를 선택한 후에 'Write to(bc에서는 Save as, )'를 선택하고 'test004.cpp'라고 쓰면 되는 겁니다.
한 가지 주의할 점은 이번에 저장되는 파일은 test004.c가 아니라 test004.cpp라는 사실입니다. 이번 예제소스에는 C++언어에서만 사용할 수 있는 cout<< 명령문이 포함되기 때문입니다.
그리고 앞으로 나오는 예제 파일은 BCW의 화면을 이용하겠습니다. 지금까지 과정을 통해 BC를 사용하는 분들도 이제는 소스파일을 작성하고 저장하고, 컴파일, 링크, 실행하는 과정을 충분히 익혔습니다. 따라서 BC 화면 대신 BCW 화면만을 보여드려도 충분하리라고 생각합니다.
^^^그림: test004.cpp 파일을 알아보기 쉽게 달아준 주석문
주석문은 프로그램의 내용을 이해하기 좋도록 도와줍니다.
이제 이 프로그램을 다시 검토해보겠습니다. 다음의 줄을 잘 보시기 바랍니다.
전에는 #include 명령문 오른쪽이 비었지만 이제는 '/* 헤더파일을 포함시키라는 명령문 */'이라는 문장이 붙어 있습니다. 그러나 이렇게 문장이 붙어있다고 해서 프로그램을 실행할 때 붙어 있는 문장이 나오지는 않습니다. 대신 주석문을 통해서 이줄이 헤더파일을 포함시키는 명령문이구나 하는 것을 쉽게 파악할 수 있습니다.
다음 줄에는 /* */ 기호 대신 // 기호를 이용하여 주석문을 달았습니다. // 기호는 줄 끝까지 주석문으로 처리하기 때문에 주석문 끝에 별도의 기호를 붙이지 않습니다. 그래서 주석문을 한 줄로 처리할 때는 /* */보다는 // 기호가 더 편리합니다.
만약 /* 기호를 사용한 다음에 */ 기호를 깜박 잊고 사용하지 않았다면 다음 줄부터 나오는 실제 명령문까지 주석문에 포함되는 실수를 할 수 있지만 // 기호를 사용하면 다음 줄이 주석문에 포함되지 않기 때문입니다. 그래서 C++언어에서는 /* */ 기호는 여러 줄에 걸쳐서 주석문을 달 때 주로 사용하고, 한 줄 짜리 주석문은 보통 // 기호를 이용합니다.
그리고 아래의 문장을 보십시요.
이 줄을 통해서 여러분은 main()함수의 끝이라는 사실을 알 수 있을겁니다. 그냥 눈으로 봐도 알 수 있을 것 같다고요? 예, 물론 지금은 한 화면에 다 들어오니까 main()함수의 끝이 어딘지 알 수 있을 겁니다. 그러나 문장이 자꾸 많아져서 천 줄, 만 줄이 넘는 함수를 만들었다고 합시다. 만 줄 안에는 수 없이 많은 함수의 본체가 들어있을 겁니다. 기억력이 나쁘거나 눈이 나쁜 사람은 함수의 끝을 놓치고 }를 하나 더 써먹거나 하나 빼먹을 수 있습니다. 이러면 컴파일할 때 에러가 납니다. 그러면 에러를 찾아내야 하는데 어디에서 에러가 났는지 찾기란 쉬운 일이 아닙니다.
소스파일의 길이가 커지면 아래와 같이 } 기호만 하나 달랑 적어놓은 문장이 많아집니다. 이럴 경우 } 기호가 어느 함수의 끝인지 잘 모를 때가 많습니다. 그러나 '/* kim() 함수 본체의 끝 */'이라는 문장을 달아두면 } 기호만 보고도 kim() 함수의 끝이라는 것을 바로 파악할 수 있습니다.
그렇기 때문에 주석문을 다는 것이 좋습니다. 에러가 나서 나중에 소스파일을 점검할 때 어디에서 문제가 생겼는지 쉽게 파악할 수 있기 때문입니다. 그리고 무엇보다도 무슨 이유로 이런 명령문을 여기에 놓았는지 쉽게 파악할 수 있어서 좋습니다. 그래서 주석문은 많이 달수록 좋습니다. 타자를 치기가 귀찮겠지만 중요한 문장이나 명령어에는 꼭 주석문을 달기 바랍니다.
^^^그림: test004.exe를 실행시킨 화면. 주석문은 화면에 표시되지 않습니다.
**요약: 주석문이란 프로그램의 실행에는 아무런 상관이 없고 단지 소스프로그램을 알아보기 쉽게 달아주는 설명문을 말합니다. C++언어는 /* 기호와 */ 기호 사이에 들어간 내용을 주석문으로 인식합니다. 또한 // 기호 다음에 나오는 문장은 줄 끝까지 주석문으로
인식하고 다음 줄부터는 주석문으로 처리하지 않습니다.
명령문은 가능한 한 줄에 하나씩만 적는 것이 좋습니다.
주석문을 다는 것과 관련하여 프로그램을 알아보기 쉽게 만드는 습관을 몇 가지 알아두시는 것이 좋습니다.
첫번째는 한 줄에 하나의 명령어를 사용하는 것입니다. C++언어로 프로그램을 짤 때는 한 줄에 여러 개의 함수와 명령을 넣을 수도 있습니다. 예를 들어서 다음과 같이 써도 프로그램은 잘 동작합니다.
그러나 여러 개의 명령어와 문장이 한 줄에 섞여버리니 프로그램을 알아보기가 어렵습니다. 어디서부터 어디까지가 하나의 명령문인지 알기 어렵습니다. 그래서 가능하면 한 줄에 하나의 문장만 쓰는 것이 좋습니다.
명령문은 적당하게 들여쓰기 하는 것이 좋으며, Indent 기능을 활용하면 편합니다.
두번째로 적절한 간격을 줌으로써 문장을 읽기 편하게 해주는 것입니다. 수 천 줄이나 되는 프로그램의 시작이 모두 첫번째 칸에서 시작한다면 프로그램을 읽기가 무척 피곤합니다. 우리가 글을 쓸 때 적절하게 들여쓰기를 하는 것과 마찬가지로 프로그램을 작성할 때도 어느 정도의 들여쓰기를 함으로써 프로그램을 쉽게 읽을 수 있도록 해주어야 합니다. 이 간격조정은 물론 프로그램을 짜는 사람의 마음에 달려 있지만 가능하면 간격을 조정해서 보기 편하게 해주는 것이 본인에게도 좋습니다.
그래서 C++언어 프로그램은 아예 들여쓰기를 자동으로 해주는 기능이 있습니다. 그러니까 앞 줄의 끝에서 큰글쇠(Enter)를 치면 다음줄의 첫번째 칸으로 가는 것이 아니라, 앞줄의 첫번째 글씨가 있는 칸으로 이동하는 기능입니다. 이 기능은 유용하고 편리한 기능이므로 들여쓰기(Indent) 기능을 활용하는 것이 좋습니다. 들여쓰기 기능은 프로그램을 조금만 짜보면 바로 생활화됩니다.
**요약: 프로그램을 작성할 때는 한 줄에 하나의 명령어만 쓰고, 적절하게 들여쓰기를 해서 읽기 편하게 만드는 것이 좋습니다. C언어 프로그램에는 자동으로 들여쓰기를 해주는 Indent 기능이 있는데 이 기능은 앞줄의 첫번째 글자가 시작한 칸으로 커서를
이동시켜주는 기능입니다.
2.5.9. 상수와 변수란 무엇인가?
값이 수시로 변하는 수를 변수라고 합니다.
이제 좀더 복잡한 프로그램을 짜보도록 하겠습니다. 이제는 변수라는 것을 사용하도록 하겠습니다. 변수는 함수와 함께 프로그램의 축을 이루는 두 기둥의 하나입니다. 함수만큼이나 변수의 개념도 중요하고 변수의 사용법도 중요합니다. 변수라는 것은 변하는 수라는 뜻입니다. 상수는 항상 변함 없는 수를 뜻합니다.
a+b=c라는 수학공식을 예로 들겠습니다.
a+b=c라는 방정식이 있고, a=3이고 b=4라고 알려주면서 c의 값을 구하라고 명령합니다. 그러면 사람들은 a+b=c이므로 3+4=7이라고 대답할 겁니다. 예 맞습니다. 분명 7입니다.
그런데 또 다시 a는 4고 b는 6일 때 c는 얼마냐고 물었습니다. 사람들은 10이라고 대답할 겁니다. 이처럼 a, b, c는 수시로 값이 변합니다. a나 b에 대입하는 값이 다르면 c의 값도 달라집니다. 이처럼 값이 수시로 변하는 수를 변수라고 합니다. 어떤 숫자가 올지 모르기 때문에 변수라고 합니다. 그러니까 보기의 수학공식은 a라는 이름을 가진 변수와 b라는 변수, c라는 변수를 사용한 것입니다.
변수에 대입하는 수는 수시로 변할 수 있습니다.
변수를 사람으로 비유해봅시다. 국장이 김대리, 이대리라는 두 명의 부하직원에게 각각 1만원, 5만원을 나누어 주었습니다. 그리고 두 사람이 가진 돈을 합하면 얼마냐고 물었습니다. 그러면 누구나 1+5=6만원이라고 대답할 겁니다. 이번에는 국장이 김대리에게서 만원을 돌려받은 뒤에 다시 김대리에게 10만원을 주었습니다. 김대리는 10만 원 이대리는 5만 원을 가지고 있는 셈입니다. 그리고 두 사람이 가진 돈의 합계를 내라고 하면 10+5=15만원이라고 대답할 겁니다. 이때 김대리나 이대리가 하는 역할이 바로 변수가 하는 역할과 같습니다.
변수에는 숫자 외에 글자나 문장, 파일, 그림을 대입시킬 수도 있습니다.
이때 주의할 점이 있습니다. 변수라는 이름 때문에 많은 사람들이 변수를 숫자로만 알고 있는데, 변수는 숫자도 될 수 있지만 글자도 될 수 있고, 하나의 긴 문장이 될 수도 있습니다. 또한 파일이 될 수도 있고, 그림이나 소리가 될 수도 있습니다.
예를 들어서 국장이 다시 김대리에게 'Kim'이라는 글씨를 쓴 종이를 주고, 이대리에게는 'JoongTae'라고 쓴 종이를 나누어준 뒤에 두 종이에 쓴 글씨를 붙여서 읽어보라고 했습니다. 그러면 'Kim JoongTae'라고 읽을 겁니다. 국장이 다시 이대리에게서 종이를 거둔 뒤에 이번에는 'hangul'이라고 쓴 종이를 나누어주고 다시 두 사람이 가진 종이의 글씨를 붙여서 읽으라고 하면 'Kim hangul'이라고 읽을 겁니다.
김대리와 이대리는 변수로서 활동을 하지만 변수가 가질 수 있는 내용은 숫자도 될 수 있고, 글자도 될 수 있다는 뜻입니다. 그 까닭은 컴퓨터는 모든 것을 0과 1로만 처리하기 때문입니다. 즉 글씨나 그림, 소리조차도 이진수로 된 자료로 판단하기 때문입니다. 그래서 우리가 글씨나 그림이라고 인식하는 것도 컴퓨터는 이진수로 된 숫자로만 파악합니다.
변수가 지니고 있는 내용물은 계속해서 변합니다.
변수를 이용하는 방법은 유치원에서 아이들에게 숫자교육이나 한글교육을 시킬 때와 비슷합니다.
'c=a-b'라는 수학공식은 이슬비라는 학생에게 7이 써진 숫자를 주고, 한강물이라는 학생에게 3이라고 써진 숫자를 준 뒤에, '이슬비가 가진 숫자에서 한강물이 가진 숫자를 빼면 얼마죠?'하고 묻는 것과 같습니다. 이때 이슬비와 한강물은 변수가 되고, 7과 3은 변수가 가진 내용물이 됩니다. 변수란 변하는 수이므로 변수가 가진 내용물은 계속해서 변할 수 있습니다. 이슬비라는 학생에게 7대신 10을 주고 '이슬비가 가진 숫자에서 한강물이 가진 숫자를 빼면 얼마죠?'하고 물어볼 수도 있습니다. 이슬비(10)-한강물(3)=7이 됩니다.
상수는 변하지 않는 수로 우리가 알고 있는 숫자나 문자가 상수에 해당합니다.
변수가 변하는 수라면 상수는 항상 변하지 않는 수입니다. 다시 말해서 7이나 10이라는 숫자가 상수입니다. 10은 10일 뿐 8이나 9가 아닙니다. 그러나 이슬비나 들고 있는 숫자카드는 변할 수 있습니다. 그래서 이슬비는 변수고, 10이라는 숫자는 상수가 되는 겁니다.
**요약: 변수란 자꾸 변하는 자료의 내용을 그때그때 받아 지니는 수를 말하는데 이때 변수는 숫자 외에도 문자나 문장, 파일을 변수의 내용을 가질 수 있습니다. 상수는 값이 늘 변함 없는 수를 말합니다.
변수를 이용해 제곱수를 구하는 프로그램을 만들어보겠습니다.
변수는 매우 유용한 개념입니다. 예를 들어서 한 사람이 어떤 수를 입력하기만 하면 제곱수를 구해주는 프로그램이 있으면 좋겠다고 생각했습니다. 그럼 제곱을 구해주는 기능을 수행하는 함수를 만들어서 프로그램으로 만들면 됩니다. 아래의 내용이 제곱을 구해주는 프로그램입니다. 그대로 입력하신 후에 test005.cpp로 저장, 컴파일, 링크한 후에 실행해보기 바랍니다. Run 메뉴를 실행시키면 컴파일, 링크, 실행을 한 번에 처리할 수 있습니다.
^^^그림: test005.cpp의 소스파일 내용
프로그램을 실행시키면 숫자를 입력받는 화면이 나옵니다.
[Ctrl]+[F9]을 실행하면 이전과는 조금 다르게 나올겁니다. TC나 BC의 경우 전에는 화면이 잠깐 깜박이다가 다시 편집화면으로 돌아왔는데, 이번에는 숫자를 입력하라는 말이 나오면서 커서가 깜박일 겁니다. BCW로 작성한 윈도용 test005.exe 역시 커서가 깜박이면서 입력을 기다립니다. 그 까닭은 프로그램이 끝나지 않았기 때문입니다. 이 프로그램은 사용자로부터 숫자를 입력받아서 화면에 출력하는 일을 하는 프로그램입니다. 따라서 사용자로부터 숫자를 입력받는 부분이 제일 먼저 나옵니다.
프로그램을 보면 아래와 같은 문장이 나옵니다.
INput Number: _
^^^그림: test005.exe를 실행시키면 커서가 깜박이며 숫자 입력을 기다립니다.
이때 원하는 숫자를 아무거나 입력해보시기 바랍니다. 예를 들어서 3을 입력해보십시요. 3을 입력한 뒤에는 [Enter]를 쳐주어야 합니다.
^^^그림: 입력받을 숫자로 3을 입력하고 [Enter]를 칩니다.
그럼 TC나 BC는 다시 편집화면으로 돌아올겁니다. 그럼 [Alt]+[F5]를 눌러서 사용자화면을 살펴보기 바랍니다. 다음과 같은 내용이 화면이 나타날 겁니다.
BCW일 경우에는 독립된 창으로 프로그램이 실행되기 때문에 화면에 위의 내용을 출력해주는 것으로 끝납니다.
^^^그림: 윈도용 test005.exe의 실행결과
3이라는 숫자를 입력받은 test005.exe 프로그램은 화면에 'Input number=3'라는 문장을 보여주고, 이어서 'input * input=9'라는 문장을 보여주고 끝난겁니다. 다시 말해서 3의 제곱수를 보여주는 기능을 수행한 것입니다.
이 프로그램의 문장을 하나씩 다시 살펴보겠습니다. main()함수 내의 문장은 아래와 같습니다. 보기 편하도록 원래 소스파일의 오른쪽에 붙였던 주석문은 생략했습니다.
'int a, b;' 는 정수형 변수 a, b를 선언하겠다는 문장입니다.
이제 이 내용을 한 줄씩 살펴보겠습니다.
int a, b;
main()과 { 에 대해서는 이제 설명 안해도 아실테니 'int a, b;'라는 문장부터 살펴보겠습니다. 이 문장은 변수를 선언하는 문장입니다. 즉 a라는 변수와 b라는 변수를 사용하겠다는 뜻입니다. 제일 처음 나오는 int라는 낱말은 정수인 변수를 선언하겠다는 뜻입니다. 알다시피 정수는 -10, 0, 3, 7과 같은 숫자입니다. 소수점이 없는 숫자를 정수라고 말하죠. a자 다음의 쉼표(,)는 a와 b를 구별하기 위해서 사용하는 기호입니다. 따라서 이 문장은 정수인(int형) 변수 a와 b를 앞으로 쓰겠다고 선언하는 문장입니다. 끝에 ; 기호를 붙이는 것을 까먹지 말기 바랍니다.
printf() 함수는 () 안의 문장을 화면으로 보여주는 함수입니다.
printf("INput Number: ");
printf() 함수는 앞에서도 몇 차례 사용했으니 큰 어려움 없이 이해하실 겁니다. ()안에 든 내용을 출력하라는 함수인데, 문장을 출력하고 싶을 경우에는 " 기호와 " 기호 사이에 원하는 문장을 적으면 됩니다.
'\n'은 줄바꿈문자(개행문자)로 다음줄로 커서를 옮기라는 뜻을 가지고 있습니다.
이때 이전과는 조금 다른 것을 하나 발견할 수 있을 겁니다. 맨 마지막에 붙어다니던 '\n'이라는 낱말이 없음을 알 수 있을 겁니다. \n 기호는 줄바꿈문자 또는 개행문자라고 해서 다음줄로 커서를 옮기라는 뜻을 가지고 있습니다. 개행문자에 대해서는 나중에 다시 설명드리겠습니다.
그런데 줄바꿈문자를 쓰지 않았으니 커서가 다음줄로 내려가지 않습니다. 그럼 어디에 붙을까요? 'INput Unmber: '라는 문장 바로 뒤에서 커서가 깜박거릴 겁니다.
**요약: 변수를 사용하기 위해서는 변수의 형태와 변수이름을 먼저 선언해주어야 합니다. printf() 함수는 괄호 안의 내용을 출력해주는 함수이며, \n은 줄을 바꾸라는 뜻을 지닌 특수문자입니다.
scanf() 함수는 숫자를 입력받아 변수에 넣으라는 함수입니다.
scanf("%d",&a);
이 문장은 사용자로부터 숫자를 입력받아서 a라는 변수에 넣으라는 명령문입니다. 이제 여러분은 printf()함수에 이어서 두번째 함수로 scanf()함수를 사용한 겁니다. "%d"라는 낱말은 정수인 숫자를 입력받으라는 뜻을 지니고 있습니다. 뒤의 쉼표(,)는 물론 다음 낱말과 구별하기 위한 구분기호입니다. 그리고 &a라는 낱말은 a라는 변수에 "%d"를 통해 입력받은 숫자를 대입시키라는 뜻입니다.
변수에 어떤 내용을 넣어주는 행위를 '대입'이라고 말합니다.
이때 변수 a에 어떤 내용을 넣어주는 것을 대입이라고 합니다. 그러니까 &a는 김대리에게 돈을 주라는 말과 같습니다. 또는 이슬이에게 선생님이 준 숫자카드를 넘겨주라는 이야기와 같습니다. 물론 이때 김대리가 국장에게 얼마를 받을지 이슬이가 어떤 숫자카드를 받을지는 아직 모릅니다.
**요약: scanf() 함수는 사용자로부터 입력받은 내용을 변수에 대입하라는 명령을 수행하는 함수입니다.
'%d'는 정수인 숫자를 대신하는 특수문자입니다.
printf("Input number=%d \n",a);
이 문장은 "" 사이에 든 문장인 'Input number=%d \n'를 화면에 보여주라는 명령문인데 이전의 printf()함수와 조금 다른 부분을 발견할 수 있을 겁니다. %d 라는 특수한 기호가 첫번째로 눈에 뜨입니다.
%d는 단순한 글자가 아니라 변수로부터 정수를 넘겨받아서 화면에 표시하라는 의미를 가지고 있습니다. 좀더 정확하게 표현하면 정수를 대신할 수 있는 특수문자입니다. 즉 scanf()함수에서 %d가 정수를 뜻하는 것처럼 printf()함수에서도 %d는 정수를 뜻합니다. 그럼 이때 %d에 넘겨주는 정수는 어디에서 가져올까요? "" 문장이 끝나고 쉼표로 구분한 뒤에 나오는 a라는 변수에서 가져옵니다.
그러니까 printf("Input number=%d \n",a); 라는 명령문은 a라는 변수에서 받은 숫자를 %d에 대입시킨 후에 "" 사이의 문장을 모니터 화면으로 보여주라는 뜻입니다. 만약 scanf() 함수를 통해서 입력받은 숫자가 3이라면 a라는 변수에는 3이 대입되었습니다. 따라서 printf("Input number=%d \n",a);라는 명령문은 다음과 같은 과정을 거쳐서 화면에 표시됩니다. 우선 a의 값이 3입니다. 따라서 %d에 a를 대입하므로 %d의 값은 3이 됩니다. 결국 화면에는 'Input number=3'이라는 문장으로 출력됩니다.
화면으로 글씨를 보여주는 것을 다른 말로 화면으로 출력한다, 또는 표준출력장치로 출력을 한다고 말합니다. 표준출력장치는 사용자가 바꿀 수 있지만 특별한 명령을 주지 않았다면 모니터의 화면을 표준출력장치로 생각합니다.
**요약: printf() 함수는 괄호 안의 어떤 문장을 표준출력장치인 모니터화면으로 출력해주는 함수입니다. 그리고 %d는 정수를 대신할 수 있는 특수문자입니다.
test005.exe를 실행하면서 정수로 3을 입력했으니 화면에는 아래와 같이 나옵니다.
Input number=3
즉 화면에 'Input number=%d'라고 나오지 않고 %d에 변수 a의 내용인 3를 대입시켜서 화면에 보여주기 때문에 'Input number=%d'라는 문장은 'Input number=3'라는 문장으로 화면에 표시됩니다.
'b=a*a' 문장은 변수 a의 값에 a의 값을 곱해서 b라는 변수에 대입하라는 뜻입니다.
b=a*a;
이 문장은 어렵지 않게 이해하실겁니다. a라는 변수를 두 번 곱해서 b라는 변수에 대입시키라는 뜻입니다. a가 3이였으니까 b는 3*3=9가 되는 겁니다. 그래서 b=9이라는 내용물을 가진 변수가 되었습니다. 이때 사용하는 * 기호는 곱하기를 뜻하는 연산자 기호입니다. 그리고 = 는 대입을 뜻하는 기호입니다.
C++언어에서 = 기호는 대입을 뜻하는 치환연산자이며 수학에서 사용하는 같기부호는 ==를 사용합니다.
주의할 점은 = 가 일반적인 수학에서 이야기하는 같기부호(등호)가 아니라는 점입니다. 수학시간에 배우는 =는 왼쪽과 오른쪽의 내용이 같다는 뜻입니다. 즉 b=a*a라고 써있다면 a 곱하기 a는 b와 같다는 뜻입니다. 그러나 C++언어에서는 =를 대입기호라고 합니다. 그래서 오른쪽에 있는 내용을 왼쪽에 있는 변수에 대입시키라는 뜻을 가지고 있습니다. 그래서 이 기호를 치환연산자라고 말합니다.
그러므로 b=a*a라는 문장은 a에 a를 곱한 수를 b라는 내용에 대입시키라는 의미입니다. 그럼 C++언어는 수학기호에서 사용하는 같기부호(=) 대신에 어떤 기호를 사용할까요? == 기호를 사용합니다. b==a*a 라고 하면 a에 a를 곱한 수가 b와 같다는 뜻입니다.
**요약: b=a*a라는 명령문은 a에 a를 곱해서 b에 대입하라는 뜻입니다. C++언어에서 = 기호는 오른쪽에 있는 내용을 왼쪽에 있는 변수로 대입하라는 뜻을 지니고 있는 치환연산자입니다. 수학에서 사용하는 =기호(같기부호)와 같은 의미를 지닌 기호는 ==
기호입니다.
printf("input * input=%d \n",b);
이 문장은 앞서 출력한 printf()함수의 문장과 사용법이 같으니 쉽게 이해할 수 있을 겁니다. b라는 변수의 내용물을 %d에 대입시킨 후에 화면에 "" 안의 문장을 출력하라는 뜻입니다. 그래서 화면에 'input * input=9'라는 문장이 출력되는 겁니다.
그렇다면 숫자를 입력받을 때 3 대신 5를 입력하면 'input * input=25'가 대신 출력될 것이고, 16을 입력한다면 'input * input=256'이 출력되어 화면에 나타날 겁니다.
그러나 입력숫자로 300을 입력하면 90000이 나오지 않고 엉뚱한 숫자가 나옵니다. 이런 엉뚱한 결과는 오버플로우 또는 언더플로우라가 발생하기 때문인데 이에 대해서는 나중에 설명드리겠습니다.
^^^그림: test005.exe를 실행시키고 16을 입력하면 제곱수로 256을 계산해줍니다.
자 이제 제곱수를 구하는 프로그램을 만들면서 변수의 사용법에 대해서 간단하게 알아봤습니다. test005.cpp의 예제를 통해서 여러분은 변수라는 것을 어떻게 사용하는지 알아봤습니다. 제곱수를 구할 수 있다면 세제곱이나 네제곱수도 쉽게 구할 수 있을 겁니다. test005.cpp를 조금만 고치면 네제곱수를 구할 수 있습니다. 어디를 어떻게 고치면 될까요?
'b=a*a;'라는 문장을 'b=a*a*a*a'라고 고치면 됩니다. 그러면 b라는 변수에 a를 네번 곱한 값이 대입됩니다. 다라서 나중에 b의 변수내용을 출력하면 네제곱수가 출력됩니다. 즉 a로 4를 입력받았다면 4*4*4*4=256이 계산되어 나오는 겁니다. 이처럼 변수는 매우 유용하게 사용할 수 있는 개념입니다.
**요약: 변수에 대입시키는 값을 다른 숫자로 바꾸면 출력결과도 원하는 새롭게 계산되어 출력됩니다.
[연습문제]
test005.cpp의 내용을 고쳐서 ex05.cpp로 저장합니다. 입력받은 수의 제곱을 보여주는 문장 다음 줄에 세제곱수를 보여주는 문장을 추가로 보여주도록 고칩니다.
[연습문제 정답]
// EX05.CPP -- 세제곱 보여주는 문장 보여주기
#include <stdio.h>
#include <iostream.h>
void main(void)
{ int a, b;
printf("INput Number: "); // 숫자를 입력하라는 안내문을 화면에 출력
scanf("%d",&a); // 숫자를 입력받아서 변수 a에 저장
printf("Input number=%d \n",a); // 입력받은 숫자인 변수 a를 화면으로
보여줌
b=a*a; // 변수 a에 a를 곱해서 변수 b에 대입 */
printf("input * input=%d \n",b); /* 변수 b를 화면에 보여줌 */
b=a*a*a; // 변수 a를 세번 곱해서 변수 b에 대입 */
printf("input * input * input=%d \n",b); /* 세제곱한 값인 변수 b를
화면에 보여줌 */
}
test005.cpp의 내용을 고쳐서 ex05.cpp로 저장합니다. 입력받은 수의 제곱을 보여주는 문장 다음 줄에 세제곱수를 보여주는 문장을 추가로 보여주도록 고칩니다.
2.5.10.함수 대신 표준입출력 객체를 이용한 제곱수 구하기 프로그램
표준입력 객체를 이용해 제곱수를 구하는 프로그램을 만들어보겠습니다.
test005.cpp에서는 scanf() 함수를 이용해서 입력을 받았습니다. 이번에는 표준입출력 객체를 이용하여 제곱수를 구하는 프로그램을 만들어보겠습니다.
이미 우리는 cout라는 표준출력 객체를 배웠습니다. 이번에는 표준입력 객체인 cin에 대해서 알아보겠습니다. 아래의 내용을 입력하신 후에 test0051.cpp로 저장, 컴파일, 링크한 후에 실행해보기 바랍니다.
^^^그림: test0051.cpp의 소스파일 내용
iostream.h는 표준입력 객체를 이용하기 위해 필요한 헤더파일입니다.
test0051.cpp의 소스파일을 하나씩 분석하면서 test005.cpp와 어떻게 다른지 알아보겠습니다.
iostream.h는 표준입출력 객체에 대한 내용을 기록해둔 헤더파일입니다. 다시 말해서 cout과 cin을 사용하기 위해서 '#include <iostream.h> 문이 추가되어야 합니다.
cout에 대해서는 앞서 배웠기 때문에 별도로 설명드리지 않겠습니다. 'cout<<"INput Number: ";'라는 문장과 'printf("INput Number: ");' 라는 문장은 같은 뜻을 가진 명령문인 셈입니다. 단지 하나는 표준출력 객체를 이용했고 다른 하나는 printf() 함수를 사용한 것이 다를 뿐입니다.
cin은 키보드로 입력받은 내용을 오른쪽의 변수에 대입시키는 객체입니다.
이 문장은 처음 나오는 명령문입니다. 먼저 cin부터 알아보겠습니다. cin은 cout과 반대인 객체입니다. 그러니까 cout가 오른쪽에 있는 내용을 cout로 출력하는 출력 객체인 것과는 반대로, cin으로 입력받은 내용을 오른쪽으로 내보내는 입력 객체입니다.
쉽게 말해서 'cout<<"Hello, Kim"'이라는 명령문은 'Hello, Kim'이라는 문장을 cout의 기본출력장치인 모니터로 보여주라는 뜻이고, 'cin>>a'는 cin의 기본입력장치인 키보드로부터 입력받은 내용을 변수 a에 저장하라는 뜻입니다.
cout에 사용하는 << 연산자는 계속 붙여서 사용할 수 있습니다.
이 문장에서 'cout<<"Input number="'까지는 쉽게 이해하실 겁니다. 'Input number='라는 문장을 모니터로 보여주라는 뜻입니다. 그런데 이전과 달리 이번에는 << 기호가 오른쪽에 두 개 더 붙었습니다. 이처럼 << 연산자는 cout 객체에 연속적으로 붙여서 사용할 수 있습니다. 물론 >> 연산자 역시 마찬가지입니다.
이제 이 문장은 쉽게 이해하실 수 있으리라 생각합니다. 앞서 사용한 문장과 같은 모습이죠. 단지 변수 a 대신에 변수 b가 들어갔을 뿐입니다.
이렇게 해서 test005.cpp와 test0051.cpp는 전혀 다른 명령문을 사용했지만 똑 같은 결과를 보여주는 프로그램이 되었습니다. 어떤 명령문을 이용하여 프로그램을 작성할 것인지는 여러분의 마음에 달렸습니다.
일단 이 책에서는 표준입출력 객체의 사용법을 익히기 위하여 printf() 함수 대신에 cout 객체를 사용하는 방향으로 예제를 만들어가겠습니다.
^^^그림: test0051.exe를 실행시킨 화면도 test005.exe와 같습니다.
**요약: printf() 함수와 scanf() 함수 대신에 표준입출력 객체인 cout과 cin 명령문을 이용하여 프로그램을 만들어도 결과는 같습니다. <<연산자나 >>연산자는 연속적으로 사용 가능합니다.
[연습문제]
test0051.cpp의 내용을 고쳐서 ex06.cpp로 저장합니다. 입력객체를 이용하여 세 개의 수를 연달아 입력받은 후에 입력받은 세 개의 수를 더해서 보여주는 프로그램으로 만듭니다.
[연습문제 정답]
// EX06.CPP -- 두 개의 수를 입력받아 곱한 결과를 보여주기
#include <stdio.h>
#include <iostream.h> // 표준입출력 객체에 관한 헤더파일
void main(void)
{ int a, b, c, d;
cout<<"INput 1st Number: "; // 첫번째 숫자를 입력받음
cin>>a; // 입력객체인 cin을 사용하여 숫자를 입력받아 a에
저장
cout<<"INput 2nd Number: "; // 두번째 숫자를 입력받음
cin>>b; // 두번째 숫자는 변수 b에 저장
cout<<"INput 3rd Number: "; // 세번째 숫자를 입력받음
cin>>c; // 세번째 숫자는 변수 c에 저장
cout<<"1st number="<<a<<"\n"; // 변수 a의 내용을 화면으로 보여줌
cout<<"2nd number="<<b<<"\n"; // 변수 b의 내용을 화면으로 보여줌
cout<<"3rd number="<<c<<"\n"; // 변수 c의 내용을 화면으로 보여줌
d=a+b+c; // 변수 a와 b, c를 더해 변수 d에 대입
cout<<"1st + 2nd + 3rd="<<d<<"\n"; // 더한 값 d를 화면으로 보여줌
}
test0051.cpp의 내용을 고쳐서 ex06.cpp로 저장합니다. 입력객체를 이용하여 세 개의 수를 연달아 입력받은 후에 입력받은 세 개의 수를 더해서 보여주는 프로그램으로 만듭니다.
2.5.11.컴파일러의 도움말 보기
컴파일러에서 제공하는 함수에 대한 설명을 담은 책을 라이브러리책이라고 합니다.
이제 어느 정도 함수에 대해서 알아보았으니 구체적으로 C++언어의 함수를 어떻게 사용하는지 알아보겠습니다. 그동안 사용한 함수는 printf()함수와 scanf() 함수뿐입니다. 그러나 배워야 할 기본 함수는 무척 많으며, 기본적인 함수의 사용법만 간단하게 설명해도 두꺼운 책 한 권이 넘습니다. 때문에 저는 모든 함수의 사용법을 다 설명하기가 곤란합니다. 대신 중요한 함수의 사용법만 말씀드리겠습니다. 그러나 단 하나의 함수 사용법만 제대로 이해할 수 있다면 나머지 함수의 사용법은 쉽게 배울 수 있습니다. printf() 함수의 사용법만 제대로 이해하고 활용할 수 있다면 C++언어의 모든 함수 사용법을 익히는 일이 그리 어렵지 않을 겁니다.
가장 많이 사용하면서도 가장 복잡하고, 또한 가장 기본적인 함수인 printf()함수에 대한 설명은 라이브러리 책을 참고해야 합니다. C++언어 책이나 C의 함수설명을 담아놓은 라이브러리 책(또는 매뉴얼)을 보면 printf()함수의 사용서식이 매우 복잡하게 나옵니다.
라이브러리 책이란 컴파일러의 함수사용법을 간단하게 설명해놓은 책을 말합니다. 간단하게 설명해놓은 책이라도 하지만 몇 백 쪽이 넘는 두꺼운 책입니다. 그렇기 때문에 항상 라이브러리 책을 곁에 두고 참고하면서 프로그램을 짜야 합니다.
함수에 대한 설명은 컴파일러에 내장된 도움말을 참고하면 편리합니다.
C의 함수가 워낙 방대하고 복잡하기 때문에 라이브러리 책을 곁에 끼고 살아야하지만 두꺼운 책을 들고 다니기란 쉬운 일이 아닙니다. 이럴 때는 컴파일러프로그램 안에 들어 있는 도움말을 참고해서 프로그램을 짭니다. 프로그램 안에 도움말이 들어 있는 것을 도움말이 내장되었다고 표현합니다. 덕분에 볼랜드C++에서도 간단하게 도움말을 볼 수 있습니다.
BC에서는 [Ctrl]+[F1]을 누르면 커서가 위치한 낱말의 도움말을 볼 수 있습니다.
BC에서는 [F1]을 눌렀을 때 현재 작업중인 영역에 대한 포괄적인 설명이 나옵니다. 예를 들어서 test0051.cpp의 편집화면에서 [F1]을 누르면 현재 작업중인 화면이 편집화면(Edit window)이라고 알려줍니다.
^^^그림: BC에서 [F1]을 누르면 작업중인 화면에 대한 도움말을 볼 수 있습니다.
그리고 다음과 같은 경고문이 표시되고 경고문으로 표시된 줄이 선택되었을 경우 [F1]을 누르면 선택된 문장 전체에 대한 도움말이 표시됩니다.
예를 들어서 다음 화면은 컴파일 과정에 발생한 에러에 대한 메시지를 보여주고 있는 상태입니다. 편집화면에서는 에러가 발생한 명령문이 반전되어 있고, 하단의 에러 메시지 창에는 소스파일의 문제가 무엇인지 알려주고 있습니다. 에러 메시지는 'Unable to open include file 'MINE.H''입니다.
^^^그림: 컴파일 과정에서 발생한 에러에 대한 경고문.
이 상태에서 [F1]을 누르면 에러 발생문에 대한 도움말을 볼 수 있습니다. 이처럼 [F1]은 화면 전체나 문장과 같이 폭이 넓은 영역의 도움말을 제공합니다.
^^^그림: 경고문이 선택되었을 때 [F1]을 누르면 경고문에 대한 도움말이 표시됩니다.
때로는 현재 사용중인 함수나 명령어의 좀더 자세한 사용법을 알고싶을 때가 있습니다. 이처럼 함수나 명령어에 대한 도움말이 필요할 때도 내장된 도움말을 참고하면 편합니다.
BC에서 도움말이 필요한 함수나 명령어의 낱말 위에 커서를 이동시킨 후에 [Ctrl]+[F1]을 누르면 자세한 도움말이 나타납니다.
^^^그림: printf() 함수 위에서 [Ctrl]+[F1]을 눌렀을 때 나오는 도움말 화면
그리고 도움말을 색인(Index)순으로 모두 보고싶다면 [Shitf]+[F1]을 누르면 됩니다. [Shitf]+[F1]을 누르면 다음 화면처럼 가나다순으로 BC에서 사용할 수 있는 명령어와 함수들의 목록이 나타납니다. 화살표키를 이용해서 보고 싶은 낱말 위로 이동시키면 선택된 낱말이 반전됩니다. 반전된 낱말 위에서 [Enter]를 누르면 그 낱말에 대한 도움말이 표시됩니다.
^^^그림: [Shift]+[F1]을 누르면 사용 가능한 명령어가 가나다순으로 표시됩니다.
**요약: BC에서는 [F1]을 누르면 작업중인 화면에 대해서, [Ctrl]+[F1]을 누르면 커서가 놓인 낱말에 대한 도움말을 볼 수 있습니다. [Shitf]+[F1]을 누르면 전체 명령어를 가나다순으로 살펴볼 수 있습니다.
BCW의 도움말은 BC와 같습니다.
BCW에서도 BC와 마찬가지 키를 사용합니다. 또 도움말의 구조도 같습니다. 그러나 마우스를 이용해 메뉴의 Help 메뉴를 선택하는 방법도 있습니다. 즉 [Shitf]+[F1]을 누르거나 메뉴에서 Help 메뉴를 선택하고 Index 메뉴를 선택하는 방법을 사용할 수 있습니다.
^^^그림: 마우스로 Help 메뉴를 선택하면 도움말을 볼 수 있습니다.
[Shitf]+[F1]을 누르거나 메뉴에서 Help 메뉴를 선택하고 Index 메뉴를 선택하면 다음 화면과 같이 Index 형식의 도움말이 나타납니다. 초록색으로 밑줄 친 낱말을 마우스로 선택하면 해당 주제를 보여주는 화면으로 바뀝니다. BCW의 도움말 사용법은 윈95/98의 도움말 사용법과 같기 때문에 따로 설명드리지 않겠습니다.
^^^그림: [Shift]+[F1]을 눌렀을 때 나오는 도움말 화면
그리고 printf 낱말 위에 커서를 이동시킨 후에 [Ctrl]+[F1]을 눌렀을 때는 printf() 함수에 대한 도움말 화면이 나타납니다. 윈도용 도움말로 나타나기 때문에 BC의 화면과는 조금 달라졌지만 기본적인 설명 내용은 같습니다.
^^^그림: printf() 함수 위에서 [Ctrl]+[F1]을 눌렀을 때는 나오는 printf() 함수에 대한 도움말
그리고 [F1]만 눌렀을 때는 작업 창이나 작업줄 전체에 대한 도움말이 나옵니다.
^^^그림: [F1]을 누르면 작업중인 창에 대한 도움말이 나타납니다.
BCW에서는 창닫기 아이콘을 눌러 경고문 창을 닫을 수 있습니다.
예를 들어서 test005.cpp 파일을 컴파일할 때는 에러가 없지만 링크 과정에서 에러가 발생할 수 있습니다. 링커에 대한 환경설정을 바꾸지 않고 볼랜드C++의 기본 환경으로 설정된 경우 다음과 같은 경고문을 보여줍니다.
BC와는 달리 BCW는 독립된 창으로 뜨기 때문에 BC처럼 경고문이 화면을 분할하지 않습니다. 따라서 경고문 창이 뜨면 창닫기 아이콘을 눌러서 닫아주면 경고문 창이 사라집니다. 또 편집화면으로 돌아가고 싶다면 편집화면 창을 마우스로 선택하면 됩니다.
링커 과정에서 문제가 있다는 경고문 창을 보면 3줄이 있는데 맨 밑에 있는 'Linker Warning:'이라는 줄을 선택하면 반전된 상태로 표시됩니다. 이 상태에서 [F1]을 누르면 이 경고문에 대한 도움말이 나타납니다.
^^^그림: 링크 과정에서 문제가 발생했다는 경고문을 별도의 창으로 보여줍니다.
'Linker Warning:'이라는 줄에서 [F1]을 누르면 이 경고문에 대한 도움말이 나타나는데 역시 또 하나의 창이 뜹니다. 따라서 이 창을 닫으려면 창닫기 아이콘을 눌러주어야 합니다.
^^^그림: 경고문 창에서 한 줄을 선택하고 [F1]을 눌렀을 때 나오는 도움말
**요약: BCW에서 [F1]을 누르면 작업중인 화면에 대해서, [Ctrl]+[F1]을 누르면 커서가 놓인 낱말에 대한 도움말을 볼 수 있습니다. [Shitf]+[F1]을 누르면 전체 명령어를 주제별로 살펴볼 수 있습니다.
2.5.12.함수와 인수의 사용법
가장 기본이 되는 printf() 함수의 사용법을 통해 함수 사용법을 익힙니다.
도움말이나 라이브러리 책을 보시면 아시겠지만 printf() 함수의 설명만 몇 쪽이 넘습니다. 때문에 printf() 함수의 사용법 설명만 봐도 아마 머리가 아플겁니다. 대부분의 사람은 printf() 함수의 사용법만 보고도 기가 질려서 언어 배우기를 포기할 지 모릅니다.
반면에 printf() 함수의 사용법만 제대로 익혔다면 C++언어의 함수는 대부분 통달했다고 볼 수 있습니다. printf() 함수는 가장 쉽고 기초적인 함수지만 또한 C++언어의 모든 내용을 포함하고 있는 함수이기도 합니다. 그래서 printf() 함수를 자유롭게 쓸 수 있는 사람은 다른 함수도 자유롭게 사용할 수 있습니다.
하여간 도움말을 통해서 대충의 내용은 알겠지만 여전히 함수의 사용법은 어렵습니다. 그러므로 몇 개의 보기를 통해서 간단하게 printf() 함수의 사용법을 익혀보도록 하겠습니다.
앞서 써먹었던 문장을 다시 살펴봅시다.
이 두 문장이 printf() 함수의 기본 문장 형식입니다. printf() 함수는 ()안의 문장을 화면으로 출력해줍니다. 그런데 괄호 안의 내용은 일정한 형식이 있어야 합니다.
printf() 함수에서 문장을 출력할 때는 큰 따옴표로 묶습니다.
첫번째 지켜야할 형식입니다. 원하는 문장을 출력하고 싶을 때는 원하는 문장을 큰따옴표로 앞 뒤를 묶어주어야 합니다.
함수 안에 사용하는 요소를 인수라고 하며 따옴표로 각 인수 사이를 구별합니다.
이때 괄호 안에 넣어서 사용하는 인자나 구성 요소들을 인수라고 말합니다. 인자가 되는 수라는 뜻입니다. 그러니까 "Hello, Kim JoongTae."라는 문장 전체가 하나의 인수가 되는 겁니다.
인수는 하나만 사용할 수 있는 것이 아니고 여러 개를 사용할 수 있습니다. 두번째 문장에서는 두 개의 인수를 사용하고 있습니다. "Input number=%d \n"라는 인수와 a라는 인수입니다. 두 인수를 구별하기 위해서 두 인수 사이에 쉼표를 넣었습니다. 그러니까 printf() 함수는 "Input number=%d \n"이라는 문장형식을 첫번째 인수로 삼고, a라는 변수를 두번째 인수로 삼고 있는 겁니다.
C언에서 사용하는 인수라는 개념은 도스명령어의 매개변수라는 개념과 비슷합니다. 요즘은 도스를 사용하는 분이 별로 없지만 도스를 사용할 때는 도스 명령어 뒤에 매개변수를 붙여서 사용하는 경우가 많습니다.
예를 들어 dir이라는 도스명령어에 여러 개의 인수를 사용할 수 있습니다. 예를 들면 'dir *.exe /w /p'과 같은 명령어인데 이를 C++언어의 형식으로 나타내면 이렇게 나타낼 수 있을 겁니다.
dir 인수 인수 ...
그러니까 dir 뒤에는 인수를 계속해서 사용할 수 있다는 뜻이 됩니다. ... 기호는 뒤에 더 많은 인수가 올 수 있다는 것을 줄여서 나타내는 기호입니다. 물론 인수로 사용할 수 있는 갯수는 한정되겠지만 dir 명령어 뒤에 매개변수를 사용하는 것처럼 C++언어의 함수도 여러 개의 인수를 사용할 수 있습니다. 그리고 도스 명령어가 매개변수를 통해서 좀더 세밀하게 명령어를 제어할 수 있는 것처럼 C++언어 역시 인수를 통해서 세부적으로 함수를 제어할 수 있습니다.
**요약: printf() 함수에서 문장을 보여주려면 큰 따옴표로 싸야 합니다. 함수 안에는 여러 개의 인수를 넣어서 사용할 수 있는데 각 인수는 따옴표로 구분합니다. 인수란 함수나 명령어에서 사용하는 인자들, 또는 함수나 명령어의 요소들을 가리키는 말입니다. 인수는
함수나 명령어의 실행과정에 사용되며 인수가 변하면 실행 결과도 바뀝니다.
2.5.13.\n 기호의 의미와 ESC문자열
\n 기호는 줄바꿈문자를 나타내는 특수문자입니다.
다시 첫번째 문장을 세부적으로 살펴보겠습니다. "Hello, Kim JoongTae. \n"이라는 문장의 맨 마지막에 붙은 \n에 대해서는 간단하게 말씀드렸습니다. 줄바꿈문자를 나타내는 특수한 기호입니다. \라는 문자와 n이라는 문자를 출력하라는 뜻이 아닙니다.
줄을 바꾸라는 명령을 내리면 커서는 다음 줄의 첫번째 칸에서 깜박거립니다. 우리들이 도스명령어를 치거나 글틀에서 문서를 작성하면서 큰글쇠를 치면 다음 줄의 첫번째 칸으로 가는 것을 볼 수 있습니다. 이것을 줄바꿈이라고 말하는데 컴퓨터는 두 단계 과정을 거쳐서 줄바꿈을 합니다.
컴퓨터에서 줄바꿈은 캐리지리턴과 라인피드의 두 가지 과정이 합쳐진 것입니다.
캐리지리턴(carriage return)과 라인피드(line feed)라는 두 가지 단계를 거칩니다. 캐리지리턴은 커서를 그 줄의 처음으로 옮긴다는 뜻입니다. 라인피드는 커서 위치에서 한 줄 밑으로 커서를 옮긴다는 뜻입니다. 그러니까 다음줄 첫번째 칸으로 커서가 이동하는 과정은 먼저 캐리지리턴이라는 동작을 통해서 현재 줄의 첫번째 칸으로 이동한 뒤에 그곳에서 다시 한 칸을 내리는 과정(라인피드해서)이 추가되어 이루어집니다. 간단한 그림으로 설명하면 다음과 같은 과정입니다.
sample_ : 원래는 이런 문장입니다. 커서가 맨 끝에 와 있죠.
sample[Enter] : [Enter]를 입력합니다.
←
_sample[Enter] : 먼저 캐리지리턴을 해서 첫번째 칸으로 커서를 이동시킵니다.
↓sample[Enter] : 라인피드를 해서 커서를 밑줄로 이동시킵니다.
_
sample : 그래서 커서가 다음줄 첫번째 칸에서 깜박이는 겁니다.
_
만약 \n이라는 줄바꿈 문자를 사용하지 않는다면 이어서 나오는 printf() 함수의 문장은 지금 출력한 문장에 붙어서 화면에 출력될 겁니다. 그럼 보기가 좋지 않겠죠? 그러니까 원래는 "" 안에 원하는 문장을 아무 것이나 넣을 수 있지만 문장 안에 \라는 문자가 나오면 일단 특수기호라고 생각을 합니다. 그래서 컴파일러가 기계어로 번역을 할 때 특수문자로 번역을 하는 겁니다.
\ 기호를 표시하려면 '\\'이라는 특수문자를 이용해야 합니다.
그럼 그냥 문자로서 \를 표현하려면 어떻게 해야 할까요?
그때는 \\라고 써주면 됩니다.
다음과 같은 문장을 화면에 출력하고자 한다고 합시다.
C:\ is C Drive's Root Directory
이때 C:\이라는 글자에 \가 들어갑니다. 만약 아무런 생각 없이 C:\라고 쓰면 이상한 결과가 나올겁니다. 한 번 시험삼아서 써보시기 바랍니다. 아마 \ 글씨가 화면에 출력되지 않을 겁니다. 이럴 때는 다음과 같이 쓰면 됩니다.
또는 cout을 이용할 때는 다음과 같이 사용합니다.
조금 번거롭기는 하지만 이렇게 해서 \ 글자를 화면에 출력할 수 있습니다. 그렇다면 " 기호도 사용할 수 없다는 것을 눈치챌 수 있습니다. 큰따옴표는 출력할 문장의 처음과 끝을 나타내는 특수기호이기 때문입니다. " 기호를 사용하려면 \" 형식을 이용해 표시할 수 있습니다.
그러므로 이쯤에서 중요한 \ 기호를 몇 가지 알아두는 것이 좋겠습니다. printf()함수를 비롯해서 C++언어의 출력함수에서 아래와 같이 쓸 경우 오른쪽의 뜻으로 쓰겠다는 뜻입니다.
이때 한글윈도를 사용하는 국내 사용자들이 주의할 점이 있습니다. \ 기호는 원래 각 나라의 화폐단위를 대신할 수 있도록 설정된 기호입니다. 때문에 영문도스나 영문윈도에서는 \ 기호 모습 그대로 보이지만 한글도스나 한글윈도에서는 우리나라의 화폐단위인 ￦ 기호로 나타납니다. 따라서 컴퓨터에서 ￦ 기호로 표시되는 부분은 \ 기호와 같은 기호임을 숙지하기 바랍니다.
예를 들어서 다음과 같은 예제 소스파일를 만들어 s01.cpp로 저장하여 실행해보기 바랍니다.
^^^그림: s01.cpp에서는 \ 기호로 입력되었습니다.
BC나 BCW에서는 소스파일에 \ 기호로 표시되는 기호가 실행파일로 바뀌어 실행될 경우 한글윈도에서는 다음 예제 화면처럼 ￦ 기호로 바뀌어 표시됩니다.
^^^그림: s01.exe를 실행시키자 ￦기호로 바뀌어 표시됩니다.
표: C++언어에서 사용하는 \기호(ESC문자)의 종류
\a : bell 소리를 냅니다. 그러니까 컴퓨터에서 에러를 나타내기 위해서 '삑'하고 울리는 소리가 납니다. 컴퓨터에서는 '삑' 하는 소리도 일종의 문자에 해당하는 셈입니다.
\b : 백스페이스를 뜻합니다. 그러니까 화면에 글씨를 출력했다면 커서를 다시 앞으로 한 칸 이동시킵니다.
\n : 라인피드를 뜻하므로 줄을 바꾸어 새로운 줄을 시작하라는 뜻입니다. 원래는 커서를 다음줄로 이동시키는 일만 합니다. 그런데 C에서는 특별한 명령이 없는 한 다음 줄의 첫번째 칸으로 이동시킵니다.
\r : 캐리지 리턴을 뜻합니다. 그러니까 커서를 현재 줄의 첫번째 칸으로 이동시킵니다.
\t : 탭을 뜻하는 기호입니다. 탭을 설정한 크기만큼 커서를 이동시킵니다. 당분간은 탭을 사용할 일이 없으므로 탭에 대한 설명은 생략하겠습니다.
\\ : 역빗금(\)문자를 표시하라는 뜻입니다.
\' : 작은 따옴표를 표시합니다.
\" : 큰 따옴표를 표시합니다.
\기호는 확장문자, 또는 확장열, ESC코드, ESC 문자, ESC 문자열 등으로 부릅니다.
\ 기호를 앞에 붙인 문자를 확장문자, 또는 확장열, ESC코드, ESC 문자, ESC 문자열 등으로 다양하게 부릅니다. \ 기호가 의미하는 것은 ESC sequence code를 의미하므로 가장 정확한 표현은 ESC따름문자가 됩니다. 그러나 이 책에서는 많은 사람들이 사용하는 ESC문자열이라는 낱말을 사용하겠습니다.
ESC문자열은 특수한 문자를 표시할 때 주로 사용합니다. 보통 우리가 사용하는 A~Z, a~z까지의 문자나 숫자 등은 타자를 쳐서 바로 나타낼 수 있습니다. 그러나 줄바꿈 문자를 비롯해서 backspace문자, tab문자, 삑 소리, 라인피드기호, 괘선문자 등은 타자를 쳐서 나타낼 수 없습니다. 그래서 이런 특수한 문자를 표시하기 위해서 \ 기호를 사용합니다.
컴퓨터는 이진수와 1바이트의 아스키코드만 이해합니다.
많은 사람들이 쉽게 이해하지 못하는 부분은 backspace나 빈칸, 탭, 캐리지리턴도 문자라는 점입니다. a, b, c, d만 문자로 알고 있던 분들은 탭이나 캐리지리턴, 삑 소리도 하나의 문자라는 사실을 잘 이해 못합니다.
그러나 컴퓨터의 입장에서 생각해보면 이해가 될 겁니다. 컴퓨터는 기본적으로 이진수만을 이해합니다. 그러나 이진수로 대화나누기가 어렵기 때문에 1바이트로 표현되는 숫자를 이용해 컴퓨터와 대화를 나눕니다. 1바이트로 표현할 수 있는 256가지 경우에 문자를 배정한 미국의 표준 코드를 아스키코드라고 하니다.
그래서 65번이라는 숫자가 들어오면 65번에 해당하는 약속을 실행합니다. 그런데 65번 코드는 A자 모양을 화면에 표시하는 것으로 약속되어 있습니다. 그래서 화면에 A자를 보여주는 겁니다. 마찬가지로 7이라는 기호가 들어오면 7번 코드에 해당하는 약속을 실행하는데, 7번 코드는 '삑'하는 소리를 내라는 약속이 되어있는 겁니다. 사람 눈에는 전혀 다른 글자로 보이겠지만 컴퓨터 입장에서 보면 어떤 숫자에 해당하는 약속된 기능을 실행한다는 점에서는 다 같은 놈으로 보이는 겁니다.
1바이트로 표현할 수 있는 문자를 정한 미국 표준코드가 아스키코드입니다.
이처럼 0부터 255까지의 숫자에 특별한 기능을 약속해놓은 코드체계를 ASCII코드라고 합니다. 그러니까 \ 기호는 ASCII코드(아스키코드) 중에서 우리가 글판(키보드)으로 입력할 수 없는 기호들을 표현하고자 할 때 주로 사용합니다.
\ 기호를 이용해 약속된 형식에 맞게 표현식을 사용하면 원하는 특수문자를 표시할 수 있습니다. 앞에서 우리가 배운 \ 기호는 자주 쓰이는 열 종류의 문자만 표현했습니다만 실제로는 더 많은 종류의 특수문자가 있고, 이런 문자를 사용하기 위한 표현방법도 다양합니다. 아스키코드가 256개의 문자를 가지고 있으므로 \ 기호를 이용해서 나타낼 수 있는 문자도 매우 많습니다. 그러나 당장은 앞서 배운 중요한 ESC문자열로 충분하기 때문에 나머지는 다음 기회에 배우는 것으로 하겠습니다.
'\n'은 라인피드를 나타내지만 예외적으로 C++언어에서는 '\r\n'의 값으로 출력해줍니다.
위의 ESC문자열을 보면 \n이 라인피드이고, \r이 캐리지 리턴이므로 다음줄 첫번째 칸으로 이동하기 위해서는 \r\n이라고 써야하지 않을까 하고 생각하는 분이 있을 겁니다. 맞습니다. 제대로 쓴다면 먼저 캐리지리턴을 하고 라인피드를 해야 하므로 \r\n이라고 써야 맞습니다. 그러나 C언어 프로그램에서는 특별한 약속이 없는 한 \n이라는 기호를 만나면 캐리지리턴과 라인피드 동작을 동시에 해서 화면에 커서를 이동시킵니다. 저장할 때는 \n이라고 저장하고 화면이나 프린터로 문장을 보여줄 때는 \r\n처럼 행동하는 겁니다. 그 까닭은 \r\n이라고 저장하다보니 자료의 크기가 많아지기 때문입니다. 그래서 저장할 때는 라인피드를 뜻하는 \n으로만 저장하고, 이를 화면에 출력할 때는 \r\n으로 출력하는 겁니다. 가능하면 자료를 저장할 때 적은 바이트수로 저장하려다보니 이런 예외규칙을 만든 겁니다.
**요약: \ 기호를 붙여서 사용하는 문자를 ESC문자열이라고 하는데, 특수문자를 출력하고자 할 때 주로 사용합니다. 따옴표나 역빗금을 표시하려면 앞에 \ 기호를 붙여서 사용합니다.
이제 위의 특수기호 사용법으로 간단하게 예를 들겠습니다.
C:\ is "ROOT" Directory
이와 같은 문장을 화면에 출력하고 싶다면 다음과 같이 써야 합니다.
위와 같이 쓰면 커서가 그 줄의 뒤에서 깜박거릴 겁니다. 그리고 다음과 같이 쓰면 커서가 다음 줄의 첫번째 칸에서 깜박거릴 겁니다.
또는
\n을 쓴 횟수만큼 커서가 내려갑니다.
그렇다면 하나의 문장 안에 \n기호를 여러 번 쓰면 그 수만큼 커서가 밑으로 내려갈까요? 예. \n 기호를 쓴 만큼 커서가 내려갑니다. 따라서 printf() 함수에 쓴 문장은 한 문장이라 하더라도 실제로 화면에 출력할 때는 여러 줄 짜리로 출력할 수 있습니다. 다음과 같이 printf() 함수를 적어서 실행시켜 보기 바랍니다.
결과를 보기 전에 미리 한 번 예상해보기 바랍니다. '1st line.'이라는 문장을 출력한 다음에 커서를 다음 줄, 다음 줄로 옮겼습니다. 두 줄 밑으로 옮긴 것이죠. 그리고 나서 '3th line.'이라고 적고, 다시 커서를 다음 줄 첫번째 칸으로 옮기고 '4th line.'라고 출력하고, 다시 세 칸 밑으로 옮겨서 '7th line.'이라고 적는 겁니다. 그리고 마지막에는 \n을 안 썼으니 커서는 '7th line' 뒤에서 깜박거릴 겁니다.
다음과 같이 s02.cpp으로 소스파일을 만들어 실행시켜보기 바랍니다.
^^^그림: s02.cpp의 내용
s02.cpp를 이 문장대로 프로그램을 작성하고 컴파일하면 아래와 같이 화면에 출력됩니다.
^^^그림: 소스파일에 \n\n\n을 넣으면 세 칸 밑으로 이동합니다.
**요약: \n은 라인피드를 뜻하는 ESC문자열인데, 특별한 약속을 하지 않으면 화면에 출력할 때 캐리지리턴과 라인피드코드를 동시에 출력해줍니다. 즉 다음 줄 첫번째 칸으로 이동하라는 뜻을 지닌 특수문자입니다.
[연습문제]
s01.cpp의 내용을 고쳐서 ex07.cpp로 저장합니다. 프로그램의 실행결과는 다음과 같이 나오도록 만듭니다. 보기 문장의 '' 기호는 제외하고, 가운데 있는 따옴표만 나오면 됩니다.
첫번째 줄에는 '디렉토리 이름은 "C:\GAME\TETRIS"입니다.'라는 문장을 보여줍니다.
두번째 줄에는 '그의 이름은 '김중태'입니다.'라는 문장을 보여줍니다.
위의 두 문장을 보여준 다음에는 '삑' 소리가 연달아 세번 나오도록 합니다. 그러니까 세번째 줄에는 문장을 보여주는 것이 아니라 소리를 내도록 합니다.
[연습문제 정답]
// EX07.CPP -- ESC 문자열의 사용 보기
#include <stdio.h>
#include <iostream.h>
void main(void)
{
cout<<"디렉토리 이름은 \"C:\\GAME\\TETRIS\"입니다.";
// 소스파일에서는 \ 기호로 보임
cout<<"그의 이름은 \'김중태\'입니다.";
cout<<"\a\a\a"; // 삑 소리가 세번 납니다.
}
s01.cpp의 내용을 고쳐서 ex07.cpp로 저장합니다. 프로그램의 실행결과는 다음과 같이 나오도록 만듭니다. 보기 문장의 '' 기호는 제외하고, 가운데 있는 따옴표만 나오면 됩니다.
첫번째 줄에는 '디렉토리 이름은 "C:\GAME\TETRIS"입니다.'라는 문장을 보여줍니다.
두번째 줄에는 '그의 이름은 '김중태'입니다.'라는 문장을 보여줍니다.
위의 두 문장을 보여준 다음에는 '삑' 소리가 연달아 세번 나오도록 합니다. 그러니까 세번째 줄에는 문장을 보여주는 것이 아니라 소리를 내도록 합니다.
이제 원하는 문장을 화면에 출력하는 것을 하실 수 있을 겁니다. 문장을 출력하는 방법을 배웠으니 이번에는 문장 안에 변수의 내용을 대체시켜서 출력하는 방법을 배우겠습니다.
printf("Input number=%d \n",a);
위에서 % 기호 역시 \ 기호와 마찬가지로 특수기호입니다. % 기호는 다른 인수로부터 입력받은 변수나 상수로 대체시켜서 출력하라는 뜻입니다. 다른 말로 변수나 상수를 대입시켜서 출력한다고 합니다. 위의 문장에서 %d라고 썼는데, 이 기호는 정수로 바꾸어 출력하겠다는 뜻입니다. 그리고 쉼표 뒤에 a자를 써놓았으니 대입할 내용은 변수 a의 내용이라는 것을 알 수 있습니다.
자 그럼 여기서 다시 % 기호의 종류를 알아보겠습니다.
**표: % 기호의 종류
%c 인수를 하나의 글자로 바꾸어 출력합니다.
%d 인수의 내용을 10진수인 정수로 바꾸어 출력합니다.
%e 인수를 float나 double의 형태, 즉 실수로 바꾸어 출력하는데 지수표시 방법으로 출력합니다. 예를 들어서 123.45 라는 수는 1.23450e+02 라는 형태로 출력됩니다.
%f 인수를 float나 double의 형태, 즉 실수로 바꾸어 출력합니다.
%g 인수를 %e나 %f의 형식으로 출력하는데 출력하는 글자수가 적은 쪽을 택해서 출력합니다.
%o 인수의 내용을 8진수로 바꾸어 출력합니다.
%s 인수를 문자열, 즉 문장으로 바꾸어 출력합니다.
%u 인수를 부호가 없는 10진수로 바꾸어 출력합니다. 즉 음수로는 표기하지 않습니다.
%x 인수의 내용을 16진수로 바꾸어 출력합니다.
%% %문자를 출력하고자 할 때 사용합니다.
%가 나오면 특수기호로 알아듣기 때문에 %를 특수기호가 아닌 일반 글자로 출력하고자 할 때는 %%라고 써주면 됩니다.
This is 100%
위와 같은 문장을 화면에 출력하고 싶다면 다음과 같이 쓰면 됩니다.
printf("This is 100%% \n");
위와 같이 고쳐서 한 번 출력해보시기 바랍니다. 원하는 결과를 얻을 수 있을 겁니다.
% 기호의 사용법은 생각보다 까다롭습니다. 그러나 이중에서 우리들이 배워야 할 기호는 몇 가지만 간단하게 배우도록 하겠습니다. 중요한 %기호는 %c, %d, %f, %s의 네 가지입니다.
자 다음과 같이 프로그램을 짜서 test006.cpp로 저장하고 컴파일, 링크, 실행시키기 바랍니다.
^^^그림: test006.cpp의 소스 내용
[Alt]+[F5]로 확인해보거나 BCW를 빠져나가서 test006.exe를 실행시키면 다음과 같은 내용이 화면에 출력될 겁니다.
^^^그림: test006.exe를 실행했을 때 나오는 화면
이제 %기호를 어떻게 쓰는지 알 수 있을 겁니다. %c는 글자 하나만 화면에 출력하고자 할 때 사용합니다. %d는 정수를 출력하고자 할 때 사용합니다. %f는 실수를 화면에 출력할 때 사용합니다. %s는 문장을 출력할 때 사용합니다.
cout을 이용할 경우에는 다음과 같이 << 연산자를 연이어 사용하면 됩니다.
^^^그림: test0061.cpp의 소스 내용
test0061.c를 실행파일로 만들어 실행보면 test006.c와 같습니다. 그러나 실수 부분을 표시하는 내용은 조금 다릅니다. test006.exe에서는 12.340000로 나왔지만 test0061.exe에서는 12.34로 나옵니다.
^^^그림: test0061.exe를 실행했을 때 나오는 화면
인수로 사용하는 문자 옆에는 작은 따옴표를 붙입니다.
test006.cpp의 예제 프로그램을 한 문장씩 다시 확인해봅시다.
%c는 한 글자를 출력하라는 뜻입니다. 그리고 인수로는 'c'를 사용했습니다. 여기에서 c 라는 글자 좌우에 작은 따옴표를 붙이는 것을 잘 기억해두시기 바랍니다. C++언어에서는 하나의 글자를 표시할 때 글자 좌우에 작은 따옴표를 붙입니다.
만약 작은 따옴표를 붙이지 않는다면 무엇으로 인식하겠습니까? c라는 변수로 받아들일 겁니다. 그러면 에러가 나오고 컴파일이 되지 않습니다.
인수로 사용하는 숫자는 작은 따옴표를 안붙이고 숫자 그대로 적어줍니다.
또는
%d는 정수로 변환해서 보여준다는 뜻입니다. 인수로는 10을 사용하고 있습니다. 이때 10 좌우에는 작은 따옴표를 붙이지 않습니다. 10은 숫자로 인식하기 때문입니다. 만약 '5'라고 썼다면 5라는 수가 아닌 5라는 글자로 인식하게 될 겁니다.
실수는 기본적으로 소숫점 이하 6자리까지 표시됩니다.
%f는 실수를 표현하고자 할 때 사용합니다. 역시 인수로 사용할 수 있는 것은 숫자이므로 12.34라는 실수를 사용했습니다. 그런데 결과는 조금 이상하게 나왔습니다. test006.exe와 test0061.exe의 결과가 각기 다릅니다.
This is 12.340000
위와 같이 나왔습니다. 그러니까 소숫점 이하 자리수를 소수 6번째 자리까지 표시한 겁니다. 이것은 볼랜드C++의 기본값입니다. 따라서 소숫점 둘째 자리까지만 표시하도록 하고 싶다면 별도의 기호를 더 넣어주어야 합니다.
그러나 test0061.cpp의 실행결과는 제대로 12.34로 나옵니다. 그 까닭은 test0061.cpp에서는 %f 기호를 사용하지 않고 숫자를 직접 입력했기 때문입니다.
인수로 사용하는 문자열은 큰 따옴표로 싸줍니다.
%s는 문자열(=문장)을 출력하라는 소리입니다. 그리고 인수로는 "This is String"을 사용했습니다. 앞의 %c의 인수로 사용한 것과 차이점을 알 수 있을 겁니다. 문자열은 앞뒤로 큰따옴표를 붙인다는 사실입니다. 그러니까 작은 따옴표를 붙이면 글자 하나를 뜻하고, 큰 따옴표를 붙이면 여러 개의 글자를 나열한 문장으로 인식하는 겁니다.
**요약: %기호는 변수의 내용을 %기호에 대입하라는 뜻을 지닌 특수기호입니다. %c는 글자 하나를 대입할 때, %d는 정수를 대입할 때, %f는 실수를 대입할 때, %s는 문장을 대입시킬 때 사용합니다. 인수로 사용하는 문자는 작은따옴표로, 문자열은 큰따옴표로
감싸줍니다.
실수의 자릿수를 조정할 때는 - . 등의 기호를 사용합니다.
그럼 %f로 출력되는 숫자의 칸이나 자릿수를 조절하고 싶다면 어떻게 하면 되는지 알아보겠습니다. %기호 바로 뒤에 다음과 같은 형식을 사용하면 됩니다.
%기호 다음에 나오는 빼기(-) 기호는 출력할 때 그 줄의 왼쪽부터 출력을 시작하라는 뜻입니다. 그러니까 왼쪽 정렬을 하라는 뜻입니다. 다음의 숫자 10은 출력할 때 10칸짜리로 출력하라는 뜻입니다. 다음의 마침표(.)는 소숫점 이하의 자릿수를 구별하기 위해서 사용합니다. 그 뒤의 3이라는 숫자는 소숫점 3번째 자리까지 출력하라는 뜻입니다. 그러면 이 문장을 실행하면 다음과 같이 출력될 겁니다.
This is 12.340
그런데 빼기(-) 기호를 사용하지 않을 경우에는 C언어 프로그램이 보통 오른쪽정렬을 기준으로 맞춥니다. 그렇다면 명령문을 다음과 같이 바꾸어서 출력하면 어떻게 나올까요?
그러면 다음과 같은 출력이 나올겁니다.
10칸으로 출력하는데 오른쪽으로 붙여서 정렬하기 때문에 'This is'라는 문장 사이에 빈 칸이 6칸 들어간 겁니다. 그리고 .1f라고 했으니 소수 첫째 자리까지만 출력한 겁니다. 그래서 12.34의 둘째 자리인 4는 탈락해버린 겁니다.
실수는 기호의 조합에 따라서 화면에 나타나는 모양이 다릅니다.
이제 이 형식에 맞추어서 몇 가지 출력을 해보도록 하겠습니다. 아래와 같이 프로그램을 작성하고 test007.cpp로 저장해서 실행파일을 만들어보기 바랍니다. 이제 컴파일하고 링크한 다음에 실행한다는 것이 어떤 것인지 아실테니 앞으로는 프로그램을 실행해보라는 말로 대신하겠습니다. 앞으로 제가 프로그램을 실행하라고 하면 컴파일하고 링크한 다음에 실행까지 하는 과정을 합쳐서 말한 것으로 받아들이시기 바랍니다. 다시 한 번 말씀드리지만 볼랜드C++에서 프로그램을 컴파일하고 링크하고 실행까지 하는 지름글쇠는 [Ctrl]+[F9]입니다.
^^^그림: test007.cpp의 소스 내용
프로그램의 결과를 예측하면 이렇습니다.
printf(" This is %10.1f \n",123.456);
123.456을 오른쪽 정렬을 해서 10칸에 맞추어서 소수점 첫째 자리까지만 출력하라.
printf(" This is %10.2f \n",123.456);
123.456을 오른쪽 정렬을 해서 10칸에 맞추어서 소수점 둘째 자리까지만 출력하라.
printf(" This is %-10.1f \n",123.456);
123.456을 왼쪽 정렬을 해서 10칸에 맞추어서 소수점 첫째 자리까지만 출력하라.
printf(" This is %-10.2f \n",123.456);
123.456을 왼쪽 정렬을 해서 10칸에 맞추어서 소수점 둘째 자리까지만 출력하라.
printf(" This is %5.1f \n",123.456);
123.456을 오른쪽 정렬을 해서 5칸에 맞추어서 소수점 첫째 자리까지만 출력하라.
printf(" This is %5.5f \n",123.456);
123.456을 오른쪽 정렬을 해서 5칸에 맞추어서 소수점 다섯째 자리까지 출력하라.
그러면 아래와 같은 출력이 화면에 나올 겁니다.
^^^그림: test007.exe을 실행시켰을 때 나오는 화면
실수로 연산할 때는 반올림 기능에 주의해야 합니다.
이렇게 출력이 나왔다면 제대로 프로그램을 작성한 겁니다. 자 이 화면에서 무엇인가 이상한 것을 발견했을 겁니다. 123.456을 지정했으므로 123.4나 123.45가 나와야 할 것 같은데 123.5와 123.46이 나왔습니다. 왜 그럴까요? 반올림을 했기 때문입니다. 즉 소수 첫째 자리만 표시하기 위해서 소수 둘째 자리 이하를 계산한 겁니다. 그래서 소수 둘째 자리가 5가 넘으면 반올림을 해서 첫째 자리에 표시하고, 5 미만이면 첫째 자리에 표시하지 않는 겁니다.
따라서 C++언어를 이용해서 숫자를 계산할 때는 주의해야 합니다. 비록 소수점 아래의 숫자지만 오차가 나올 수 있기 때문입니다. 그래서 컴퓨터언어로 프로그램을 짜서 정밀한 숫자를 다룰 때는 항상 컴파일러의 프로그램이 가지는 반올림을 염두에 두고 짜야 합니다. 안 그러면 엉뚱한 계산결과가 나올 수 있습니다.
이제 이정도로 하면 기본적인 printf() 함수의 사용법을 배운 셈입니다. 사실 printf() 함수의 사용법은 더욱 복잡하지만 일단은 이정도로만 끝내겠습니다. 좀더 자세한 사용법은 다음에 낼 책에서 다루도록 하겠습니다. 다만 이 책에서 배운 내용을 바탕으로 '볼랜드 C++'의 라이브러리 책을 보신다면 어렵지 않게 쉽게 이해할 수 있을 것으로 생각합니다.
**요약: 실수는 특수기호의 조합에 따라서 출력결과가 완전히 다르게 출력됩니다. 또한 반올림 기능이 있어 예상했던 결과와 다른 계산결과가 나올 수 있다는 점을 염두에 두어야 합니다.
2.5.14. C++언어에서 사용하는 자료형의 종류
상수의 형태를 자료형이라 하며 정수형, 실수형, 문자형을 가장 많이 사용합니다.
앞서의 함수에 사용된 인수는 글씨와 문장, 숫자로 구별됨을 알 수 있습니다. 또한 숫자는 정수와 실수로 구분된다는 사실을 알 수 있습니다. 컴퓨터라는게 결국은 자료를 다루는 것이기 때문에 C++언어를 비롯한 모든 언어는 자료의 형태나 종류를 분류해서 사용합니다. 자료형은 다른 말로 상수라고 할 수 있습니다.
예를 들어서 1이나 2라는 숫자는 정수형의 자료입니다. 그리고 1과 2는 변수를 설명할 때 말씀드린 것처럼 상수입니다. 1은 언제나 1의 값을 가질 뿐이며 3이나 4의 값을 가질 수 없습니다. A라는 문자도 역시 상수(constant)입니다. A자는 언제나 A자라는 값을 가지기 때문입니다. 이때 1이나 2는 정수 상수라고 하고, A나 B는 문자 상수라고 합니다. 3.45는 실수상수라고 합니다.
물론 변수(variable) 역시 자료형을 가지고 있습니다. 그에 따라 정수형 변수, 문자형 변수 등으로 구분됩니다.
가장 손쉽게 생각할 수 있는 자료형(date type) 또는 상수(constant)의 구분은 숫자와 문자입니다. 그러나 실은 그보다 더 세부적으로 나누어집니다. C++언어의 자료형은 구분 방법에 따라서 수가 달라지겠지만 대충 50여종 정도 됩니다. 이를 더 세분화하여 분류하고 더구나 여기에서 파생되는 자료형을 모두 포함한다면 백 여 가지도 훨씬 넘습니다.
이 모든 자료형을 기억했다가 올바른 형식에 맞추어 사용하기란 쉬운 일이 아닙니다. 그리고 각각의 자료형이 사실은 동일한 자료를 뜻하는 경우도 있습니다. 그래서 그 중에서 가장 많이 사용하는 자료형만 정리하면 다음과 같습니다.
우선 C++언어의 자료형은 크게 다음의 세 가지 형태로 구분됩니다.
기본형(basic type)
파생형(derived type)
클래스형(class type)
이 중에서 가장 많이 사용하는 기본형은 다시 다음과 같이 구분됩니다. 다섯 가지로 구분했지만 열거형은 거의 사용하지 않으며 void형 역시 실체가 없기 때문에 실제로 주로 사용하는 자료형은 정수형, 실수형, 문자형의 세 가지뿐입니다.
정수형(int)
int
long
unsigned
unsigned long
실수형(또는 부동소수점형.float)
float
double
문자형(char)
char
unsigned char
열거형(enum)
void형(void)
정수형은 수학에서 사용하는 정수를 뜻합니다.
먼저 정수형부터 살펴보겠습니다. 정수형 자료는 우리가 수학시간을 통해서 배운 정수와 같은 개념입니다. 흔히 0, 12, -33과 같은 숫자가 정수형입니다. 실수형(또는 부동소수점형)은 우리가 흔히 말하는 실수와 거의 같은 개념입니다. 당연한 이야기이겠지만 실수형은 정수형을 포함하고 있습니다. 0, 12, -33의 정수 숫자는 물론 소수점이 들어간 숫자들도 포함합니다. 예를 들면 0.1, -3.45, 3.56E7과 같은 숫자들이 실수형 자료(상수)입니다.
문자형의 1, 2, 3은 도형적 의미만 있지만 정수형의 1, 2, 3은 계산이 가능하다는 차이가 있습니다.
그리고 문자형은 우리가 사용하는 문자를 말합니다. a, B, 1과 같은 문자들입니다. 여기서 주의할 점은 문자형의 문자 1과 정수형이나 실수형의 1은 다른 형태의 자료라는 것입니다. 문자로서의 0, 1, 2, 3은 계산을 할 수 없고 단지 화면에 그 형태를 보여주기만 하는 도형적인 의미를 가지고 있을 뿐입니다. 그러나 정수형이나 실수형에서 사용하는 0, 1, 2, 3은 더하기 곱하기를 할 수 있고 계산이 되는 숫자를 말하는 겁니다.
이는 종이에 연필로 1000이라고 쓴 종이와 5000이라고 쓴 종이의 숫자와 천원 짜리 지폐와 5000원 짜리의 지폐에 적힌 숫자의 개념이 다른 것과 같습니다.
종이에 연필로 낙서한 것처럼 쓴 1000이라는 숫자는 그저 사람이 눈으로 볼 수 있는 도형적인 개념에 불과합니다. 5000이라고 써진 종이를 준다고 해서 1000이라 써진 종이 다섯 장과 교환하지는 못합니다. 숫자는 그냥 종이에 써진 도형일 뿐입니다. 종이 한 장은 종이 한 장의 가치를 인정받을 뿐입니다.
그러나 5000원 짜리 지폐를 주면 1000원 짜리 지폐 5장과 교환이 가능합니다. 5천원을 주고 1천원 짜리 물건을 사면 4천원을 거슬러 받습니다. 이처럼 지폐에 써진 숫자는 계산이 가능한 숫자라는 특징을 가집니다.
낙서한 숫자와 지폐의 숫자가 매우 다른 의미를 가지는 것처럼 문자 1은 그저 도형일 뿐이고, 숫자 1은 계산이 가능하다는 차이점이 있습니다.
정수형은 부호와 숫자의 범위에 따라서 int, long, unsigned, unsigned long으로 구분해 사용합니다.
정수형은 다시 int, long, unsigned, unsigned long로 나눕니다. int형으로는 -32768에서부터 32767까지만 다룰 수 있다고 보시면 됩니다. 그럼 10만이 넘는 숫자는 다루지 못한다는 이야기인가? 예 그렇습니다. 10만이 넘는 숫자는 다루지 못합니다. 그 까닭은 정수형의 자료는 2바이트의 크기를 이용해서 자료를 다루기 사용하기 때문입니다.(시스템에 따라서 이런 자료형의 길이는 변합니다. 대형 기종에서는 4바이트의 크기를 사용하기도 합니다.)
1바이트로는 256을 표현할 수 있습니다. 그러므로 2바이트 즉, 16비트로는 256×256=65536가지의 경우를 표현할 수 있습니다. 그래서 -32768에서 32767까지의 수를 다룰 수 있습니다. 그러나 음수를 사용하지 않는다면 0부터 65535까지의 수를 표현할 수 있습니다. 음수를 사용하지 않는 정수 상수를 unsigned init라고 표시합니다. 줄여서 unsigned라고 합니다. 그러니까 int형은 -32768~32767까지를 다루고, unsigned형은 0~65535까지 다루는 자료형입니다.
왜 2바이트의 크기로 정수를 다루는가 하는 의문을 가지는 분도 있을 겁니다. 2바이트의 크기로 정수를 다루는 까닭은 쓸 데 없는 낭비를 줄이기 위해서입니다. 예를 들어서 정수 하나를 다루는데 2바이트를 사용한다면 100개의 숫자를 다루거나 저장하기 위해서는 200바이트가 필요합니다. 또 정수 하나를 다루는데 4바이트를 사용한다면 똑 같은 100개의 숫자를 다루기 위해서 400바이트가 필요한 셈입니다. 2배나 더 큰 크기가 필요합니다. 이렇게 되면 램도 2배, 디스크에 저장할 때도 2배의 크기가 필요합니다. 그러나 대부분의 경우 정수를 다룰 때는 만 단위를 넘지 않습니다. 그래서 2바이트 크기로 정수를 다루는 정수형 자료를 만든 겁니다.
long형은 int형보다 큰 숫자를 다룰 때 사용하며 4바이트의 크기를 가집니다.
long형은 int형보다 큰 숫자를 다룰 때 많이 사용합니다. long형은 4바이트로 된 정수형 상수입니다. 4바이트이므로 65535×65535=4294967296 가지의 자료를 다룰 수 있습니다. 음수를 포함한 정수형을 다룬다면 -2147483648~2147483647까지 다룰 수 있습니다.
unsigned long형은 음수를 안 쓰고 양수만 다루겠다는 뜻이므로 0~4294967295까지 다룰 수 있습니다. 42억까지 다룰 수 있으므로 어지간한 수는 다 다룰 수 있는 셈입니다. 그러나 실제로 프로그램을 짜다보면 long형 자료(long형 상수)를 쓸 일이 그리 많지 않다는 것을 알게될 겁니다. 대부분은 int형으로도 해결할 수 있기 때문입니다.
**요약: 정수형 자료(정수 상수)를 다음과 같은 4종류를 가장 많이 사용합니다.
자료형 사용바이트 수 표현가능한 숫자
int 2 -32768~32767
unsigned 2 (부호 없음) 0~65535
long 4 -2147483648~2147483647
unsigned long 4 (부호 없음) 0~4294967295
정수형보다 큰 수를 다룰 때는 실수형을 사용합니다.
그럼 정수형보다 큰 숫자를 다루거나 소수점이 있는 실수를 다룰 때는 무엇을 사용해야 할까요? 실수형을 사용해야 합니다. 실수형 중에서 float형은 4바이트 즉, 32비트의 자료크기를 가지고 자료를 처리합니다. 그리고 double형은 8바이트 즉, 64비트 정도의 자료를 다룹니다. 따라서 어지간한 숫자는 대부분 float형만으로도 다룰 수 있습니다.
얼핏 생각하기에는 float형이나 정수형의 long형의 자료크기가 같기 때문에 같은 float형도 0~4294967295까지만 다룰 수 있는 것으로 알기 쉽습니다. 그러나 같은 4바이트를 사용하지만 float형은 지수부와 가수부라는 형태로 나누어서 수를 표시하기 때문에 더 큰 수도 표시할 수 있습니다. 예를 들어서 100억이라는 수를 10000000000으로 표시하는 것이 아니고 1.0+e10으로 표시합니다. 즉 1.0을 표시하는 부분과 +e10을 표시하는 두 부분으로 나눌 수 있기 때문에 가수부분의 백 억, 천 억도 어렵지 않게 표시할 수 있습니다. 물론 숫자가 4294967295처럼 각 자리의 숫자가 각기 다르다면 long형으로 표시할 수 있는 정도의 숫자밖에는 표시할 수 없지만 끝의 몇 자리가 0으로 끝난다면 훨씬 큰 수를 표시할 수 있습니다.
실수 상수는 지수 형태로 표현하기 때문에 표현가능한 숫자의 범위가 정수형보다 큽니다.
때문에 float형은 최대 표현가능한 지수를 통해서 최대 표시 가능 숫자가 나옵니다. 그리고 가수부분의 숫자가 어느 정도로 복잡하냐에 의해서 숫자의 정밀도가 달라집니다. 보통 float형의 최대지수는 10의 38제곱까지 가능합니다. 그러니까 1.0e+38이라는 표현을 통해서 최대 10의 38제곱이라는 엄청난 숫자를 표시할 수 있습니다. 그러나 가수부분의 숫자 때문에 보통 유효정밀도는 7자리를 삼습니다. 7자리까지는 오차가 거의 없다는 뜻이니 백 만 단위나 소수 7째 자리까지 별 오차가 없다는 뜻입니다.
그리고 double형은 최대 표현 가능한 지수가 308제곱이며, 유효정밀도는 16자리입니다. 조 단위까지도 오차 없이 사용할 수 있다는 뜻입니다.
**요약: 실수형 자료형(실수 상수)은 다음 같이 두 종류를 가장 많이 사용합니다.
자료형 사용 바이트 수 표현가능한 숫자 유효정밀도
float 4 10의 38제곱 7자리
double 8 10의 308제곱 16자리
문자 상수는 영문 1글자를 표시할 수 있습니다.
숫자가 아닌 문자형 자료 즉, 문자 상수로 char과 unsigned char 두 종류가 있습니다. char형은 1바이트를 사용합니다. 따라서 256가지 경우를 표현할 수 있습니다. 숫자로 말하자면 0~255까지 표현할 수 있는데, 이 숫자를 가지고 문자를 표시합니다. 즉 0~255까지의 숫자를 이용해서 아스키코드를 표현합니다. 이렇게 해서 문자 상수 1바이트로 영문 한 글자를 표시할 수 있습니다.
char형은 -128~127까지 사용하므로 음수도 사용합니다. 그럼 음수를 통해서 아스키코드를 표현할 수 있는가? 안됩니다. 그러나 C언어 프로그램에서는 char 상수가 음수일 경우에는 이를 128~255까지의 확장코드로 변환해서 사용합니다. 즉 unsigned char형은 0~255라는 숫자를 통해서 확장문자까지 표현하고, char형은 음수로 255번 아스키코드까지 표현할 수 있습니다.
**요약: char형 문자 상수는 1바이트를 이용해서 문자를 표시하는데 -128~127까지의 숫자를 통해서 문자를 표시합니다. unsigned char형 문자 상수는 0~255까지의 숫자를 통해서 문자를 표시하는 자료형입니다.
변수가 어떤 형의 자료형을 쓸 것인지 미리 알려주는 것이 '변수의 선언'입니다.
자료형을 이렇게 나누는 이유는 프로그램에서 다룰 자료의 형태를 미리 정해두고 다루기 위해서입니다. 때문에 변수나 상수를 사용할 때는 반드시 자료의 형태를 알려주어야 합니다. 예를 들면 'a라는 변수는 정수만을 다룰 것이다'라든지 'b라는 변수는 실수를 다룰 것이다'라고 알려주어야 하는데, 이것을 변수의 선언이라고 합니다.
**요약: 변수를 쓰기 위해서는 변수의 이름과 자료형을 미리 알려주어야 하는데 이를 '변수를 선언한다'고 표현합니다.
2.5.15. 변수의 선언방법과 정의방법, 초기화방법
변수를 선언할 때는 자료형을 적고 쉼표로 구분한 변수이름을 적어주면 됩니다.
변수의 선언방법은 사실 앞에서 이미 여러 번 사용했습니다. 다음과 같이 선언하면 됩니다.
int a;
int a, price, tax;
float a;
floadt a, dollar, won;
double rate;
char a;
char team, group;
변수를 선언할 때 변수의 값도 같이 대입해주는 것을 변수의 초기화라고 합니다.
먼저 자료형을 앞에다 적어주고, 한 칸을 띄고 변수이름을 적어주면 됩니다. 변수는 여러 개를 사용할 수 있는데, 쉼표로 구분하면서 여러 개의 변수를 동시에 선언할 수도 있습니다. 그리고 변수를 선언하면서 변수에 들어갈 내용 즉, 변수의 값도 같이 대입해줄 수 있습니다. 아래의 경우처럼 변수의 기본형을 선언하고 여기에 값을 대입하는 것을 변수의 초기화 또는 정의라고 말합니다. 그러나 가장 많이 쓰는 표현은 '변수에 값을 대입한다'는 표현입니다.
int price=35000, tax=-3500;
float dollar=1, won=800;
char teamname='a';
변수도 선언과 동시에 정의가 가능합니다.
앞서 함수의 선언과 정의에 대해서 설명드리면서 정의와 선언의 차이점을 설명드렸습니다. 변수에서도 선언은 앞으로 변수를 사용하겠다는 말 그대로 선언에 불과합니다. 그러나 정의는 변수의 본체를 밝혀줍니다. 다시 말해서 변수에 값을 대입하는 것은 변수의 정의에 해당합니다. 위의 예문처럼 int price=35000이라고 적으면 정수형 변수 price의 정체는 숫자 35000이 됩니다. 따라서 아래 예문의 경우는 변수의 선언과 동시에 정의도 이루어지는 경우가 됩니다.
이때 음과 양의 부호를 가지지 않는 자료 즉 양의 부호만 가진 자료를 다루겠다면 변수형 앞에 unsigned라는 낱말을 넣으면 됩니다. 정수형일 경우에는 unsigned만 넣어도 됩니다.
unsigned int price=35000;
unsigned long number;
unsigned char moonja;
이렇게 하면 price라는 변수는 이제 양의 정수만을 다루게 됩니다.
변수에 내용을 넣는 행위를 '변수에 값을 대입한다'고 표현합니다.
그런데 변수는 앞서도 몇 차례 말씀드렸듯이 내용이 계속 변하는 수입니다. 그러므로 변수에 다른 내용을 넣을 수도 있습니다. 이때 변수에 다른 내용을 넣는 동작을 보통 변수에 값을 대입한다고 말합니다. 보통은 다음과 같이 합니다.
price=35000;
price=35000+a;
price=a+b;
price=(a+b)*c
첫번째 문장은 price라는 변수에 35000이라는 숫자를 바로 대입한 것입니다. 이렇게 해서 price는 35000이라는 숫자를 지닌 변수가 됩니다. 두번째 문장은 35000에 a의 값을 더한 값을 대입한다는 뜻입니다. 세번째 a라는 변수와 b라는 변수를 더한 값을 price의 값으로 가지라는 문장입니다. 네번째 문장은 a라는 변수와 b라는 변수를 더한 뒤에 c라는 변수를 곱한 값을 price에 대입하라는 뜻입니다.
다시 한 번 앞서 배운 소스파일을 검토해가면서 설명하겠습니다. test005.cpp의 내용을 다시 살펴봅시다.
변수는 사용 전에 반드시 선언해주어야 합니다.
함수 본체의 첫머리에 변수를 선언했습니다. int a, b; 라고 했으니까 정수형인 변수 a와 b를 앞으로 사용하겠다는 선언문입니다. 만약 이 선언문을 하지 않고 중간에 a나 b라는 변수를 쓰겠다고 하면 바로 에러가 나고 맙니다. 물론 컴파일할 때부터 에러가 납니다.
함수와 마찬가지로 변수는 사용 전에 반드시 선언해주어야 한다고 보면 됩니다. 꼭 그래야 할 필요는 없지만 보통 프로그램의 첫부분이나 함수 본체의 첫부분에 변수를 선언합니다. 그래야 그 함수에서 어떤 변수들을 사용하는지 쉽게 알아볼 수 있기 때문입니다.
변수는 선언했지만 변수에 값을 대입하지는 않았습니다. 따라서 값이 대입될 때까지 변수 a와 b는 아무 내용도 없는 빈 변수로 빈둥거립니다. 마치 아직 일감이나 자료를 받지 못해서 노는 직원과도 같습니다. 그러다가 3번째 줄에서 scanf() 함수를 통해서 입력받은 숫자를 a라는 변수에 대입합니다. 그리고 a*a를 해서 b에 대입합니다. 만약 입력받은 숫자가 5라면 a라는 변수에는 5가 들어가고 b라는 변수에는 25가 대입될 겁니다.
변수는 선언한 자료형에 맞는 변수만 대입해야 합니다.
그러다가 새로운 수를 다시 입력받으면 전에 받은 값은 버리고 새로 받은 값으로 변수를 채웁니다. 이때 알아두셔야 할 점은 선언한 자료형에 맞게 자료를 입력하고 출력해야 한다는 겁니다. 정수형으로 선언한 변수에 실수나 문자를 입력해도 안되고, 문자형으로 선언한 변수에 실수를 입력할 경우에는 에러가 발생합니다. 때문에 프로그램을 짤 때는 변수의 자료형을 잘 기억하면서 프로그램을 짜나가야 합니다.
**요약: 변수는 사용하기 전에 반드시 선언해주어야 합니다. 변수를 선언하는 방법은 자료형을 먼저 적고 변수 이름을 적는데 여러 개일 경우 쉼표로 구분해줍니다. 변수를 선언할 때 변수에 값을 대입할 수도 있으며 나중에 대입할 수도 있습니다. 변수에 값을
대입할 때는 자료형에 맞게 대입해야 합니다. 변수에 값을 대입하는 행위를 변수의 정의라고 합니다.
2.5.16. 연산자란?
프로그램에서 다루는 자료형에 대해서 대충 감을 잡으셨다면 이제는 실제로 각 자료를 이용해서 간단한 수학공식을 처리해보도록 하겠습니다. 다음과 같은 프로그램을 짜서 test008.cpp로 만들고 실행해보기 바랍니다.
^^^그림: test008.cpp의 내용
이 프로그램을 실행시키면 화면에 아래와 같은 결과가 나올겁니다.
^^^그림: test008.exe를 실행시켰을 때 나오는 화면
변수 C는 새로운 값을 대입시킬 때마다 이전에 가지고 있던 값을 버립니다.
함수의 내용을 한 줄씩 살펴보도록 하겠습니다.
정수형 변수로 a, b, c를 선언했는데 a에는 10이라는 정수를, b에는 3을 대입시켰고 c는 선언만 한 상태입니다.
c라는 변수에 a와 b를 더한 값을 대입시켰습니다. 그러므로 c=10+3이 되어 13이 대입되었습니다. 그리고 cout 명령을 통해서 c를 화면으로 출력한 겁니다.
이번에는 c 변수에 a와 b를 곱한 수를 대입시켰습니다. 그래서 c=30이 되었습니다. a와 b는 여전히 10과 3이지만 c는 전에 가지고 있던 13이라는 값을 버리고 새로 부여받은 30이라는 숫자를 가지게 된 겁니다. 역시 cout 명령을 이용해서 c가 가진 30이라는 값을 화면으로 출력했습니다.
10÷3은 3.33...이지만 정수형이기 때문에 3이라는 계산결과를 돌려줍니다.
이번에는 c에 a를 b로 나눈 값을 대입시켰습니다. 10/3을 정확하게 계산하면 3.333...이라는 무한소수가 됩니다. 그러나 c라는 변수는 정수형이므로 소수 첫째 자리에서 반올림을 계산한 후에 밑을 잘랐습니다. 그래서 3이라는 숫자가 나온 겁니다.
**요약: 변수는 새 값이 대입되면 이전에 가지고 있던 값을 버립니다. 그리고 계산 결과는 자료형에 맞게 바뀌므로 정확한 계산결과를 원한다면 변수의 자료형에 주의하면서 사용해야 합니다.
덧셈, 곱셈 등에 이용하는 기호를 연산자라고 합니다.
이때 a+b라든지 a*b라는 계산을 할 때 사용하는 +나 * 같은 기호를 연산자라고 합니다. 수학을 배운 분이라면 대충 알고 있는 내용입니다. 그러므로 연산자의 개념을 어렵지 않게 이해할 수 있을 겁니다. C++언어에서 사용하는 연산자는 꽤나 종류가 많습니다. 그중에서 자주 사용하는 중요한 연산자만 적어보면 아래와 같습니다.
결합방향은 좌우중 어느 쪽의 자료부터 계산을 하느냐를 따지는 것입니다.
결합방향이란 어느 쪽의 것부터 계산을 하느냐를 말합니다. → 표시된 방향은 왼쪽부터 차례대로 계산해서 오른쪽으로 계산한다는 뜻입니다. 더하기연산자(+)나 곱하기연산자(*)는 왼쪽에서 오른쪽으로 계산합니다. 그러니까 3+5+2이라고 할 때 먼저 3을 더하고, 다음에 3에 5를 더해 8을 만들고, 다음에 2를 더해서 10을 만드는 겁니다. 2*3*4/2라면 2에 3을 곱하고 여기에 다시 4를 곱하고, 이 수를 다시 2로 나누는 것입니다.
우선순위는 어떤 연산자부터 계산할 것이냐를 따지는 것입니다.
우선순위는 어떤 연산자부터 먼저 계산할 것인가를 정하는 겁니다. 표에서는 위에 적힌 것이 가장 우선순위가 높습니다. 그러니까 더하기(+) 빼기(-) 연산자보다는 곱하기(*) 나누기(/) 연산자가 더 우선 순위가 높으므로 곱하기 나누기부터 먼저 계산합니다. 2+3*4-8/4 라는 계산식이 있다면 3*4를 먼저 계산하고 8/4을 계산한 다음에 더하기와 나누기를 계산해야 합니다. 그러므로 2+3*4-8/4=2+12-2=14-2=12 가 됩니다.
**요약: 연산자란 어떤 수식이나 공식을 계산할 때 사용하는 기호를 뜻하는데 결합방향과 우선순위에 따라서 계산을 합니다.
C++언어에서 - 기호는 빼기의 뜻을 가진 뺄셈연산자가 아니라 대입의 뜻을 가진 대입연산자입니다.
연산자의 종류를 가만 보면 단항연산자의 -와 더하기 빼기의 -가 같아 보이는데, 단항연산자의 -는 음의 수를 뜻하는 마이너스부호이고, 빼기의 -는 왼쪽에 있는 수에서 오른쪽에 있는 수를 빼라는 빼기 기호입니다. 그리고 단항연산자의 &는 번지연산자라는 것입니다.
한 가지 주의할 점이 있는데 C++언어에서는 =가 수학에서 말하는 등식부호가 아닙니다. C++언어에서는 등식부호로 ==를 사용합니다. 즉 a==b라는 문장은 a와 b는 같다는 문장입니다. 그리고 a=b라고 하면 b의 값을 a에 대입하라는 대입연산자가 됩니다.
이러한 연산자를 모두 알 필요는 없습니다. 실제로 초급자가 사용하는 연산자는 수학시간에 배운 연산자 이상은 거의 사용하지 않기 때문입니다. 그러므로 필요한 연산자는 그때 그때 프로그램을 짜가면서 설명드리도록 하겠습니다.
연산자와 변수의 특성을 이용해 간단한 덧셈과정을 구현해봅니다.
이제 이 연산자를 이용해서 간단한 덧셈을 보여주는 소스파일을 하나 만들도록 하겠습니다. 다음과 같이 프로그램을 짜고 test009.cpp로 만들어서 저장하고 실행해보기 바랍니다.
^^^그림: test009.cpp의 소스파일 내용
이 프로그램을 실행하면 다음과 같은 결과가 화면에 출력될 겁니다.
^^^그림: test009.exe의 실행 화면
이 프로그램을 하나씩 살펴봅시다.
정수형 변수인 a를 선언하면서 1이라는 값을 대입시켰습니다.
a라는 변수를 %d에 대입시켜서 화면에 출력하라는 명령입니다. 현재 a라는 변수에는 1이 대입되어 있으므로 a= 1이 화면에 출력됩니다.
a에 a+1을 대입하라는 명령문이니까 a=1+1이 되어서 2가 대입됩니다. 그리고 이를 다시 화면에 출력하니 2가 나옵니다. 변수는 자신의 값에 어떤 연산을 한 결과를 다시 자신의 값으로 가질 수 있습니다. 연산자의 우선 순위가 있기 때문에 가능한 일입니다.
다시 a에 a+1을 대입하라는 명령문입니다. 현재 a에는 2라는 값이 들어가있는 상태입니다. 따라서 a=2+1이 되므로 3이 대입되고 'a= 3'이라는 문장이 화면에 출력됩니다.
지금까지 배운 내용을 잘 기억하고 이해하신다면 여러분은 간단한 글자를 화면에 보여주거나 간단한 숫자를 보여주는 프로그램을 만들 수 있습니다. 그러나 지금까지 배운 내용만으로는 더 복잡하고 경우의 수가 많은 경우를 처리하기 어렵습니다. 컴퓨터는 대량의 자료를 다루는 기계인데 대량의 자료를 다루기 위해서는 많은 작업과정을 컴퓨터 혼자서 하도록 자동화를 시켜주어야 하기 때문입니다. 그러므로 지금까지 배운 C언의 기본개념을 토대로 해서 다음 마당에서는 작업을 효율적으로 할 수 있는 자동화방법을 배우도록 하겠습니다.
**요약: 변수는 새로운 값이 대입될 때마다 이전에 있던 값을 버리고 새로 대입된 값을 가집니다. 또 연산자의 우선 순위에 따라서 자신의 값에 변화를 준 값을 다시 자신이 값으로 가질 수 있습니다.
[연습문제]
test008.cpp의 내용을 고쳐서 ex08.cpp로 저장합니다.
세 개의 변수 a, b, c를 선언하면서 a에는 99를 b에는 3을 대입합니다. a를 b로 더하고, 빼고, 곱하고, 나눈 네 가지 값을 c에 대입하여 각 결과의 값을 한 줄씩 차례대로 보여주도록 합니다.
[연습문제 정답]
// EX08.CPP -- 변수의 선언과 연산자 이용하기
#include <stdio.h>
#include <iostream.h>
void main(void)
{
int a=99, b=3, c; // 정수형 변수 a, b, c를 선언
c=a+b; // a+b의 값을 c에 대입
cout<<" a+b= "<<c<<"\n"; // c의 값을 화면으로 출력해줌
c=a-b; // a-b의 값을 c에 대입
cout<<" a-b= "<<c<<"\n";
c=a*b; // a×b의 값을 c에 대입 */
cout<<" a*b= "<<c<<" \n";
c=a/b; // a÷b의 값을 c에 대입 */
printf(" a/b= %d \n",c);
}
test008.cpp의 내용을 고쳐서 ex08.cpp로 저장합니다.
세 개의 변수 a, b, c를 선언하면서 a에는 99를 b에는 3을 대입합니다. a를 b로 더하고, 빼고, 곱하고, 나눈 네 가지 값을 c에 대입하여 각 결과의 값을 한 줄씩 차례대로 보여주도록 합니다.
