[c++] 상속

* c++ 상속에는 3가지 상속이 있다.

 

1. private 상속

private란 자기 자신의 내부에서만 접근 할 수 접근지정자로 외부에서 접근 할 수가 없다. private로 자식에게 상속하면 어떤 접근지정자의 필드라도 자식에게 상속되는 순간 private로 넘어가게 된다. 거의 쓰지 않는 상속 방법이다.

 

2. protected 상속

protected란 자기 자신의 내부와 상속한 자식에게서만 접근 할 수 있다. protected 상속을 했을때, private로 상속을 넘기면 private로 상속 받고 protected와 public으로 상속을 넘기면 protected로 상속 받는다. has ~ a 관계로 상속된다.

 

3. public 상송

public이란 내부던 외부던 모두 접근이 가능한 공공 접근자다. public 으로 상속을 했을때, 어떤 접근 지정자로 넘기던 접근지정자 그대로 넘어간다. is ~ a 관계로 상속된다.

 

 

 

 

* public 으로 상속을 하는 코드를 작성해 보자. A 클래스를 B클래스에게 public 상속하고, B클래스를 C클래스에게 public 상속하라. main 에서 접근이 가능한건 직접 호출하고, 접근이 불가능한건 함수를 이용해서 호출하라.

 

 

 

#include <iostream>
#include <iomanip>
using namespace std;
 
 
class A {
    int a1 = 1;
protected:
    int b1 = 2;
public:
    int c1 = 3;
    void seta1(int a1) {this->a1 = a1;}
    int geta1() {return a1;}
    void setb1(int b1) {this->b1 = b1;}
    int getb1() {return b1;}
};
class B :public A {
 
    int a2 = 4;
protected:
    int b2 = 5;
public:
    int c2 = 6;
    void seta2(int a2) {this->a2 = a2;}
    int geta2() {return a2;}
    void setb2(int b2) {this->b2 = b2;}
    int getb2() {return b2;}
 
};
class C :public B {
 
 
    int a3 = 7;
protected:
    int b3 = 8;
public:
    int c3 = 9;
    void seta3(int a3) {this->a3 = a3;}
    int geta3() {return a3;}
    void setb3(int b3) {this->b3 = b3;}
    int getb3() {return b3;}
};
 
 
void main() {
    C cc;
    //직접 접근 가능한거 직접표현
    //접근 불가능 함수로 표현
 
    cout << cc.geta1() << endl;
    cout << cc.getb1() << endl;
    cout << cc.c1 << endl;
    cout << cc.geta2() << endl;
    cout << cc.getb2() << endl;
    cout << cc.c2 << endl;
    cout << cc.geta3() << endl;
    cout << cc.getb3() << endl;
    cout << cc.c3 << endl;
 
}

 

 

 

 

* protected 로 상속을 하는 코드를 작성해 보자. A 클래스를 B클래스에게 protected 상속하고, B클래스를 C클래스에게 protected 상속하라. main 에서 접근이 가능한건 직접 호출하고, 접근이 불가능한건 함수를 이용해서 호출하라.

 

 

#include <iostream>
#include <iomanip>
using namespace std;
 
 
class A {
    int a1=1;
protected:
    int b1=2;
public:
    int c1=3;
    void seta1(int a1) {this->a1 = a1;}
    int geta1() const{return a1;}
    void setb1(int b1) {this->b1 = b1;}
    int getb1() const{return b1;}
    void setc1(int c1) {this->c1 = c1;}
    int getc1() const{return c1;}
 
};
class B :protected A {
    A aa;
    int a2=4;
protected:
    int b2=5;
public:
    int c2=6;
 
    void seta2(int a2) {this->a2 = a2;}
    int geta2() const{return a2;}
    void setb2(int b2) {this->b2 = b2;}
    int getb2() const{return b2;}
    void setc2(int c2) {this->c2 = c2;}
    int getc2() const{return c2;}
 
};
class C :protected B{
    //오버라이드 쓸때는 부모와 자식이 똑같아야함
 
    int a3=7;
protected:
    int b3=8;
public:
    int c3=9;
 
    void seta1(int a1) { A::seta1(a1); }//A꺼에 a1을 불러줘
    int geta1() const{ return A::geta1(); }
    void setb1(int b1) { A::setb1(b1); }
    int getb1() const { return A::getb1(); }
    void setc1(int c1) { A::setc1(c1); }
    int getc1() const { return A::getc1(); }
 
    void seta2(int a2) { B::seta2(a2); }
    int geta2()const { return B::geta2();}
    void setb2(int b2) { B::setb2(b2); }
    int getb2() const{ return B::getb2();}
    void setc2(int c2) { B::setc2(c2); }
    int getc2() const{ return B::getc2();}
 
 
    void seta3(int a3) { this->a3 = a3; }
    int geta3() {return a3;}
    void setb3(int b3) {this->b3 = b3;}
    int getb3() {return b3;}
};
 
 
void main(){
    C cc;
    //직접 접근 가능한거 직접표현
    //접근 불가능한거 함수로 표현
 
    cout << cc.geta1() << endl;
    cout << cc.getb1() << endl;
    cout << cc.getc1() << endl;
    cout << cc.geta2() << endl;
    cout << cc.getb2() << endl;
    cout << cc.getc2() << endl;
    cout << cc.geta3() << endl;
    cout << cc.getb3() << endl;
    cout << cc.c3 << endl;
    
 
}