클래스의 메서드는 일반 함수를 정의하는 것과 동일한데 한 가지 첫 번째 인자는 반드시 self가 되어야 한다는 점이 다르다.  관례적으로 메서드 정의들 사이에는  한 줄 공백을 준다.


class Robot:

   def __init__(self, name='dummy'):
       self.name = name

   def talk(self):
       print('Hi. I am %s.'% self.name)


self라는 변수를 클래스 함수의 첫번째 인자로 받아야 하는 것은 파이썬만의 (불필요해 보이는) 특징이다. 문법이 이렇게 규정되어 있으니 사용자는 거기에 맞추어 작성해 주어야만 한다. 메서드 내에서는 이 self 변수를 통해서 기정의된 필드를 접근할 수 있으며 또 한 새로운 필드를 생성하는 것도 가능하다. talk() 메서드 내부에서 name 이라는 필드를 self를 통해서 (즉, slef.name 와 같이) 사용했음을 알 수 있다. 객체의 필드는 이와 같이 메서드 내에서 반드시 self 변수를 통해서만 접근할 수 있다.


 객체의 필드와 메서드 목록을 확인하고 싶으면 내장함수 dir()를 이용하면 된다.


>>> asimo=Robot(‘asimo’)
>>> dir(asimo)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'talk']


위에서 보면 매직 메서드들 다음에 name, talk 등 필드와 메서드의 이름을 모두 확인할 수 있다.


   이제 asimo라는 Robot 클래스 객체를 통해서 메서드를 호출할 수 있다. 객체명 뒤에 점(.)을 찍고 함수명을 명시하면 된다.


>>> asimo.talk()
Hi. I am asimo.


메서드를 호출하는 쪽에서는 정의부의 self인자는 무시하고 (없는 것으로 간주하고) 인자를 주면 된다. 따라서 asimo.talk() 메서드는 아무런 인자를 주면 안된다. __init__() 메서드와 마찬가지로 self 인자 뒤에 일반인자를 줄 수 도 있다.


class Robot:

   def __init__(self, name = 'dummy'):
       self.name = name

   def talk(self):
       print('Hi. I am %s.'% self.name)

   def walk(self, step):
       print('Sorry. No legs.')

   def run(self, dist, speed = 10):
       print('Must go %dm at %dm/s speed.'%(dist, speed))
       print('Sorry. No legs.')


이렇게 정의하면 walk()함수는 하나의 일반 인자를 주고 호출해야 하며 run()은 하나 혹은 두 개의 일반 인자를 주어야 한다.


>>> asimo.walk(5)
Sorry. No legs.
>>> asimo.run(100, 50)
Must go 100m at 50m/s speed.
Sorry. No legs.
>>> asimo.run(100)
Must go 100m at 10m/s speed.
Sorry. No legs.


이와 같이 메서도는 첫 번째 인자가 self 라는 점만 제외하면 일반 함수와 정의와 호출하는 방법이 동일하다.



Posted by 살레시오

댓글을 달아 주세요

  1. JJ 2016.07.04 15:20  댓글주소  수정/삭제  댓글쓰기

    강좌 잘 봤습니다! 다음 글도 기다리겠습니다~

 클래스의 모든 멤버 변수와 멤버 함수는 정적(static) 멤버로 지정될 수 있다. 정적 멤버 변수는 인스턴스가 생성될 때마다 독립적으로 생기는 멤버 변수와 달리 해당 클래스에 하나만 생성되고 모든 인스턴스에서 공동으로 접근할 수 있는 변수이다. 마찬가지로 정적 멤버 함수도 클래스당 하나만 생기며 모든 인스턴스에서 공동으로 호출할 수 있다.


 멤버를 정적 멤버로 선언하려면 선언문 앞에 static 이라는 지정자를 붙이면 된다. 모든 멤버들이 static으로 선언될 수 있으며 정적 멤버들도 접근 지정자 (public, protected, private)을 붙일 수 있다.

1 정적 멤버 변수

 이전 포스트의 LED 클래스의 예를 가지고 정적 멤버 변수를 추가시켜 보면 다음과 같다.

class Led {
   public:
       Led();
       void turnOn();
       void turnOff();
       static int iCount; // 정적 멤버 변수
   private:
       byte _pin;
};

이 예제에서 iCount는 정적 멤버 변수로 선언되었다. 정적 멤버 변수를 초기화하기 위해서는 클래스 내부에서는 불가능하다. 다음과 같이 초기화 하려고 하면 에러를 발생한다.


class Led {
   public:
       Led();
       void turnOn();
       void turnOff();
       static int iCount = 0; // 오류 발생
   private:
       byte _pin;
};

 

따라서 클래스 외부에서 전역 변수처럼 초기화시켜야 한다.

int Led::iCount = 0;

정적 변수를 접근하는 방법은 두 가지가 있는데 먼저 클래스 이름으로 접근하는 것이다. 이때 범위 지정 연산자인 ::을 이용한다.


Led::iCount ++; // iCount값을 하나 증가시킨다.

 

또는 인스턴스를 이용해서도 접근할 수 있다.

Led led1(12), led2(11);
led1.iCount = 10;
led2.iCount = 30;

비록 인스턴스 멤버 변수를 접근하는 문법과 똑같지만 서로 다른 인스턴스를 통해서 정적 변수를 참조했다고 할지라도 결국 같은 하나의 정적 변수 iCount를 접근하는 것이다.

 정적 변수의 첫 번째 활용 목적은 인스턴스들 사이에서 공유할 변수를 만들고자 하는 것이다. 예를 들어서 인스턴스가 몇 개나 생성되었는지를 기록하고자 할 때 앞의 예에서 iCount를 사용하면 될 것이다. 이 경우 생성자 내에서 iCount 값을 증가시키면 새로운 인스턴스가 생성될 때마다 이 변수값이 증가되므로 이것으로 개수를 알 수 있다.

int Led::iCount = 0; // 전역에서 정적 멤버 변수 초기화
Led::Led(int pin) { //생성자
   _pin = pin;
   pinMode(_pin, OUTPUT);
   iCount++; // 인스턴스 생성 시 하나 증가
}
Led::~Led(int pin) { //소멸자
   iCount--; // 인스턴스 소멸 시 하나 감소
}

또한 전역 변수를 쓰는 대신 관련된 클래스 내부에 정적 멤버 변수를 집어넣어서 C언어의 전역 변수처럼 사용할 수도 있다.

2 정적 멤버 함수

 멤버 함수 앞에 static 이라는 키워드를 붙이면 정적 멤버 함수가 된다. 정적 변수와 마찬가지로 정적 멤버 함수는 인스턴스에 속하는 멤버 함수가 아니라 클래스에 속하는 하나의 함수이다. 정적 함수 내부에서는 오직 정적 변수만을 사용할 수 있으며 함수도 정적 함수만을 호출할 수 있다. 반대로 일반 멤버 함수에서는 정적 멤버를 접근하는데 전혀 제약이 없다. 다음 예를 보자.

class Util {
   public:
       int iA;
       static double dA;

       void getA() {
           iA += (int)dA; // 정적과 비정적 변수를 모두 사용가능
           return iA;
       }

       static void getB() { // 정적 함수
           return dA; //정적 변수만 사용 가능
       }
};


비정적 함수 getA() 내부에서는 변수 iA와 정적 변수 dA를 사용하는데 아무런 제약이 없으나 정적함수 getB() 에서는 정적 변수 dA만 사용할 수 있다. 마찬가지로 정적 함수 내에서는 정적인 함수만 호출할 수 있으며 일반적인 멤버 함수는 호출할 수 없다.



Posted by 살레시오

댓글을 달아 주세요

 C++ 에서 함수를 호출하는데 있어서는 어느 정도 댓가가 따른다. 함수를 호출하기 직전에 기존 정보를 저장하고 인자를 넘겨주고 실행 순서를 바꾼 후 함수의 수행이 끝나면 사용한 메모리를 정리하고 반환값을 받는다. 즉 함수 호출 전후에 필수적으로 수행해야하고 메모리와 시간을 요하는 작업들이 있는 것이다. PC에서 수행되는 프로그램을 작성할 때에는 이러한 오버헤드는 무시할 수 있을 것이다. 하지만 아두이노와 같은 메모리나 성능이 매우 제약된 프로세서를 프로그래밍할 경우에는 무시 못할 성능 저하 요인이 될 수도 있다.


 C++의 인라인(inline)함수는 함수의 길이가 매우 짧을 경우에 효율을 높이기 위해서 도입된 방법으로서 함수의 선언부 앞에 inline 이라는 키워드로 구현된다. 이전의  코드로 예를 들면 다음과 같다.

inline boolean Button::isPushed() {
   return (digitalRead(_pin) == LOW)? true:false;
}


컴파일러는 인라인 함수를 호출하는 곳에 인라인 함수의 코드를 그대로 삽입하여 함수의 호출이 일어나지 않도록 한다. 이렇게 되면 함수를 호출할 때 드는 비용이 없어지기 때문에 속도가 더 올라간다. 반대 급부로 프로그램의 길이는 더 길어지게 된다.

 다른 객체지향 언어(JAVA, C# 등등)도 마찬가지지만 C++도 비교적 작은 크기의 함수를 많이 사용한다. 대표적인 것이 멤버 변수를 접근하는 getter/setter 함수인데 이러한 사용 빈도가 높고 크기가 작은 함수들을 inline으로 정의해 놓으면 더 높은 실행 효율을 얻을 수 있다.


 함수를 inline으로 설정했다고 모두 코드를 치환하는 것은 아니고 컴파일러에 따라서 동작 방식이 다르다. 자기 자신을 호출하는 재귀함수나 반복문, switch문 등이 포함된 함수는 inline으로 지정했다고 하더라도 컴파일러에 의해서 인라인 선언이 무시될 수도 있다. 또한 생성자를 포함하여 모든 멤버 함수가 인라인으로 선언될 수 있다. 이전 포스트의 Button클래스의 멤버 함수를 인라인 함수로 지정하면 다음과 같다.

class Button {
   public:
     Button(byte, boolean); // 생성자
     boolean isPushed(); // 버튼이 눌렸다면 true를 반환하는 멤버 함수
   private:
     byte _pin; // 연결된 핀
     boolean _internalPullup; //내부에 풀업이 되었는가
};
// 생성자의 구현
inline Button::Button(byte pin, boolean internalPullUp = true) {
   _pin = pin;
   _internalPullup = internalPullUp;
   if (_internalPullup)
       pinMode(_pin, INPUT_PULLUP);
   else
   pinMode(_pin, INPUT);
}
// 멤버 함수의 구현
inline boolean Button::isPushed() {
   return (digitalRead(_pin) == LOW)? true:false;
}

 멤버 함수의 크기가 작을 경우 클래스의 선언부에 바로 함수를 구현해도 무방하다. 즉, 위 예의 isPushed() 함수를 다음과 같이 클래스의 선언부에 바로 구현해도 된다.

class Button {
   public:
     Button(byte, boolean); // 생성자
     boolean isPushed();{
       return (digitalRead(_pin) == LOW)? true:false;
     }
     boolean isPushed(); // 버튼이 눌렸다면 true를 반환하는 멤버 함수
   private:
     byte _pin; // 연결된 핀
     boolean _internalPullup; //내부에 풀업이 되었는가
};
// 생성자의 구현
inline Button::Button(byte pin, boolean internalPullUp = true) {
   _pin = pin;
   _internalPullup = internalPullUp;
   if (_internalPullup)
       pinMode(_pin, INPUT_PULLUP);
   else
       pinMode(_pin, INPUT);
}

 단 한 가지 주의할 점은 컴파일러는 클래스 선언부에 바로 구현된 멤버 함수들에 대해서는 inline선언이 없어도 인라인 함수로 자동으로 처리한다. 따라서 이 예에서 isPushed()함수는 인라인 함수로 자동으로 간주된다.



Posted by 살레시오

댓글을 달아 주세요

 여기에서는 입력 장치로 많이 사용되는 푸시 버튼을 객체화 시키는 예제를 작성해 보도록 하겠다. 푸시버튼도 디지털 핀에 연결할 수 있으며 외부에서 풀업(pull-up)을 시켜주느냐 아니면 내부 풀업을 연결하느냐를 지정할 수 있도록 하겠다. Led 클래스와 마찬가지로 연결된 핀 번호는 private 변수에 저장한다. 그리고 내부에 풀업이 되었는지의 여부를 저장하는 변수도 private변수에 저장한다.


 클래스의 선언을 다음과 같다.

class Button {
public:
   Button(byte, boolean); // 생성자
   boolean isPushed(); // 버튼이 눌렸다면 true를 반환하는 멤버 함수
private:
   byte _pin; // 연결된 핀
   boolean _internalPullup; //내부에 풀업이 되었는가
};

생성자를 보면 입력 인수의 타입만 지정해 주었음을 알 수 있다. 생성자와 멤버 함수의 구현부는 다음과 같다.

// 생성자의 구현
Button::Button(byte pin, boolean internalPullUp = true) {
   _pin = pin;
   _internalPullup = internalPullUp;
   if (_internalPullup)
       pinMode(_pin, INPUT_PULLUP);
   else
       pinMode(_pin, INPUT);
}
// 멤버 함수의 구현
boolean Button::isPushed() {
   return (digitalRead(_pin) == LOW)? true:false;
}

생성자의 구현을 보면 다음과 같이 기본값 인자가 사용되었다.


Button::Button(byte pin, boolean internalPullUp = true) {...}

이렇게 구현해 놓으면 생성자는 인자를 하나를 받을 수도 있고 두 개를 받을 수도 있는데 하나만 있다면 두 번째는 자동으로 true로 지정된다. 즉, 다음과 같이 두 가지로 생성하는 것이 가능하다.

Button btn1(12); // 내부 풀업 저항을 연결하는 경우
Button btn2(11, false); // 외부에서 풀업 된 경우

두 번째 인자의 값에 따라서 pinMode()함수를 적절하게 호출하였음을 알 수 있다.


 풀업 저항이 연결되었을 경우 푸시버튼을 누른 상태에서 digitalRead()함수의 반환값은 LOW가 된다. 따라서 이에 맞게 멤버 함수 isPushed() 가 작성되었음을 알 수 있다.

 만약 클래스 선언이 Button.h에, 구현부가 Button.cpp 에 저장되어 라이브러리를 구성했다면, 이것을 이용하여 버튼이 눌리면 내장 LED가 켜지고 그렇지 않으면 꺼지는 프로그램을 다음과 같이 작성할 수 있다.

#include <Button.h> // 라이브러리 인클루드
Button btn1(12); //12번 핀에 내부 풀업 연결
void setup() {
   pinMode(13, OUTPUT);
}
void loop() {
   if (btn1.isPushed()) // 만약 버튼이 눌렸다면
       digitalWrite(13, HIGH);
   else // 그렇지 않다면 (눌리지 않았다면)
       digitalWrite(13, LOW);
}

 

이와 같이 class를 이용하여 객체화를 시도하면 프로그램을 좀 더 직관적으로 작성할 수 있다.




Posted by 살레시오

댓글을 달아 주세요

  이전 포스트에서 객체를 생성하는 것이 외형상으로 함수를 호출하는 것과 유사하다고 했는데, 사실 객체를 생성할 때 클래스의 __init__() 메소드를 호출하게 된다. 이 메쏘드는 다음과 같이 사용자가 정의할 수 있다.


class 클래스명:
def __init__(self):
메소드 본체


이 예에서 __init__(self) 메쏘드는 객체를 생성할 때 자동으로 호출되는 특수한 메소드이고 반드시 첫 번째 인자는 self 이어야 한다. 이 메쏘드 내부에 클래스 변수를 생성할 수 있다.


class Robot:
   def __init__(self):
       self.nLegs = 2
       self.nArms = 2


이제


>>> asimo = Robot()


이라고 Robot객체를 생성하면 nLegs 와 nArms 필드가 생성되고 초기화 되었음을 알 수 있다.


>>> asimo.nLegs
2
>>> asimo.nArms
2


객체의 필드를 확인하고 싶다면 내장 함수 vars()를 이용하면 된다.


>>> vars(asimo)
{'nLegs': 2, 'nArms': 2}


이 내장 함수는 사실 객체의 __dict__ 내부 필드를 반환한다. 이 내부 필드에 객체의 필드들이 딕셔너리의 요소로 저장되어 있다.


객체를 생성할 때 이름을 사용자가 입력하도록 하려면 다음과 같이 __init__() 메소드에 일반 인자를 self 뒤에 주면 된다.


class Robot:
   def __init__(self, name):
       self.nLegs = 2
       self.nArms = 2
       self.name = name


이제 객체를 생성할 때 이름을 반드시 입력해야 한다.


>>> asimo=Robot('asimo')
>>> asimo.name
'asimo'


만약 이름이 주어지지 않았을 때 ‘dummy’ 라는 이름을 주고 싶다면 다음과 같이 기본값 인자를 사용하면 된다.


class Robot:
   def __init__(self, name=’dummy’):
       self.nLegs = 2
       self.nArms = 2
       self.name = name

    

이제 객체를 생성할 때 이름을 입력하지 않아도 된다.


>>> asimo=Robot()

>>> asimo.name

'dummy'


이와 같이 __init__() 생성자 함수도 파이썬의 일반 함수처럼 가변 개수 인자, 기본값 인자, 키워드 인자 등을 적용할 수 있다.



Posted by 살레시오

댓글을 달아 주세요

  1. 파이언 2017.07.20 11:23  댓글주소  수정/삭제  댓글쓰기

    이렇게 댓글을 달아도 모르겠는데...
    책으로 보면서 이게 잘 이해가 안갔었는데 설명해 주신 것 보고는 정말 쉽게 이해하고 갑니다~!!

 파이썬은 클래스를 지원하므로 객체 지향적인 프로그래밍을 할 수 있다. 사실 지금까지 다뤄온 기본 자료형도 다 클래스이다. 클래스는 새로운 자료형을 정의하는 것이고 객체(object)는 클래스의 인스턴스(instance, 클래스가 구체화된 것)를 의미한다.


클래스는 다음과 같이 정의한다.


class 식별자:
클래스 본체


보통 클래스의 식별자는 대문자로 시작한다. 예를 들어 Person, Robot, Car, Point 등이다. 클래스 본체는 이 클래스에 속하는 변수와 함수를 정의하게 된다. 특별히 클래스에 속한 변수들을 필드(field), 클래스에 속한 함수들을 일반 함수들과 구분하기 위해서 메소드(method)라고 부르며 이 둘을 통칭하여 속성(attribute)라고 한다.


이 용어들에 대해서는 숙지해 두는 것이 좋다.


  • 필드 (field) : 클래스에 내장된 변수

  • 메쏘드 (method) : 클래스에 속하는 함수

  • 속성 (attribute) : 필드와 메쏘드를 통칭하여 속성이라 한다.


가장 간단한 형태의 클래스를 다음과 같이 정의해 보자.


class Robot:
pass


이 클래스는 보면 알겠지만 본체가 없다. 이 클래스의 인스턴스를 생성하려면 다음과 같이 하면 된다.


>>> asimo = Robot()


이제 asimo 는 Robot 클래스의 객체가 되었다. 이와 같이 어떤 클래스의 객체(인스턴스)를 생성하려면 다음과 같이 한다.


변수명 = 클래스명()


마치 함수를 호출하는 것과 유사하다.



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 살레시오

댓글을 달아 주세요

 생성자(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 살레시오

댓글을 달아 주세요

  잘 알려져 있다시피 클래스(class)는 객체지향 프로그램에서 핵심적인 역할을 하고 있고 루아에서는 이 기능을 베이스 수준에서 지원하지는 않지만 어느 정도 흉내는 낼 수 있다. 사실 객체지향에서 중요한 특성으로 캡슐화, 상속, 다형성 세 가지 정도가 언급이 되지만 소규모 프로젝트에서는 캡슐화 정도만 어느 정도 구현되어도 코딩과 수정 그리고 디버깅이 상당히 용이해진다고 개인적으로 생각한다. 글을 쓰고 있는 본인도 깊이 있는 지식은 없으므로 여기에서는 초보자들이 간단하게 쓸 수 있는 정도로만 설명하고자 한다.


  

  객체지향이나 클래스의 개념이 생소하다면 일단은 ‘특정한 임무에 관련된 변수들과 그 변수들을 핸들링하는 관련 함수의 집합’ 정도로 이해해도 될 것 같다. 예를 들어서 ‘좌표점과 그것에 관련된 계산’이라는 임무에 대해서


   (1) x좌표

   (2) y좌표

   (3) 한 좌표의 원점으로부터의 거리를 구하는 함수

   (4) 두 점의 거리를 구하는 함수


정도를 구현한다고 하자. 보통 (1),(2)번을 멤버변수라고 하고 (3)(4)번은 멤버함수라고 한다. 이것들을 전체를 하나의 이름으로 묶은 것을 클래스라고 한다.


코로나에서 이것을 외부 모듈로 구현한다면 먼저 다음과 같은 형태를 생각해 볼 수 있다. (외부모듈에 대한 기본적인 것은 이전 포스트를 참조)


┌─────────────────────────────


     local Sqrt = math.sqrt

     local M={}

     

     function M.New(x,y)

          local pt = {x=x or 0, y = y or 0} -- 먼저 멤버변수를 테이블로 새로 생성


          function pt:GetLength() -- 첫 번째 멤버함수를 pt안에서 생성

               return Sqrt(self.x*self.x + self.y*self.y)

          end


          function pt:DistTo(pt2) -- 두 번째 멤버함수를 pt 안에서 생성

               local dx = self.x - pt2.x

               local dy = self.y - pt2.y

               return Sqrt(dx*dx + dy*dy)

          end


          return pt -- 생성된 테이블(인스턴스)를 반환한다.


     end


     return M


└─────────────────────────────


  이 예제에서는 M.New() 함수 안에서 새로운 테이블을 생성한 후 이 안에서 변수와 함수를 다 정의하여 반환하는 식으로 처리했다. 이것을 예를 들어서 ‘point.lua’라고 저장했다면 다른 파일(예를 들어서 main.lua)에서 다음과 같이 불러서 쓸 수 있다.


┌── "main.lua" ───────────────────────────


     local CPoint = require "point" -- 외부모듈을 읽어들인다.


     local pt1 = CPoint.New(10,20) -- 첫 번째 인스턴스 생성

     local pt2 = CPoint.New(30,40) -- 두 번째 인스턴스 생성


     print("length of pt1:".. pt1:GetLength() ) -- 길이 22.36이 찍힘

     print("length of pt2:".. pt2:GetLength() ) -- 길이 50이 찍힘


     print("distance:".. pt1:DistTo(pt2) ) -- 두 점의 거리 28.28이 찍힌다


└─────────────────────────────


이제 CPoint.New()함수를 호출해서 새로운 점좌표를 얼마든지 생성할 수 있으며 보통 이렇게 생성되는 객체를 인스턴스(instance)라고 부른다. 그리고 이렇게 생성된 인스턴스를 통해서 관련 함수를 호출할 수 있다. (print 함수 안의 명령들)


  그런데 이 point1.lua 의 단점은 인스턴스를 생성할 때 마다 그 인스턴스 안에 함수의 본체도 같이 구현된다는 것이다. 예를 들어 100개를 생성하면 함수 본체도 각각 100개가 존재한다. 멤버함수의 개수나 덩치가 커진다면 이것은 실행이나 메모리 관점에서 굉장히 비효율적이다. 그래서 다음과 같이 멤버함수는 외부로 빼는 방식을 생각해 볼 수 있다.


┌─────────────────────────────

          local Sqrt = math.sqrt

          

          local function GetLength(tbl) -- 함수 본체를 외부에 정의

                    return Sqrt(tbl.x*tbl.x + tbl.y*tbl.y)

          end


          local function DistTo(pt1, pt2) -- 함수 본체를 외부에 정의

                    local dx = pt1.x - pt2.x

                    local dy = pt1.y - pt2.y

                    return Sqrt(dx*dx + dy*dy)

          end


          local M={}


          function M.New(x,y)

                    local pt = {x=x or 0, y = y or 0}


                    function pt:GetLength() -- 본체로 리다이렉션시킨다

                              return GetLength(self)

                    end


                    function pt:DistTo(pt2) -- 본체로 리다이렉션시킨다

                              return DistTo(self, pt2)

                    end

                    

                    return pt

          end

          return M

└─────────────────────────────


이제 함수 본체는 (인스턴스 개수와 상관없이) 외부에 하나만 존재하며 인스턴스 안에는 단지 본체로 리다이렉션 시켜주는 조그만 함수가 있을 뿐이다. 앞의 경우보다는 훨씬 효율적이지만 여전히 (작은 크기지만) 함수가 인스턴스 내부에 존재하고 본체로 재호출한다는 점에서 비효율적이다.


  좀 더 루아스럽고 우아하게(...) 개선하려면 이전 포스트에서 설명한 메타테이블의 __index 를 사용하면 된다.


┌─────────────────────────────

          local Sqrt = math.sqrt

          

          local mtIndex = {}


          function mtIndex:GetLength()

                    return Sqrt(self.x*self.x + self.y*self.y)

          end


          function mtIndex:DistTo(pt2)

                    local dx = self.x - pt2.x

                    local dy = self.y - pt2.y

                    return Sqrt(dx*dx + dy*dy)

          end


          local M={}


          function M.New(x,y)

                    local pt = {x=x or 0, y=y or 0} -- 멤버변수를 생성

                   return setmetatable(pt, {__index = mtIndex}) -- 멤버 함수를 메타테이블로 첨부한 후 반환

          end

          

          return M

└─────────────────────────────


이 방법이 코딩의 간결성이나 실행의 효율성에서 앞에서 소개한 방법들 보다 좀 더 앞선다고 할 수 있다.


Posted by 살레시오

댓글을 달아 주세요