명령어 return은 함수 내부에서 사용되어 함수의 실행을 끝내는 역할을 한다. return 다음에는 반환값이 오기도 하고 void형 함수의 경우는 반환값이 없이 단독으로 사용된다.


  • return; // void형 함수의 종료

  • return 반환값; // 반환값이 있는 함수의 종료 및 결과값 반환


이 명령은 또한 함수 실행 도중에 강제로 수행을 종료하려는 목적으로 사용할 수 있다.


void sayHi() {
 printf("Hi ");
 return;
 printf("all."); //절대 실행되지 않는다.
}


이 예에서 두 번째 printf()함수는 절대로 실행되지 않는다. return명령어에 의해서 함수의 실행이 종료되기 때문이다.


long factorial(long n){
 if (n<0) return -1;
 long lf = 1;
 while(n>1) {
   lf *= n--;
 }
 return lf;
}


이 함수는 만약 인자의 값이 음수라면 -1을 반환하고 바로 종료되어 버린다. 그렇지 않다면 팩토리얼을 구해서 반환한다.


 또 다른 예를 살펴보자. 함수 exec()는 char형을 받아서 char형을 반환한다. main()함수에서는 사용자로부터 숫자를 하나 입력 받아서 cn 변수에 대입한 후 그것을 exec()함수의 인자로 넘겨주면서 호출하도록 되어 있다. ❶줄을 보면 조건 검사를 하기위해서는 exec()함수를 호출해야만 하도록 되어있다. exec()함수 내부에서 보면 만약 입력한 인수가 1,2,3 셋 중 하나가 아니라면 ❷번 줄의 return –1; 명령에 의해서 함수의 수행이 바로 종료되게 된다. 1, 2, 3중 하나라면 해당되는 명령을 수행했다는 표시를 하게 된다. main()함수에서는 이 함수의 반환값이 –1이라면 수행이 제대로 안 되었다고 판단하고 “Execution failed.”라는 메세지를 표시한다. 또한 반환값이 1이라면 정상적으로 명령이 수행되었다고 판단할 수도 있다. 이 예에서와 같이 함수 내에서 return명령을 만나면 그 즉시로 함수는 종료되게 된다.


#include <stdio.h>

char exec(char);

int main(void) {
  char cn;
  printf("1. Turn left.\n");
  printf("2. Turn right.\n");
  printf("3. Stop.\n");
  printf("Command : ");
  scanf("%d", &cn);
  if (exec(cn)==-1) //❶
      printf("Execution Failed.\n");
}

char exec(char ca) {
  if (ca!=1 && ca!=2 && ca!=3)
      return –1; //❷

  switch (ca) {
      case 1:
          printf("Robot turned left.\n");
          break;
      case 2:
          printf("Robot turned right.\n");
          break;
      case 3:
          printf("Robot stopped.\n");
          break;
  }
  return 1;
}


직접 실행해 보고 결과를 확인해 보기 바란다.


C++ 강좌 전체 목록 >>>


c{c++},n{c0026}


Posted by 살레시오
,

 이전 포스트에서는 사용자 정의 함수가 main()함수 이전에 위치하였다. 또 다른 예를 들어보자.


double getArea(double dr) { //반지름으로 원의 면적을 구하는 함수
   double dArea = 3.14*dr*dr;
   return dArea;
}

int main() {
   double da = getArea(5.0);
}


하지만 C++ 프로그램은 관례적으로 main()함수를 다른 함수들보다 위에 위치시킨다. 맨 먼저 실행되는 함수이기도 하지만 이렇게 배치해야 다른 함수들과 호출 순서나 상관 관계를 파악하기 쉽다.


  하지만 다음과 같이 단순히 순서를 바꾸기만 해서는 문제가 생긴다.


int main() {
   double da = getArea(5.0); //문제 발생
}

double getArea(double dr) {
   double dArea = 3.14*dr*dr;
   return dArea;
}


왜냐면 컴파일을 수행할 때 main()함수 내부의 함수 호출 getArea() 을 처리하는 시점에서 이 함수에 대한 어떠한 정보도 없기 때문이다. 이렇게 하면 컴파일러는 오류를 발생시킨다.


 이런 경우 함수에 기본적인 정보를 주는 부분이 main()함수 위에 와야 하는데 이것을 ‘함수의 선언’ 이라고 한다. 함수의 선언은 함수 정의부에서 본체를 제외한 첫 줄만 따로 적어주면 된다.

  

double getArea(double dr); //함수의 선언

int main() {
   double da = getArea(5.0);
}

double getArea(double dr) { //함수의 정의 (본체 포함)
   double dArea = 3.14*dr*dr;
   return dArea;
}


이렇게 하면 컴파일시에 오류를 발생시키지 않는다. 이와 같이 함수의 정의가 호출하는 부분보다 뒤에 온다면 반드시 함수의 선언이 선행되어야 한다.


실행 가능한 전체 프로그램을 다음과 같다.


#include <stdio.h>
double getArea(double);

int main(int argc, char **argv) {
   double da = getArea(5.0);
   printf("Area: %f", da);
}

double getArea(double dr) {
   double dArea = 3.14 * dr * dr;
   return dArea;
}
//실행결과
78.500000


함수의 선언과 정의의 차이점을 다시 한 번 살펴보자.


  • 정의(definition) : 사용자가 만든 함수의 본체 부분까지 실제로 구현된다. 따라서 컴파일러가 함수 본체를 저장할 메모리를 당연히 확보하고 호출부보다 먼저 위치한다면 선언과 겸할 수 있다.


  • 선언(declaration) : 컴파일러에게 사용자가 만든 함수의 인자와 반환 자료형을 미리 알려준다. 컴파일러가 본체를 위한 메모리를 확보하지는 않는다 선언은 정의를 겸할 수 없다.


 함수의 선언에서 인자의 변수명은 생략할 수 있으나 인자의 자료형을 반드시 명시해주어야 한다. 다음 예를 보자.


#include <stdio.h>

int add(int, int);

int main() {
  int ia = 100, ib=150;
  int isum1, isum2;
  isum1 = add(10,20);
  isum2 = add(ia, ib);
  add(10, isum1);
  printf("%d, %d\n", isum1, isum2);
}

int add(int ix, int iy) {
  return ix+iy;
}

실행결과

30, 250


이 예제에서 함수 add()의 선언에서 인자의 변수명을 생략했음을 알 수 있다. 이렇게 해도 문법적으로 오류가 발생하지 않는다.


C++ 강좌 전체 목록 >>>


c{c++},n{c0014}

'프로그래밍언어.Lib > C,C++' 카테고리의 다른 글

C++에서 함수의 인자 전달  (0) 2015.05.18
C++ 의 return 명령어  (0) 2015.05.18
C++ 사용자 함수(function)의 정의  (0) 2015.05.17
C/C++ 함수(function) 개요  (0) 2015.05.17
C++ 클래스 예제 : Led 클래스  (0) 2015.05.17
Posted by 살레시오
,

 C++ 언어의 함수는 크게 반환값이 있는 함수와 반환값이 없는 함수 두 가지로 나눌 수 있다. 반환값이 있는 함수는 함수가 호출(call)이 되어 뭔가 작업을 거친 후 호출한 위치로 그 기능을 수행한 결과 값을 다시 보낸다. 반환값이 없는 함수는 단순히 어떤 기능만 수행한다는 것을 의미한다.


예를 들어서 두 개의 입력 값을 받아서 더한 값을 돌려 주는 기능을 하는 함수를 생각해 보자. 이 때 입력되는 값은 ‘인자’(argument) 혹은 ‘매개변수’(parameter)라고 부른다. (이후에는 ‘인자’ 라는 명칭만을 사용할 것이다.) 계산 결과값(이 경우 더한 값)을 호출한 곳으로 되돌려주는 경우 이것을 ‘반환값’, ‘리턴값’이라고 한다.


  • 인자(argument) - 함수로 넘겨주는 데이터

  • 반환값(return value)  - 함수가 작업이 끝나고 넘겨주는 결과값


사용자 정의 함수는 문자 그대로 ‘사용자가 필요에 의해서 만드는 함수’를 의미한다. C++ 프로그램에서 함수를 사용하기 전에 반드시 정의를 해 주어야 한다. 함수의 정의 형식은 다음과 같다.


반환자료형 함수명(데이터형 인수1, 데이터형 인수2 ...) {
   함수 본체
}


예를 들면 다음과 같다.


void sayHi() {
   printf("Hi ");
   printf("all.");
}


이 함수의 이름은 sayHi()이다. 함수명 앞에는 이 함수의 반환 값의 데이터 형을 명시한다. 반환값이 없는 경우에는 명시적으로 void라는 키워드를 써야 한다. 이 함수는 인자가 없다. 이렇게 인자가 없는 경우 함수명 뒤에 그냥 빈 괄호를 입력한다. 괄호를 생략할 수 없음에 유의하자.


이렇게 정의된 함수는 다음과 같이 호출할 수 있다.


int main() {
   ...
   sayHi(); // sayHi()함수 호출
   ...
}


이것을 합하여 완전한 프로그램으로 만들면 다음과 같다.


#include <stdio.h>

void sayHi()
{
   printf("Hi ");
   printf("all.");
}

int main(int argc, char **argv)
{
  sayHi();
}


Hi all.


이 프로그램을 보면 sayHi() 함수와 main() 두 개의 함수가 있다. 이 예제가 실행될 때는 항상 main()함수를 실행시키며 main()함수가 종료되면 프로그램도 종료된다. C++ 언어는 항상 main()함수를 제일 먼저 실행시킨다.


또 다른 함수의 예를 들어보자.


void sayHello(int in)
{
   for(;in>0;in--) {
       printf(“Hello.\n”);
   }
}


이 함수는 반환값이 없으며 인자를 하나 받는 함수이다. 그렇게 받은 인자의 개수만큼 “Hello.”를 반복해서 출력하는 일을 한다. 이것으로 완전한 프로그램을 만들어 보면 다음과 같다.


#include <stdio.h>

void sayHello(int in)
{
   for(;in>0; in--){
       printf("Hello. ");
   }
}

int main(int argc, char **argv)
{
   sayHello(3);
   int ia = 5;
   sayHello(ia);
}


Hello. Hello. Hello.
Hello. Hello. Hello. Hello. Hello.


main()함수 내에서 sayHello()함수를 두 번 호출했다. sayHello(3)이라고 호출하면 3이라는 정수형 값이 sayHello(int in) 의 인자 in에 저장된 후 함수가 수행된다. 따라서 “Hello.”라는 문자열이 3번 출력된 것이다. 마찬가지로 두 번째 호출인 sayHello(ia) 는 ia의 값은 5를 이 함수의 인자 in에 전달한다. 그러므로 “Hello.”가 다섯 번 출력 된다.


다른 예로 이번에는 반환값이 있는 함수를 들어보자.


float add(float fa, float fb) {
   float fc = fa + fb;
   return fc;
}


이 함수는 반환값의 자료형이 float형이라고 함수명 앞에 명시되어 있다. 인자(argument)는 두 개이고(fa, fb) 모두 float 형이다. 함수 본체에 보면 변수 fc에 두 인자의 합을 저장한 후 return 명령어를 이용하여 그 값을 반환하고 있다. 따라서 이 함수는 두 실수를 받아서 그 합을 반환하는 함수이다.


이와 같이 반환값이 있는 함수의 경우 호출부에서는 그 반환값을 변수에 저장할 수 있다. 예를 들어 다음과 같다.


float fr;
fr = add(1.0f, 2.5f);//fr에 3.5 저장

float fa = 10.1f, fb = 22.3f;
float fc = add(fa, fb);// fc에 32.3이 저장됨


이와 같이 반환값이 있는 함수의 경우는 호출부에서 그 반환값을 받아서 변수에 저장할 수 있다.


#include <stdio.h>

float add(float fa, float fb) {
   float fc = fa + fb;
   return fc;
}

int main(int argc, char **argv) {
   float fr;
   fr = add(1.0f, 2.5f);
   float fa = 12.3f, fb = 45.6f;
   float fc = add(fa, fb);
   printf("fr = %f, fc = %f", fr, fc);
}


fa = 3.500000, fb = 57.899998


 좀 더 다양한 함수의 정의 예를 다음 표에 들었다.


함수 정의 예

의미

void nop() {... }

반환값이 없음을 명시적으로 나타냄

int sub(int ia, int ib) {...}

두 개의 int형 입력, 반환값도 int형

double round(double dx) {...}

하나의 double형입력, 출력도 double형

void myDate(void) {... }

인자가 없음을 명시적으로 나타냄.

char display(char ca) {...}

하나의 char형입력, 출력도 char형


여기에서는 함수의 기본적인 정의 방법에 대해서 살펴 보았다.


C++ 강좌 전체 목록 >>>


c{c++},n{c0025}

'프로그래밍언어.Lib > C,C++' 카테고리의 다른 글

C++ 의 return 명령어  (0) 2015.05.18
C++ 사용자 함수의 선언  (0) 2015.05.17
C/C++ 함수(function) 개요  (0) 2015.05.17
C++ 클래스 예제 : Led 클래스  (0) 2015.05.17
C++의 생성자와 소멸자 실행 순서  (0) 2015.05.17
Posted by 살레시오
,

7.1 함수의 개요      [gdoc]       [smts]

 C 언어는 구조 지향 언어(structure-oriented language)라고 한다. 이 구조의 핵심으로 함수(function)가 있는데 C 언어는 함수로 시작해서 함수로 끝난다고 해도 과언이 아닐 정도이다. C++언어는 객체 지향(object-oriented) 언어이지만 C언어와의 하위 호환성을 유지하므로 구조 지향적인 프로그래밍도 가능하다.


 C 프로그램은 하나 이상의 함수들로 구성되어 있으며 각 함수들은 다양한 일들을 수행할 수 있는 독립적인(self-containted) 부프로그램을 일컫는다. 전술했듯이 C++ 의 경우 C 언어에 대해서 하위 호환성이 있으므로 함수에 대한 기본적인 내용을 똑같이 적용된다.


 함수는 식별자 뒤에 괄호()가 반드시 붙는다. 괄호가 붙지 않는 식별자는 변수이며 괄호가 붙은 식별자는 함수이다. 맨 처음부터 다뤄온 예제들에서 프로그램 본체인 main() 도 바로 함수이다. 그리고 scanf(), printf() 도 함수이다.


  • main() 함수 : C 프로그램의 시작점

  • scanf(), printf() 함수: 입출력 함수


 특히 C 언어는 함수에 의한 언어라고 할 수 있다. 아무리 덩치가 큰 C 프로그램이라도 모두 함수를 조합하여 만들어진다. 함수의 사전적인 의미는 ‘기능’이다. 즉 ‘어떤 일을 수행하는 프로그램의 작은 단위’를 함수라고 한다.


  • 함수(function) - 어떤 작업을 수행하는 프로그램의 작은 단위


 프로그래밍 입문자는 왜 하나의 프로그램을 여러 개의 함수로 나누어 작성해야 되는지 궁금할 수 있다. 함수를 사용하는 장점으로 다음과 같은 것들을 들 수 있다.


  1. 덩치가 큰 프로그램을 작고 다루기 쉬운 함수(모듈) 단위로 분할해서 설계하고 구현함으로서 프로그램을 더 쉽게 작성할 수 있다.

  2. 프로그램을 단계적으로 개발할 수 있다.

  3. 어떤 프로그램에서 작성한 함수를 다른 프로그램에서 재사용할 수 있다.

  4. 프로그램 내부에 세부적인 연산이나 작업 등을 함수의 내부에 숨길 수 있어 프로그램을 보기에 간결하게 만들 수 있다.


 C 언어의 함수는 이미 만들어져서 사용할 수 있는 표준 함수와 사용자가 만들어 사용하는 사용자 정의 함수로 구분할 수 있다.


  • 표준 함수 (standard function)

  • 사용자 정의 함수 (user-defined function)


지금까지 사용했던 scanf(), printf() 함수는 모두 표준 함수에 속하며 C/C++ 언어 표준에 포함되어 일반 사용자가 가져다 쓸 수 있는 이미 만들어진 함수이다.


 표준 함수와 사용자 정의 함수를 프로그램 내에서 적절하게 활용하면 중복되는 부분을 상당히 줄일 수가 있으며 프로그램의 크기도 줄일 수 있는 효과를 얻을 수 있다. 덩치가 큰 프로그램을 제작할 때 작은 크기의 모듈을 설계하여 전체를 짜 맞추는 식으로 만들어 가면 개발 시간을 단축할 수 있고 프로그램을 보다 명료하게 구현할 수 있다는 장점이 있다.


Posted by 살레시오
,

 여기에서는 Led 라는 클래스를 작성하는 예를 들어보도록 하겠다. 아두이노의 예제이지만 아두이노가 C++로 개발하므로 일반적인 클래스의 예제도 된다.


 아두이노의 디지털핀에는 LED를 연결할 수 있으므로 Led 클래스는 연결된 핀 번호를 갖는 멤버가 있어야 한다. 따라서 다음과 같이 작성할 수 있다.

class Led {
   public: byte pin;
};

그리고 인스턴스를 생성할 때 이 핀번호를 받도록 하려면 다음과 같이 생성자를 작성하면 될 것이다.

class Led {
   public:
       byte pin;
       Led(int);
};
Led::Led(int dp) {
       pin = dp;
       pinMode(pin, OUTPUT);
}

이렇게 작성하면 멤버 변수 pin을 외부에서 접근할 수 있다. 예를 들면

Led ledRed(12);
ledRed.pin = 11;

와 같이 인스턴스를 생성한 이후에 핀번호를 바꾸는 것이 가능하다.


 그렇지만 핀번호는 한 번 초기화되면 바꿀 필요가 없으므로 궂이 외부에 노출시킬 필요가 없다. 따라서 다음과 같이 private 멤버로 지정하는 것이 바람직하다. 또한 내부 멤버임을 표시하기 위하여 첫 문자를 underscore(_)로 했다.



class Led {
   public:
       Led(int);
   private:
       byte _pin;
};
Led::Led(int pin) {
   _pin = pin;
   pinMode(_pin, OUTPUT);
}

또는 기본 지정자가 private 이므로 아래와 같이 작성해도 된다.



class Led {
   byte _pin;

   public:
       Led(int);
};

Led::Led(int pin) {
   _pin = pin;
   pinMode(_pin, OUTPUT);
}

 

하지만 명시적으로 private 키워드를 이용하여 지정해 주는 것이 가독성 측면에서 더 바람직하다. 그리고 클래스 선언에서는 public 멤버들이 먼저 오는 것이 좋다. 왜냐면 작성자가 아닌 다른 사람이  (보통 라이브러리에 포함되어 배포되는) 이 클래스를 사용하고자 한다면 public 멤버들만 알면 되지 private 멤버들은 궂이 볼 필요가 없기 때문이다.

 이렇게 핀 번호를 private로 지정해 놓으면 외부에서 접근할 수 없으므로 LED를 켜고 끄는 것도 외부에서 수행할 수 없다. 하지만 멤버 함수는 내부 변수를 접근할 수 있으므로 LED를 켜고 끄는 public 멤버 함수를 다음과 같이 지정할 수 있다. 전체적인 클래스의 모양은 다음과 같을 것이다.

class Led {
   public:
       Led(int);
       void turnOn();
       void turnOff();
   private:
       byte _pin;
};
Led::Led(int pin) {
   _pin = pin;
   pinMode(_pin, OUTPUT);
}
Led::void turnOn() {
   digitalWrite(_pin, HIGH); // 멤버 함수는 _pin을 사용할 수 있다.
}
Led::void turnOff() {
   digitalWrite(_pin, LOW); // 멤버 함수는 _pin을 사용할 수 있다.
}

 멤버 변수나 함수는 관례적으로 그 이름이 소문자로 시작하며 클래스는 대문자로 시작한다는 점을 알아두자. 이것은 식별자(이름)만 보고 타잎을 유추하기 쉽게 하기 위한 C++ 프로그램의 관례이다.

 만약 12번 핀에 빨간색 LED가 연결되어 있다면 다음과 같이 Led 객체를 사용할 수 있다.

Led ledRed(12);
....
ledRed.turnOn();
delay(500);
ledRed.turnOff();
delay(500);
....


이와 같이 인스턴스의 이름도 그것으로 실제 의미를 유추할 수 있도록 작성하는 것이 프로그램의 가독성 측면에서 유리하다.


 만약 11번핀에 노란색, 10번핀에 파란색 LED가 추가로 달려있다면 아래와 같이 작성할 수 있을 것이다.


Led ledRed(12), ledYellow(11), ledBlue(10);

이후에 만약 파란색 LED를 켜고 싶다면 다음과 같이 멤버함수를 호출한다.


ledBlue.turnOn();

 이런 식으로 클래스를 이용하여 LED를 객체화 시키면 직관적으로 프로그램을 작성할 수 있다는 장점이 있다.

C++ 강좌 전체 목록 >>>


c{c++},n{c0023}

Posted by 살레시오
,

 일반 변수와 마찬가지로 어떤 함수 내에서 생성된 인스턴스는 지역 인스턴스, 함수 바깥에 선언된 인스턴스는 전역 인스턴스이다. 전역 인스턴스는 프로그램이 실행될 때 생성되고 프로그램이 종료될 때 소멸된다. 그리고 지역 인스턴스는 함수가 실행될 때 생성되고 함수가 종료될 때 소멸된다.


 다음 예를 가지고 생성자와 소멸자의 실행 순서를 설명하도록 하겠다. 여기에서 rect1 은 함수 바깥에서 생성된 전역 인스턴스이고 rect2, rect3 는 함수 func()의 지역 인스턴스이다.

class Rect {
   .....
};
Rect rect1;
void func() {
   Rect rect2;
   Rect rect3;
   .....
}
int main() {
   .....
   func();
   .....
}

위 예제와 같이 main()함수에서 func() 함수가 호출될 때 rect2, rect3 의 순으로 인스턴스가 생성되며 생성자도 같은 순서로 호출된다. 하지만 func() 함수가 종료될 때는 그 역순으로 소멸되며 소멸자도 역순으로 호출된다.


 전체적인 생성자와 소멸자의 호출순서를 좀 더 자세히 기술하면 다음과 같다.



프로그램 시작

   rect1 객체 생성 (생성자 호출)

   main()함수 실행
       .....

       func()함수 실행
       rect2 객체 생성 (생성자 호출)
       rect3 객체 생성 (생성자 호출)
       .....
       rect3 객체 소멸 (소멸자 호출)
       rect2 객체 소멸 (소멸자 호출)
       func()함수 종료

       .....
   main함수 종료

   rect1 객체 소멸 (소멸자 호출)

프로그램 종료

전역 인스턴스는 전역 변수와 마찬가지로 그 밑에 위치한 모든 함수에서 접근할 수 있는 반변 지역 인스턴스는 포함된 함수 내부에서만 접근할 수 있고 함수의 실행이 끝나면 소멸된다.


C++ 강좌 전체 목록 >>>


c{c++},n{c0022}

Posted by 살레시오
,

 소멸자(destructor)는 생성자와는 반대로 인스턴스가 소멸될 때 반드시 호출되는 멤버 함수이다. 소멸자는 객체가 삭제되는 시점에서 필요한 마무리 작업을 처리하기 위해서 있는 것이다. 예를 들어서 동적으로 할당받은 메모리를 반환하거나 열어 놓은 파일을 닫거나 시리얼 등의 통신 연결을 끊거나 하는 마무리 작업을 수행해야 하는 경우 소멸자를 구현해야 한다.


 소멸자의 이름은 클래스이름 앞에 틸다(~)를 붙인다. 예를 들어서 Rect 클래스의 소멸자 이름은 ~Rect() 이다.


class Rect { // 클래스 선언
   public:
       Rect(); // 생성자
       ~Rect(); // 소멸자
   .....
};

Rect::~Rect() { // 소멸자 구현
   .....
}

 생성자와 마찬가지로 소멸자도 반환값이 없으며 함수 내부에서 어떤 값을 반환해서도 안된다. 또한 생성자를 오버로딩할 수 있으나 (즉,  입력 인자가 다른 생성자가 여러 개 있을 수 있다) 소멸자는 입력 인수가 없는 기본형 하나밖에 없다.


 생성자와 마찬가지로 사용자가 소멸자를 선언하지 않은 경우에는 컴파일러가 자동으로 기본 소멸자(default destructor)를 생성하여 인스턴스 소멸시에 자동으로 호출되도록 한다. 이 기본 소멸자는 아무 일도 하지 않고 단순히 리턴하도록 만들어진다.


C++ 강좌 전체 목록 >>>


c{c++},n{c0021}

Posted by 살레시오
,

 클래스에는 반드시 생성자가 있어야 하며 인스턴스를 생성할 때 반드시 하나의 생성자가 호출되도록 정해져 있다. 사용자가 생성자를 하나도 선언/구현하지 않은 경우에도 컴파일러가 기본 생성자(default constructor)를 만들어서 인스턴스 생성시에 이 기본 생성자를 호출하게 된다. 기본 생성자는 입력 인자가 없는 생성자이다.


 즉, 만약 다음과 같이 생성자가 없다면


class Rect{
   public:
      int width;
      int height;
};


컴파일러는 다음과 같이 입력 인자가 없는 기본 생성자를 자동으로 만들어 준다. 기본 생성자는 inline 멤버 함수로서 아무일도 하지 않는다.


class Rect{
   public:
       int width;
       int height;
       Rect() {}; // 자동으로 생성되는 기본 생성자
};


이와 같이 사용자가 생성자를 하나도 선언/정의하지 않았을 경우 C++ 컴파일러는 백그라운드에서 기본 생성자를 삽입하여 인스턴스 생성 시에 호출한다.


 한 가지 주의할 점은 생성자가 하나라도 선언된 클래스는 기본 생성자가 자동으로 생기지 않는다는 점이다. 이 말은 만약 매개변수가 있는 생성자들만 있는 경우 인스턴스 선언에서 입력 인수가 없이 선언한 경우는 오류를 발생하게 된다는 의미이다. 기본 생성자가 없기 때문이다. 예를 들어서


class Rect {

   public:

       Rect(int iw, int ih);
       int width;
       int height;
};
Rect::Rect(int iw, int ih) { // 입력 인수가 두 개인 생성자
   width = iw;
   height = ih;
}


와 같이 클래스가 정의된 경우에


Rect rect; //에러 발생


라고 인스턴스를 생성하려하면 에러를 발생시킨다. 왜나면 이 경우 기본 생성자를 호출해야 하는데 클래스 정의에서 입력 인수가 두 개인 생성자가 정의되어 있으므로 컴파일러는 자동으로 기본 생성자를 만들지 않기 때문이다. 따라서 없는 기본 생성자를 호출한 격이 되므로 에러를 발생한다.


C++ 강좌 전체 목록 >>>


c{c++},n{c000x}

Posted by 살레시오
,

 생성자(constuctor)란 클래스의 인스턴스가 생성되는 시점에서 자동으로 호출되는 특수한 멤버 함수이다. 생성자 내에서 일반적으로 멤버 변수들을 초기화 시키거나 기타 객체 인스턴스를 생성하는데 필요한 작업들을 수행하게 된다.


class Rect {
   public:
       Rect(); // 생성자1 선언
       int width;
       int height;        
       ....

};
// 생성자 구현
Rect::Rect() { // 입력 인수 없는 생성자
   width = 0;
   height = 0;
}


생성자의 이름은 클래스의 이름과 같다. 생성자는 특별한 경우가 아니면 보통 public 멤버 함수이다. 또한 반환값이 없으며 그럼에도 불구하고 void 를 붙이지 않는다는 점에 주의해야 한다. 이렇게 생성자 있다면 다음과 같이 객체를 생성하는 시점에서


Rect rect1;


입력 인자가 없는 생성자가 호출되어 객체 생성에 필요한 작업을 수행하게 된다.


 생성자는 여러 개를 정의할 수 있으나 (constructor overloading) 이들 중 하나만 실행된다. 아래는 생성자가 두 개인 경우의 예이다.


class Rect {
   public:
       Rect(); // 생성자1 선언
       Rect(int iw, int ih); //생성자2 선언
       int width;
       int height;        
       ....

};
// 생성자 구현
Rect::Rect() { // 입력 인수 없는 생성자
   width = 0;
   height = 0;
}

Rect::Rect(int iw, int ih) { // 입력 인수가 두 개인 생성자
   width = iw;
   height = ih;
}


 

 생성자는 반환값이 없기 때문에 어떤 값도 return해서는 안되지만 중간에 실행을 멈추기 위해서 반환값이 없는 단순 return문은 사용할 수 있다. 만약 다음과 같이 생성자를 입력한다면 오류를 발생시킬 것이다.


Rect::Rect() {
   width = 0;
   height = 0;
   return 0; // 오류 발생

}


그리고 생성자는 여러 개를 중복하여 선언하고 구현할 수 있으나 각각의 입력 인수의 개수나 타입이 서로 달라서 구별되어야 한다. 즉, 이 경우 C++의 일반적인 함수 중복의 규칙에 따른다. 따라서 예를 들어 다음과 같이 여러 개의 생성자를 선언할 수 있다.


Rect();
Rect(int x);
Rect(double y);
Rect(int x, int y);


위에서 든 네 개의 생성자는 서로 입력 인수가 다르므로 다른 생성자이다. 단, 인스턴스 생성시에는 이 중 단 하나만 실행된다.


 생성자에게 입력 인자를 넘기려면 인스턴스 바로 뒤에 괄호로 묶어서 넘기면 된다.


Rect rect1; // 입력 인수가 없는 생성자 호출
Rect rect2(10,20); // 입력 인수가 두 개인 생성자 호출


이렇게 마치 함수를 호출하듯 객체명 뒤에 인자를 주면 입력 인자가 매치가 되는 생성자가 호출되게 된다. 즉, rect1이 생성될 때 Rect() 생성자가 호출되고 rect2가 생성될 경우에는 Rect(int iw, int ih) 생성자가 호출된다. 따라서 rect1의 내부 변수들은 모두 0으로 초기화 되어 있게 되고 rect2의 내부변수는 각각 10과 20으로 초기화가 되었다.


rect1.getArea(); // 0을 반환
rect2.getArea(); // 20을 반환


C++ 강좌 전체 목록 >>>


c{c++},n{c0019}


Posted by 살레시오
,

1.3 C++ 언어 소개    [DOC]    [SMTS]

 컴퓨터의 속도가 빨라짐에 따라 소프트웨어의 덩치도 커지게 되었고, C 언어로는 규모가 큰 프로그램을 개발할 때 프로그램의 코드를 관리하는데 어려움을 겪게 되었다. 이러한 점을 개선하기 위해서 C 언어와의 하위 호환성을 유지하면서 객체 지향 특성 (object oriented programming) 및 편의 기능들을 추가하여 1983년 즈음에 Bell 연구소의 Bjarne Stroustrup 이 C++ 언어를 개발하였다.


Bjarne Stroustrup, Creator and Developer of C++ programming language

[그림 1.3.1] C++ 언어를 개발한 Bjarne Stroustrup


C++에서는 C 언어의 struct 자료 구조를 확장한 class라는 새로운 자료 구조를 이용하여 객체 지향 프로그래밍 방법론을 구축하였으며 이는 다른 현대적인 프로그래밍 언어들에 지대한 기여를 하였다. 이것에 영향을 받아 1991년에는 Guido B.A.가 python의 초기 버전을 발표하였으며, 1995년도에는 C++의 영향을 받은 JAVA라는 언어가 Sum Microsystem 사의 James Gosling 에 의해서 만들어졌다. 또한 2000년에는 Microsoft 가 C++과 JAVA의 장점을 취한 C#이라는 언어를 만들어 ,NET framework의 핵심 언어가 되었다. 이외에도 Javascript, PHP 등 웹프로그래밍 언어들도 C/C++의 영향을 받아서 개발되어 널리 사용되고 있다. 파이썬과 자바 그리고 자바스크립트는 현대의 컴퓨팅환경에서 가장 널리 쓰이는 프로그래밍 언어들이다.


다른 언어들에 비해서 상대적으로 오래된 역사에도 불구하고 C++은 현재까지도 중요한 비중을 차지하고 있으며 속도나 성능이 매우 중요한 임베디드 시스템 개발이나 게임 프로그래밍에 많이 사용되고 있다.  또한 마이크로콘트롤러(microcontroller)나 DSP(digital signal processor)의 프로그래밍에서는 C/C++언어가 아직도 주력으로 사용되고 있으며 특히 아두이노(arduino)와 같은 인기있는 오픈 하드웨어 플랫폼도 C++언어를 사용한다.


 전술한 바와 같이 다른 주요한 언어들이 C/C++언어의 영향을 많이 받아 설계되었으므로 C/C++언어를 익히면 다른 언어로 건너갈 때 훨씬 용이하므로 전산 관련 학과에서 프로그래밍 입문 언어로 C/C++이 많이 사용된다.


Posted by 살레시오
,