[개탱][C++][상속][inheritance][수정필요]

상속 (inheritance)

 - 기존에 존재하는 클래스의 자원 (데이터 멤버, 멤버 함수)를 물려받아서 재사용하는 제도

 - 복사를 하지않고 그대로 사용이 가능

// Super Class // Parent(부모) Class  // Base Class

-> 상속을 시켜주는 Class 

// Sub Class  // Child(부모) Class    // Derived Class

-> 상속을 받는 Class

특성

부모 클래스에서 자식 클래스에 넘겨주는 Data Member에 대해서

 -> 삭제 X, 변경 X

 -> 추가 O

부모 클래스의 Data Member 와 자식 클래스의 Data Member 의 변수명이 같아도 이상없음!

 부모클래스에 int a; 를 선언해주고 자식 클래스에서 int a; 를 선언해준뒤

자식클래스에서 a를 가지고 사용을하면 자식클래스의 a를 사용하게 되는 것이며,  

부모클래스의 a를 사용을 하고싶으면 부모클래스::a 이런식으로 사용한다. [아래 코드 참고]

class X{
public:
    int a;
};
 
class Y :public X {
public:
    int a;
};
 
int main() {
    Y A;
    A.a; // -> 자식클래스의 a
    A.X::a; // -> 부모클래스의 a
}

하지만 이러한 방식의 코드는 나중에 다중으로 상속관계를 만들었을 때 햇갈릴 수도 있으니 조심하자!

[ 아무리 상속관계일지라도 부모 클래스의 private자원에 대해서는 접근 불가 ]

class X{
private:
    int a;
};
 
class Y :public X {
public:
    int a;
};
 
int main() {
    Y A;
    A.X::a; // -> 부모클래스의 a는 현재
    //private 상태이므로 Y클래스에서 접근이 불가능하다!
}
 

부모 클래스에서 자식 클래스에 넘겨주는 Member Function에 대해서

 -> 삭제 X

 -> 변경 O(물려받은 함수의 내용의 수정이 가능)

[ex) 아버지에게 술을 먹는다는 함수가 있을 때

그 함수내부에 아버지 클래스에서는 술을 먹은 후 노래를 부른다 라는 내용이 있을 때

자식 클래스에서는 그 내용을 수정하여 술을 먹은 후 잠을 잔다로 수정이 가능하다]

 -> 추가 O

#include <stdio.h>
 
class Point
{
private:
    int m_X;
    int m_Y;
 
public:
    Point();
    Point(int x, int y);
    void setX(int x);
    void setY(int y);
    int getX();
    int getY();
    void move(int x, int y);
    Point& getMidPoint(Point& p);
    void add(int n);
    void print();
};
 
Point::Point() {
    m_X = 0;
    m_Y = 0;
}
Point::Point(int x, int y) {
    m_X = x;
    m_Y = y;
}
void Point::setX(int x){
    m_X = x;
}
void Point::setY(int y){
    m_Y = y;
}
 
int Point::getX() {
    return m_X;
}
int Point::getY() {
    return m_Y;
}
void Point::move(int x, int y){
    m_X += x;
    m_Y += y;
}
Point& Point::getMidPoint(Point& p){
    return Point((m_X+p.m_X)/2, (m_Y+p.m_Y)/2);
}
void Point::add(int n){
    m_X += n;
    m_Y += n;
}
void Point::print() {
    printf("(%d, %d)\n",m_X, m_Y);
}
 
 
int main()
{
    Point x;
    Point y(10, 30);
    Point z;
 
    x.setX(100);
    x.setY(200);
 
    x.move(10,30);
    
    z = x.getMidPoint(y);
 
    z.add(10);
 
    x.print();
    y.print();
    z.print();
}
 

위와 같이 처음에 Point 라는 클래스를 만들어 주고 나서 사용 하던중에

현재로서는 X,Y 좌표만을 가지고 사용하는 class를 만들어주었는데 

이제는 X, Y, Z 좌표를 사용하는 3D형식의 class를 만들고 싶을 때, 우리에게는 2가지의 방법이 있다.

먼저, 복사 & 붙여넣기 후 수정

class Point3D
{
private:
    int m_X;
    int m_Y;
    int m_Z;
 
public:
    Point3D();
    Point3D(int x, int y, int z);
    void setX(int x);
    void setY(int y);
    void setZ(int z);
    int getX();
    int getY();
    int getZ();
    void move(int x, int y, int z);
    Point3D& getMidPoint(Point3D& p);
    void add(int n);
    void print();
};
 

위와 같은 방법으로 2D형식으로 만든 Point 클래스와 다른 별개의 Point3D라는 클래스를 만들어서 새롭게 만들어 

내용이 비슷하니 안의 내용을 복사하여 필요한 부분만 추가하는 방법.

class Point3D : public Point
{
    
};

​이러한 식으로 Point 라는 클래스를 부모클래스로 지정하고 상속을 받겠다 라는 뜻으로 사용이 된다.

아래의 protected 와 관련된건 나중에 다시 한번 적겠습니다.

설명은 주석으로 처리했으며 이해가 안되는 부분이 있다면

댓글로 달아주세요!

​

#include <stdio.h>
 
class Point
{
protected: // 상속관계의 자식 클래스에서 접근 가능하게끔 해줌
            // 상속관계가 아닌 별개의 다른곳에서는 접근 불가능
    int m_X;
    int m_Y;
 
public:
    Point();
    Point(int x, int y);
    void setX(int x);
    void setY(int y);
    int getX();
    int getY();
    void move(int x, int y);
    Point& getMidPoint(Point& p);
    void add(int n);
    void print();
};
Point::Point() {
    m_X = 0;
    m_Y = 0;
}
Point::Point(int x, int y) {
    m_X = x;
    m_Y = y;
}
void Point::setX(int x){
    m_X = x;
}
void Point::setY(int y){
    m_Y = y;
}
 
int Point::getX() {
    return m_X;
}
int Point::getY() {
    return m_Y;
}
void Point::move(int x, int y){
    m_X += x;
    m_Y += y;
}
Point& Point::getMidPoint(Point& p){
    return Point((m_X+p.m_X)/2, (m_Y+p.m_Y)/2);
}
void Point::add(int n){
    m_X += n;
    m_Y += n;
}
void Point::print() {
    printf("(%d, %d)\n",m_X, m_Y);
}
 
class Point3D : public Point
{
    int m_Z;
public:
    Point3D() : Point(){ // Point3D()가 호출이 되면 부모클래스의 Point() 생성자에 접근하여
                        // 처리후에 함수 내의 내용 처리
        m_Z = 0;
    }
 
    Point3D(int x, int y, int z) : Point(x, y){ 
        // Point3D(int x, int y, int z)가 호출이 되면 부모클래스의
        //Point(x, y) 생성자에 접근하여 처리후에 함수 내의 내용 처리
        m_Z = 0;
    }
    void setZ(int n) {
        m_Z = n;
    }
    int getZ() {
        return m_Z;
    }
    void move(int x, int y, int z) { //함수 이름은 같지만 파라메터가 다르다.
        Point::move(x, y); 
        // 상위클래스에 있는 동일함수 호출시에는 앞에 Point:: 식으로
        // 어느 클래스의 move 함수인지 알려주어야 한다.
        // scope resolution operator
        m_Z += z;
    }
 
    Point3D& getMidPoint(Point3D& p){
    return Point3D((m_X+p.m_X)/2, (m_Y+p.m_Y)/2, (m_Z+p.m_Z)/2);
    // 신택스가 완전히 다르기때문에 상속을 하지않고 새롭게 만들어준다.
    }
    void add(int n) {
        Point::add(n);
        // Point 클래스의 add함수를 불러와 처리
        m_Z += n;
    }
    void print() {
        printf("(%d, %d, %d)\n",m_X, m_Y, m_Z);
    }
};
 
 
int main()
{
    Point x;
    Point y(10, 30);
    Point z;
 
    Point3D a;
    Point3D b;
    Point3D c;
 
    a.setX(100);
    a.setY(200);
    a.setZ(300);
    a.move(10,20,30);
    c = a.getMidPoint(b);
    c.add(10);
    a.print();
    b.print();
    c.print();
 
    x.setX(100);
    x.setY(200);
 
    x.move(10,30);
    
    z = x.getMidPoint(y);
 
    z.add(10);
 
    x.print();
    y.print();
    z.print();
}