C++상속 안내

11015 단어 C++계승
그 다음 에 각 구성원 함수 옵션 은 virtual 또는 non-virtual 또는 Pure virtual 일 수 있 습 니 다.본 고 는 단지 몇 가지 관건 적 인 검증 을 할 뿐이다.
Public 계승,예 를 들 어 다음:

 class base
 ｛...｝
 class derived:public base
 ｛...｝　　
이렇게 쓰 면 컴 파일 러 는 derived 의 대상 이자 base 의 대상 으로 이해 되 지만,base 의 대상 은 derived 의 대상 이 아 닙 니 다.그게 중요 해.그러면 함수 형 삼 은 base 유형 으로 derived 에 적용 되 고 형 삼 은 derived 로 base 에 적용 되 지 않 습 니 다.다음은 인증 코드 입 니 다.하나의 매개 변 수 는 base 의 함수 입 니 다.derived 에 들 어가 면 성공 적 으로 실행 되 어야 합 니 다.반면 하나의 매개 변 수 는 derived 함수

 #include <iostream>
  #include <stdio.h>

  class base
  {
      public:
      base()
      :baseName(""),baseData(0)
      {}

     base(std::string bn,int bd)
     :baseName(bn),baseData(bd)
     {}

     std::string getBaseName() const
     {
         return baseName;
     }

     int getBaseData()const
     {
         return baseData;
     }

     private:
         std::string baseName;
         int baseData;
 };

 class derived:public base
 {
     public:
         derived():base(),derivedName("")
         {}
         derived(std::string bn,int bd,std::string dn)
         :base(bn,bd),derivedName(dn)
         {}
         std::string getDerivedName() const
         {
             return derivedName;
         }
     private:
         std::string derivedName;
 };

 void show(std::string& info,const base& b)
 {
     info.append("Name is ");
     info.append(b.getBaseName());
     info.append(", baseData is ");
     char buffer[10];
     sprintf(buffer,"%d",b.getBaseData());
         info.append(buffer);
 }

 int main(int argc,char* argv[])
 {
     base b("test",10);
     std::string s;
     show(s,b);
     std::cout<<s<<std::endl;
     derived d("btest",5,"dtest");
     std::string ss;
     show(ss,d);
     std::cout<<ss<<std::endl;
     return 0;
 }
의 실행 결 과 는 다음 과 같 습 니 다.
base:baseName is test, baseData is 10base:baseName is btest, baseData is 5
다음은 코드 를 바 꾸 고 함수 매개 변 수 를 derived

void show2(std::string& info,const derived& d)
{
    info.append("Name is ");
    info.append(d.getBaseName());
    info.append(", baseData is ");
    char buffer[10];
    sprintf(buffer,"%d",d.getBaseData());
    info.append(buffer);
}
호출 show(ss,d)로 바 꿉 니 다.컴 파일 러 오류

 derived_class.cpp: In function `int main(int, char**)':
 derived_class.cpp:84: error: invalid initialization of reference of type 'const derived&' from expression of type 'base'
 derived_class.cpp:70: error: in passing argument 2 of `void show2(std::string&, const derived&)'               ，
계승 방식\멤버 유형
public
protected
private
public
public
protected
계승 불가
protected
protected
protected
계승 불가
private
private
private
계승 불가
여기 서 설명 하 자 면,여 기 는 기본 적 인 구성원 만 을 표현 하고,Public,proctected,private 세 가지 방식 으로 계승 한 후,기본 적 인 유형 은 Public,protected c,private 의 구성원 은 계승 유형 에서 표 의 내용

class base
{
    public:
        std::string testPublic()
        {
            return std::string("this is public base");
        }
    protected:
        std::string testProtected()
       {
           return std::string("this is protected base");
       }
   private:
       std::string testPrivate()
       {
           return std::string("this is private base");
       }
};
class derivedPublic:public base
{
   public:
       std::string testPubPublic()
       {
           return testPublic()+= "in derived";
       }
       std::string testProPublic()
       {    
           return testProtected()+= "in derived";
       }
       std::string testPriPublic()                   
       {    
           return testPrivate()+= "in derived";
       }
};
int main(int argc,char* argv[])
｛
   derivedPublic dpub;
   std::cout << dpub.testPublic() << std::endl; 
｝
으로 아래 의 오 류 를 보고 합 니 다.설명 testPrivate()은 derived 사유 함수 가 아니 라 base 의 사유 함수 derived 11.cpp:16:error:`std::string base::testPrivate()'is privatederived 11.cpp:36:error:inside this context 는 private 형식 구성원 이 계승 되 지 않 음 을 검증 합 니 다(public,private,proctected)주:private,protected 는 증명 서 를 생략 하고 테스트 Protected 가 3 층 상속 류 에 의 해 계승 되 는 지 검증 하면 되 지만 3 층 류 에 의 해 직접 호출 되 지 못 한 다 는 것 은 Public 상속 후 상속 유형 이 proctected 이 고 기 류 는 Public 유형 구성원 이면 계승 되 고 직접 호출 될 수 있다 는 것 을 의미한다.

 #include <iostream>
 #include <string>

 class base
 {
     public:
         std::string testPublic()
         {
             return std::string("this is public base");
        }
    protected:
        std::string testProtected()
        {
            return std::string("this is protected base");
        }
    private:
        std::string testPrivate()
        {
            return std::string("this is private base");
        }
};

class derivedPublic:public base
{
    public:
        std::string testPubPublic()
        {
            return testPublic()+= "in derived";
        }

        std::string testProPublic()
        {    
            return testProtected()+= "in derived";
        }

//        std::string testPriPublic()                   
//        {    
//            return testPrivate()+= "in derived";
//        }
};


class deepDerived:public derivedPublic
{
    public:
        std::string deepProtected()
        {
            return testProtected() +="in deep";
        }

        std::string deepPublic()
        {
            return testPublic() +="indeep";
        }
};


int main(int argc,char* argv[])
{
    derivedPublic dpub;
    std::cout << dpub.testProtected() << std::endl; 
    deepDerived deepdpub;
    std::cout<<deepdpub.testPublic() <<std::endl;
    std::cout<<deepdpub.testProtected() <<std::endl;
    std::cout<<deepdpub.deepProtected() <<std::endl;
    std::cout<<deepdpub.deepPublic() <<std::endl;
}
여기 서버 오류
derived 12.cpp:13:error:`std:string base::testProtected()'is protected derived 12.cpp:62:error:in this context 는 이렇게 하 나 는 Public 이 고 하 나 는 proctected 이 며 proctected 는 직접 호출 할 수 없 지만 계승 되면 Public 구성원 에 의 해 호출 될 수 있 음 을 검증 했다.아래 의 증명 은 상세 한 절 차 는 생략 합 니 다.이 부분 검증 에 관심 이 있 으 면 아래 코드 를 볼 수 있 습 니 다.

 #include <iostream>
 2 #include <string>
 3 class base
 4 {
 5     public:
 6         std::string testPublic()
 7         {
 8             return std::string("this is public base");
 9         }
     protected:
         std::string testProtected()
         {
             return std::string("this is protected base");
         }
     private:
         std::string testPrivate()
         {
             return std::string("this is private base");
         }
 };

 class derivedPublic:public base
 {
     public:
         std::string testPubPublic()
         {
             return testPublic()+= "in derived";
         }

         std::string testProPublic()
         {    
             return testProtected()+= "in derived";
         }

 //        std::string testPriPublic()                   //            
 //        {    
 //            return testPrivate()+= "in derived";
 //        }
 };

 class deepDerived:public derivedPublic
 {
     public:
         std::string test()
         {
             return testPublic() +="in 3";
         }
 };

 class derivedProtected:protected base
 {
     public:
         std::string testPubProtected()
         {
             return testPublic()+= "in derived";
         }

         std::string testProProtected()
         {    
             return testProtected()+= "in derived";
         }
 };

 class deepDerived2:public derivedProtected
 {
     public:
         std::string test()
         {
             return testPublic() +="in 3";
         }
 };

 class derivedPrivate:private base
 {
     public:
         std::string testPubPirvate()
         {
             return testPublic()+= "in derived";
         }

         std::string testProPrivate()
         {    
             return testProtected()+= "in derived";
         }

 };

 //class deepDerived3:public derivedPrivate
 //{
 //    public:
 //        std::string test()
 //        {
 //            return testPublic() +="in 3";
 //        }
 //};

 int main(int argc,char* argv[])
 {
     derivedPublic dpub;
    //derivedProtected dpro;
    //derivedPrivate dpri;
    std::cout<<dpub.testPublic()<<std::endl;       //
    //std::cout<<dpub.testProtected()<<std::endl;    //           
    //cout<<dpub.testPrivate()<<std::endl;         //        
    std::cout<<dpub.testPubPublic()<<std::endl;
    std::cout<<dpub.testProPublic()<<std::endl;
    //std::cout<<dpub.testPriPrivate()<<std::endl; //     

    deepDerived dd;
    std::cout<<dd.test()<<std::endl;

    derivedProtected dpro;
    //std::cout<<dpro.testPublic()<<std::endl;        //  protected  
    std::cout<<dpro.testPubProtected()<<std::endl;
    std::cout<<dpro.testProProtected()<<std::endl;

    deepDerived2 dd2;
    std::cout<<dd2.test()<<std::endl;

    derivedPrivate dpri;
    std::cout<<dpri.testPubPirvate()<<std::endl;
    std::cout<<dpri.testProPrivate()<<std::endl;

//    deepDerived3 dd3;
//    std::cout<<dd3.test()<<std::endl;
｝
Anaconda 를 이용 하여 Python 2 와 python 3 의 공존 문 제 를 완벽 하 게 해결 합 니 다.
Python 에서 실 현 된 간단 한 dns 조회 기능 예시

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다
best100-homepage