[c++_11-2. 상속(inheritance) ]

졔·2022년 8월 25일

C++_Study

목록 보기

20/25

11-6. private로 상속

// 실습2 
class A                        //기본 클래스
{
    int x;                     // 안적혀있다면 private 속성, 상속 안댐
    public: 
        void setX(int i){x=i;}
        void showX(){std::cout << x << std::endl;}
};
// A로부터 상속받은 B
class B:private A               //비공개적으로 상속 
{
    int y; 
    public: 
        void setY(int i){y=i;}
        void showY(){std::cout << y << std::endl;}
};
int main()
{
    A aa;
    B bb;
    aa.setX(1);
    aa.showX();
    // bb.set(1);      오류
    bb.setY(2);        //파생클래스의 멤버접근
    // bb.showX();     오류
    bb.showY();        //파생클래스의 멤버접근
    return 0;

}

11-7. In-class member initializer

굳이 쓰지 않는것을 추천...!

class A
{
    int x = 1;      // In-class member initializers 
public: 
    A():x(2){}      // A() { x =2; }
    void setX(int i) { x = i;}
    int getX() { return x; }
};
int main()
{
    A a1;       //디폴트 생성자 호출, 눈에 안보이는 A(){}, 디폴트 생성자는 사라짐
    std::cout << a1.getX() << std::endl;        //2로 출력됨
    return 0;    
}

11-8. private 상속의 용도

private로 상속받더라도 기본클래스의 public 멤버들은 파생 클래스의 멤버함수에 의해서는 접근 가능.
private 상속은 기본클래스의 public 멤버를 파생클래스에서만 접근 가능하게 만듬. 자식에게만 비밀스럽게 상속!

11-9. protected로 상속

잘 안씀!

11-10. 접근 속성 비교: protected vs private

클래스를 만들 때 클래스 외부에서는 접근하지 못하게 하고 자식클래스에서는 마음대로 접근할 수있게 하려면 멤버의 속성을 Protected로 사용!
상속은? public 으로!
멤버접근 제어속성
protected 접근제어 속성
- 완전히 자기만 가지고 놀려면 private, 자신과 자식까지 접근가능하게 하려면 protected!
  외부에서는 둘 다 접근 안됨 X !

class A
{
protected: 
    int a,b;
public:
    void setAB(int i, int j){a=i;b=j;}
};

class B:public A
{
    int c;              //private
//protected가 아닌 private이면 접근 속성이 없음! 
protected:
    int a,b;            //다 물려줄게! 
public:
    void setAB(int i, int j){a=i;b=j;}
    void setC(int n){c=n;}
    void showABC(){std::cout << a << " "<< b << " " << c << "" << std::endl;}
    //기본 클래스의 protected 멤버들은 파생클래스에 의해 접근 가능
};

int main()
{
    A aa;
    B bb;
    // aa.a;       //외부에서 접근 불가
    // bb.b        //외부에서 접근 불가
    bb.setAB(1,2);
    bb.setC(3);
    bb.showABC();
    return 0;
}
결과: 1,2,3 출력됩니다.

11-11. 상속에서 생성자와 소멸자 실행 순서

파생클래스생성자(매개변수리스트): 기본클래스생성자(매개변수리스트){}
- public:
  B(int i, int j):A(i){ //i는 기본클래스 생성자의 매개변수로 전달}

// 파생클래스 생성자에서 기본 클래스 생성자에 매개변수 전달
class A{
    int a;                          //private
public:
    A(int i){
        std::cout << "A의 생성자\n";
        a=i;
    }
    ~A(){std::cout<<"A의 소멸자\n";}
    void showA(){std::cout<<a<<'\n';}
};
class B:public A{
    int b;
public:
    B(int i, int j):A(i){           //i는 기본클래스 생성자의 매개변수로 전달
        std::cout << "B의 생성자\n";
        b=j;
    }
    ~B(){std::cout<<"B의 소멸자\n";}
    void showB(){std::cout<<b<<'\n';}
};

int main()
{
    B bb(10,20);            // 10이 i로, 20이 j로 넘어간다
    bb.showA();
    bb.showB();
    return 0;
}

11-12. 계층적 다중 상속

계층적 다중상속에서 계층적 매개변수 전달

class B{                                //할아버지
    double d;
public:
    B(double dd){d=dd;}
    double getD() {return d;}
};

class D1:public B{                      //아버지
    int i;
public:
    D1(double dd, int ii) :B(dd) {i=ii;}                        //:B(double dd)가 들어옴
    int getI() {return i;}
};

class D2:public D1 {                    //자식
    char c;
public:
    D2(double dd, int ii, char cc) :D1(dd,ii) {c=cc;}           //:D1(double dd, int ii)가 들어옴
    void print(){std::cout << "Double: " << getD() << std::endl;
                            //B 멤버 호출 
                std::cout << "Int: " << getI() << std::endl;
                            // D1 멤버 호출 
                std::cout << "Char: " << c << std::endl;
                    }
};

int main()
{
    D2 d2(10.5,10,'H');
    std::cout << d2.getD() << "," << d2.getI() << std::endl; 
            //B,D1 멤버호출
    d2.print();
    return 0;
}

// 10.5,10
// Double: 10.5
// Int: 10
// Char: H