<< 프랜드(friend) 함수 >> 클래스의 멤버들은 억세스(ACCESS!) 권한 지정자에 의해서 비공개, 즉 pri vate 속성을 가진 것은 같은 클래스의 멤버함수로만 참조가 가능하고 외부 에서 접근이 불가능하다고 하였다. 그러나, 예외적으로 접근이 가능한 함수 가 있는데, 이것을 프랜드 함수라고 한다. (친구니까 사생활 침해가 가능?) friend함수를 사용하기 위해서는 어떤 클래스내에 프랜드 함수의 프로토타 입을 기술하여 준다. 형식) class ACCESS { : friend void func(); : } 프랜드 함수는 private나 public이나 어느 영역에 있어도 상관이 없다. (friend자체도 예약어이기 때문이다.) ex) #include class ACCESS { private: // 생략가능 int x,y; friend void sub(); // 프랜드 함수임을 선언 ACCESS(int a,int b) { x=a; y=b; } // 생성자 }; void sub() { int i,j; class ACCESS var(3,10); // 생성자 호출 - 멤버 초기화 i=var.x; // 마음껏 참조가능 j=var.y; // 역시 마음껏 참조가능 cout << i << j << endl; } void main(void) { sub(); } 프랜드함수가 클래스를 마음껏 참조가능하다고 해서 위의 (1)과 (2)를 i=x; j=y; 라고 하면 안된다. 이것이 멤버함수와 프랜드함수의 멤버사용에 대한 유일한 차이점이다. 멤버함수는 : '.'을 이용해 참조할 필요가 없다. (인수의 생략가능) 프랜드함수 : 한 객체를 클래스를 사용해서 선언한후 그 변수와 '.'을 이 용하여 참조해야만 한다. (위의 예에서는 var로 선언) 선조클래스(기저, 기반또는 상위 클래스)의 friend함수는 후손클래스(파생 또는 하위클래스)의 friend함수가 아니다. 즉, 선조의 친구는 선조에게만 적용, 역시 후손의 친구는 후손의 친구에게만 적용된다. (인간과 같다!) ( 선조와 후손은 클래스의 계승(또는 상속, 파생)에 나오는 내용이다.) << 클래스의 계승(inheritance) >> OOP(object-oriented programming)의 기본이념은 한번 작성한 코드를 별 수정없이 계속 재사용할 수 있게 하는 데 있다. 기존에 이미 작성해놓은 클 래스에 몇가지 기능을 추가하여 새로운 클래스를 확장할 수 있는 것이다. C++에서는 이러한 것을 계승(또는 파생, 상속)이라는 개념으로 지원한다. 기존에 존재하던 클래스에서 추가할 것은 추가하고 필요없는 것은 빼는 등 형태을 변경시켜서 형태를 바꾸어서 사용할 수 있는 것이다. 이 때에도 물 론 전에 존재하던 클래스는 지워지거나 특성을 잃지 않는다. (OOP이 아니면 불가능한 일...) << 선조클래스(Base class)와 후손클래스(Derived class) >> 계승에 의해서 새로운 클래스를 만들 때 원래있던 클래스를 선조(또는 기 반, 기저, 상위)클래스라고 하고, 새로 만들어지는 클래스를 후손(또는 파 생, 하위) 클래스라고 한다. 클래스의 계승에 관해서는 다음과 같은 특징들 이 있다. ① 계승된 클래스에서 또 계승시키는 것이 가능하며, 선조, 후손의 개념은 상대적이다. (인간세상에서 할아버지, 아버지, 아들관계와 같다!) ┌─────┐ │ class A │ 선조클래스 └──┬──┘ │ ┌──┴──┐ A의 후손클래스 │ class B │ B의 선조클래스 └──┬──┘ │ ┌──┴──┐ │ class C │ 후손클래스 └─────┘ ② 한 클래스에서 여러개의 클래스를 계승시킬 수 있다. (제한이 없다) ③ 여러 클래스에서 한 클래스로 계승시킬 수 있다. (다중상속) ex) 클래스 계승도 ┌─────┐ │ class A │ └──┬──┘ ┌────────┴────────┐ ┌──┴──┐ ┌──┴──┐ │ class B │ │ class C │ └──┬──┘ └──┬──┘ │ ┌──────┼──────┐ ┌──┴──┐ ┌──┴──┐┌──┴──┐┌──┴──┐ │ class D │ │ class F ││ class E ││ class H │ └──┬──┘ └──┬──┘└─────┘└──┬──┘ │ │ │ └─────┬────┘ │ ┌──┴──┐ ┌──┴──┐ │ class G │ │ class I │ └─────┘ └─────┘ (위의 것은 아주 단순한(?) 계승도이다. 윈도우용 OWL(object windows lib rary)같은 것은 전지 1장에 그려지는 것들도 수두룩하다고 한다. ) * 후손클래스 정의의 형식 ([]는 생략가능 - default: class에서는 private, struct에서는 public) class <클래스명> : [억세스 계승 지정자] <선조클래스명> {클래스내용}; 억세스 계승 지정자에는 public과 private가 오며, 후손의 속성을 결정한 다. (protected는 쓰지 못한다는 사실에 주의 - 멤버억세스 권한지정자와는 별개의 것이다.) * 억세스 계승 지정자에 따른 속성의 계승 1. public : 선조의 모든 멤버와 멤버 함수들을 선조 내에서 쓰고 있던 특 성들(억세스 권한들)을 변경없이 그대로 가지고 온다. 2. private : 선조의 모든 맴버와 맴버함수들을 private:로 바꾸어서 가지 고 온다. (과연 사용할 일이 있을려는지...) (private의 파워가 public보다 세다!!) ex) class ACCESS { // 선조클래스 int x,y; public: func() {... } }; class PRM: public ACCESS { char a,b; public: put() {... } }; 후손클래스가 발생하면, 선조의 내용이 후손에 그대로 복사된다고 생각하 면 된다. PRM 클래스의 경우를 예로 들면, 컴파일러에 의해 내용이 다음과 같이 바뀐다. 즉, class PRM { int x,y; char a,b; public: func() {... } put() {... } }; 위의 예에서는 계승속성이 public이므로 후손의 속성은 변하지 않았다. 만약에 private로 계승하면 class PRM: private ACCESS { char a,b; // 생략시에는 private속성임을 잊지 말자. func() {... }; put() {... }; }; 이렇게 되버린다. * 헷갈리는 것들을 대충 정리하면... 1. 후손이 가지고있는 맴버함수들을 선조 내에서 프랜드 함수로 선언을 한 다면, 후손의 멤버함수들은 선조의 내부를 쉽게 접근할수가 있다. 2. 선조에서 public 또는 protected 속성을 가진 것들은 당연히 후손에서 접근이 가능하다. (주의: proteced:로 선언된 멤버들은 후손 외부에서는 접근 불가능하다. publicd:으로 선언된 멤버들은 후손 외부에서도 접근 가능하다.) 3. frined함수는 계승받지 못한다는 사실을 잊지 말자. 4. 그리고 추가로... 선조 클래스의 객체는 후손의 객체를 포인트할 수가 있다. 후손 클래스의 객체는 선조의 객체를 포인트할 수가 없다. ex) class A { ... }; class B:public { ... }; A obj1; B obj2; A *ptr1; B *ptr2; ptr1 = &obj2; // 가능 ptr2 = &obj1; // 불가능 << 후손클래스에서 생성자의 호출 >> 컴파일러는 후손클래스의 생성자가 호출될 때 먼저 선조클래스의 생성자를 호출하고 난 후에 후손의 생성자를 호출한다. 후손이란 멤버들을 선조로부 터 상속받았기 때문에 후손의 생성자만으로는 자신의 데이터멤버들을 초기 화시킬 수 없는 것이다. 그래서 상속받은 데이터 멤버들은 선조의 생성자에게 초기화를 일임한다. (후손은 선조가 낳은 자식들이므로 부양할 의무가 있는 것이다!(??)) 후손의 생성자는 객체 생성시에 전달된 인수(arguement)들을 일단 받아두 었다가 선조에게 일부를 넘겨준다. 선조의 생성자는 넘겨받은 데이터로 자 기가 맡은 초기화를 수행하고 후손의 생성자는 남은 데이터로 초기화를 수 행한다. 형식> 클래스명::후손클래스의 생성자(인수들):선조클래스의 생성자(인수들) { .. 함수본체.. } ex) class ACCESS { // 선조클래스 int x; public: ACCESS(int i=0) { x=i; } // 디폴트 생성자 }; class PRM: public ACCESS { // 후손클래스 int y,z; public: | PRM(int l,int m,int n); // 초기화 생성자 선언 }; PRM::PRM(int l,int m,int n) { // 생성자 외부 정의 y=l; z=n; }; PRM의 생성자를 보면 뒷부분에 ACCESS(m) 이 붙어있다. 이와같이 파생클래 스의 생성함수를 정의할때는 기반클래스의 생성함수도 초기화를 해주어야 합니다. << C++에서 모듈별 컴파일 - 프로젝트 >> C++에서는 프로그램을 이루는 기본단위가 클래스이므로, (참고:C에서는 함 수) 클래스 하나에 대해서 헤더파일과 CPP파일을 만들어 두고 헤더파일에서 는 클래스 정의를 하고 CPP파일에서는 클래스의 멤버 함수를 정의한다. 이 러한 방법대로 작업하는 습관을 들이면 분석이 용이해지는 것은 물론이고 분석도 훨씬 쉬워진다. 가령, A클래스를 작성해놓고 각각 다른 2모듈인 A와 B에서 사용한다고 했 을 때, 다음과 같이 된다. ┌──────────┐ ┌─────────┐ │ main() │ │ moduleB의 함수 │ │ mouduleA의 함수 │←─┬──→│ │ │ │ │ │ │ └──────────┘ │ └─────────┘ moduleA.CPP │ moduleB.CPP │포함 ┌──────────┐ │ ┌─────────┐ │ │ │ │ │ │ 멤버함수 정의 │←─┴───┤ classA 정의 │ │ │ │ │ │ │ │ │ └──────────┘ └─────────┘ classA.CPP classA.h 헤더파일끼리 계승을 위해 복잡하게 서로 include를 하다보면 본의 아니게 클래스가 중복정의되는 수가 있는데, 그런 경우를 방지하기 위해서 조건부 컴파일 전처리기(preprocessor)를 사용한다. 일반적 형태는 다음과 같다. #ifndef _CLASSA #define _CLASSA class classA { : : } #endif 이렇게 조건부 컴파일 지시가 있으면 단 1번만의 정의가 이루어지므로 안 전하다. 중복시키지 않는다면 필요야 없겠지만 만약을 대비하기 위해서 이 러한 형태를 관례적으로 사용하는 것이 좋다. << 함수의 오버로딩(overloading)과 가상함수(virtual function) >> * 정적 바인딩(static binding) ① 파일시 호출될 함수의 결정 ② static 변수와 비슷~ ③ 가상함수가 아닌이상 항상 정적바인딩만 이루어진다. * 동적 바인딩(dynamic binding) ① 실행시 호출될 함수의 결정 ② auto 변수와 비슷~ ② 동적 바인딩을 위해서는 가상함수가 필요 이 부분은... 예제없이 설명하기란 지극히 어렵고, 또 C++에서 최고로 헷 갈리는 부분중의 하나인만큼 주의깊게 살펴보아야 한다! 다음의 예를 보자. Position, Point, Circle이라는 3개의 클래스로 구성되어 있다. 이 예제는 어떤 책에 있는 것을 개조(?)한 것이다. 무슨 내용인지 차근차근 잘 뜯어보 면 쉽게 알 수가 있다. #include #include #include #include #include enum Boolean {false,true}; class Position { protected: int px,py; public: Position(int x,int y) { // constructor px=x; py=y; } int Getpx() { return (px); } int Getpy() { return (py); } }; class Point:public Position { protected: int Color; Boolean Visible; public: Point(int x,int y,int c):Position(x, y) { // constructor of derived class Color=c; Visible=false; } int Getcolor() {returnColor;} Boolean Getvisible() {return Visible;} void Show() { Visible=true; putpixel(px,py,Color); } void Hide() { Visible=false; putpixel(px,py,getbkcolor()); } void Moveto(int nx, int ny); }; // ------------------------------------- void Point::Moveto(int nx,int ny) { Hide(); px = nx; py = ny; Show(); delay(100); } // ------------------------------------- class Circle:public Point { private: int Rad; public: Circle(int x,int y,int c,int r):Point(x, y, c) { Rad = r; } void Show() { Visible=true; setcolor(Color); circle(px,py,Rad); } void Hide() { Visible=false; setcolor(getbkcolor()); circle(px,py,Rad); } void Moveto(int nx, int ny); void Resize(int nr) { Hide(); Rad = nr; delay(50); Show(); } int GetRad() { return (Rad);} }; // ------------------------------------- void Circle::Moveto(int nx,int ny) { Hide(); px = nx; py = ny; Show(); delay(100); } // ------------------------------------- void main() { int gd=VGA, gm=VGAHI; initgraph(&gd,&gm,""); Circle WON(100,200,14,50); WON.Show(); for (int i=0;i<30;i++) WON.Moveto(WON.Getpx()+5,WON.Getpy()); for (int j=0;j<50;j++) WON.Resize(WON.GetRad()+3); getch(); closegraph(); } 다음은 위의 예제의 클래스 계승상황과 변수들의 상속관계를 표로 도시한 것이다. 굵은 선으로 둘러싸여진 부분을 주목해서 살펴보자. ┌─────────┬─────────┬─────────┐ │Position (계승->)│Point (계승->)│Circle │ ├─────────┴─────────┴─────────┤ │px; px; px; │ │py; py; py; │ ├─────────┬───────────────────┤ │ │Color; Color; │ │ │Visible; Visible; │ │ └─────────┬─────────┤ │ │Rad; │ ├───────────────────┴─────────┤ │Position(); Position(); Position(); │ │Getpx(); Getpx(); Getpx(); │ │Getpy(); Getpy(); Getpy(); │ ├─────────┬───────────────────┤ │ │Point(); Point(); │ │ │Getcolor(); Getcolor(); │ │ │Getvisible(); Getvisible(); │ │ └─────────┬─────────┤ │ │Circle(); │ │ ┏━━━━━━━━━━━━━━━━━━━┓ │ ┃Show(); Show(); ┃ │ ┃Hide(); Hide(); ┃ │ ┃Moveto(); Moveto(); ┃ │ ┗━━━━━━━━━━━━━━━━━━━┛ │ │Resize(); │ │ │GetRad(); │ └───────────────────┴─────────┘ Circle이라는 클래스는 Position과 Point 2개의 선조로부터 2차 계승을 받 은 클래스이며, 선조에 함수명, 인자형이 동일한 모양의 함수가 다시 정의 되어 있다. (굵은 선부분) 이런 경우에는 후손에서 새롭게 정의된 멤버함수가 쓰이게 되며, 이러한 것을 함수의 오버로딩(overloading)이라고 한다. 즉, Circle내에서 Show() 와 Hide()함수를 사용하게 되면, Circle::Show()와 Circle::Hide()가 호출 되어진다. (참고: C++에서는 상속을 많이하면 할 수록 발전된 클래스로 여긴다. (당연한 얘기인가?) 그만큼 많이 발전했다는 뜻!! 오버로딩또한 선조의 것을 무시하고 더욱 발전적인 후손의 것을 쓰겠다는 개념이라고 생각하면 쉽다. 완전히 하극상이네.. ) 그렇다면 Moveto()함수는 어찌 되는가? Moveto()함수는 Show()함수와 Hide()함수를 다시 호출하고 있는데, 위의 예제를 보면 알겠지만, Point()에서 정의된 Moveto()함수와 Circle()에서 정의된 Moveto()함수는 완전히 같다.. 함수명, 인자, 내용까지 완전히~ 같 다. 즉, 중복정의된 것이라고 볼 수가 있다. 그럼, Circle() 클래스 내의 Moveto()를 정의할 것 없이 Point()로부터 상 속받아 사용하면 될 듯도 싶다... (위의 예제에서 Circle.Moveto()부분을 없애버리면...) 그러나.. 상속받으면 전혀 엉뚱한 결과가 초래된다. Circle::Show(), Circ le::Hide()가 아닌 Point::Hide(), Point()::Show()함수만 항상 호출되어진 다. (∵ 정적바인딩에 의해서!) 똑같은 내용을 가진 함수이지만, 그 함수 내부에서 다시 호출되는 함수는 전혀 틀린 것이다. 이 문제를 해결하기 위해서는.. 위와 같이 오버로딩시키면 되지만, 간단히 해결해버리는 수가 있다. 일단, Circle 클래스 내의 Moveto()함수를 말소시 켜버린 후, Point내의 함수를 다음과 같이 가상함수로 정의하는 것이다. # 가상함수 정의시에는 예약어 virtual을 사용한다. ~~~~~~~ class Point { . : virtual void Show() { ... } virtual void Hide() { ... } : } 이렇게 해버리면 동적바인딩을 하게 되어, 실행시에 함수의 바인딩이 이루어 진다. 이렇게 되면 Moveto()함수를 호출한 객체가 어떤 클래스 소속인가에 따 라서 실행시에 호출되는 함수가 결정된다. 즉, Point형 객체가 Moveto()를 호 출하면 Point 클래스의 멤버함수들이 호출되고, Circle형 객체가 Moveto()를 호출하면 Circle 클래스의 멤버함수들이 호출된다. 그리고,선조에서 가상함수를 1번 선언해주면 후손에 있는 함수도 자동적으 그리고,선조에서 가상함수를 1번 선언해주면 후손에 있는 함수도 자동적으 로 virtual형이 되므로, 굳이 다시 선언해줄 필요는 없다. * 가상함수의 재정의 가상함수는 후손에서 선조와 다른 형태로 재정의 될 수 있다. 그 이후에 계승되는 후손이 있다면 재정의된 가상함수가 계승된다. 단, 반드시 선조의 가상함수와 함수의 형이 같아야한다. ① 후손에서 선조의 가상함수와 인자의 형이 틀리게 재정의한 경우 -> 오버로딩에 의해서 선조의 것이 무시되고 새로운 함수가 만들어진다. ② 리턴값이 틀린 경우 ->다형성에 어긋나므로 에러가 발생한다. . . PRESENTED by . * __ ____ ____. ____ ____* ____ the / |/ ___|/ ___|| ___|/ _*|/ __| registered / / | |___ |___ | _| \_*_ \\___ \ trademark of /_/|_|\____|\____||____*|____/|____/ MicroSoft Inc. -1995- . * * * 출력이 끝났습니다. [Enter]를 누르십시오.