// Example: define member function without argument within // the class #include  using namespace std; class Person {  int id;  char name[100]; public:  void set_p()  {  cout << 'Enter the Id:';  cin>> 아이디;  시합<< 'Enter the Name:';  cin>> 이름;  } 무효 디스플레이_p() { cout<< endl <<'Id: '<< id << '
Name: ' << name <> 물론입니다;  시합<< 'Enter the Course Fee:';  cin>> 수수료;  } 무효 디스플레이_s() { 디스플레이_p();  시합<<'Course: '<< course << '
Fee: ' << fee << endl;  } }; int main() {  Student s;  s.set_s();  s.display_s();  return 0; }>

// Example: define member function without argument outside the class #include using namespace std; class Person {  int id;  char name[100];    public:  void set_p();  void display_p(); }; void Person::set_p() {  cout<<'Enter the Id:';  cin>>아이디;  시합<<'Enter the Name:';  cin>>이름; } 무효 사람::display_p() { cout<> 물론;  시합<<'Enter the Course Fee:';  cin>>수수료; } void Student::display_s() { display_p();  시합<<'
Course: '<

// Example: define member function with argument outside the class #include #include using namespace std; class Person {  int id;  char name[100];    public:  void set_p(int,char[]);  void display_p(); }; void Person::set_p(int id,char n[]) {  this->아이디=아이디;  strcpy(이->이름,n);  } 무효 사람::display_p() { cout<

// C++ program to demonstrate implementation // of Inheritance #include  using namespace std; // Base class class Parent { public:  int id_p; }; // Sub class inheriting from Base Class(Parent) class Child : public Parent { public:  int id_c; }; // main function int main() {  Child obj1;  // An object of class child has all data members  // and member functions of class parent  obj1.id_c = 7;  obj1.id_p = 91;  cout << 'Child id is: ' << obj1.id_c << '
';  cout << 'Parent id is: ' << obj1.id_p << '
';  return 0; }>

// C++ Implementation to show that a derived class // doesn’t inherit access to private data members. // However, it does inherit a full parent object. class A { public:  int x; protected:  int y; private:  int z; }; class B : public A {  // x is public  // y is protected  // z is not accessible from B }; class C : protected A {  // x is protected  // y is protected  // z is not accessible from C }; class D : private A // 'private' is default for classes {  // x is private  // y is private  // z is not accessible from D };>

// C++ program to explain  // Single inheritance #include using namespace std; // base class class Vehicle {  public:  Vehicle()  {  cout << 'This is a Vehicle
';  } }; // sub class derived from a single base classes class Car : public Vehicle { }; // main function int main() {   // Creating object of sub class will  // invoke the constructor of base classes  Car obj;  return 0; }>

// Example: #include using namespace std; class A {  protected:  int a;    public:  void set_A()  {  cout<<'Enter the Value of A=';  cin>>아;    } 무효 disp_A() { cout<출력:- A= 3의 값을 입력합니다. 3 B의 값을 입력합니다. = 5 5 3의 곱 * 5 = 15
 
 
C++ 
// Example: #include using namespace std; class A {  protected:  int a;    public:  void set_A(int x)  {  a=x;   }    void disp_A()  {  cout<Product of 4 * 5 = 20>
 
 
 
    2. 다중 상속:    다중 상속은 클래스가 둘 이상의 클래스에서 상속할 수 있는 C++의 기능입니다. 즉 하나    아강    둘 이상의 것으로부터 상속됨    기본 클래스    .
 
 
 
    통사론    :
 
class subclass_name : access_mode base_class1, access_mode base_class2, .... {  // body of subclass }; class B {  ... .. ...  }; class C { ... .. ... }; class A: public B, public C { ... ... ... };>
여기서 기본 클래스 수는 쉼표(', ')로 구분되며 모든 기본 클래스에 대한 액세스 모드를 지정해야 합니다.
CPP 
// C++ program to explain // multiple inheritance #include  using namespace std; // first base class class Vehicle { public:  Vehicle() { cout << 'This is a Vehicle
'; } }; // second base class class FourWheeler { public:  FourWheeler()  {  cout << 'This is a 4 wheeler Vehicle
';  } }; // sub class derived from two base classes class Car : public Vehicle, public FourWheeler { }; // main function int main() {  // Creating object of sub class will  // invoke the constructor of base classes.  Car obj;  return 0; }>
   
  산출  
This is a Vehicle This is a 4 wheeler Vehicle>
 
 
C++ 
// Example: #include using namespace std; class A {  protected:  int a;    public:  void set_A()  {  cout<<'Enter the Value of A=';  cin>>아;    } 무효 disp_A() { cout<자세한 내용은 기사를 참조하세요. 다중 상속 .
 
  
    3. 다단계 상속    : 이 유형의 상속에서는 파생 클래스가 다른 파생 클래스에서 생성됩니다.
 
 
버블 정렬 자바
 
통사론:-
 
class C {  ... .. ...  }; class B:public C { ... .. ... }; class A: public B { ... ... ... };>
CPP 
// C++ program to implement // Multilevel Inheritance #include  using namespace std; // base class class Vehicle { public:  Vehicle() { cout << 'This is a Vehicle
'; } }; // first sub_class derived from class vehicle class fourWheeler : public Vehicle { public:  fourWheeler()  {  cout << 'Objects with 4 wheels are vehicles
';  } }; // sub class derived from the derived base class fourWheeler class Car : public fourWheeler { public:  Car() { cout << 'Car has 4 Wheels
'; } }; // main function int main() {  // Creating object of sub class will  // invoke the constructor of base classes.  Car obj;  return 0; }>
   
  산출  
This is a Vehicle Objects with 4 wheels are vehicles Car has 4 Wheels>
 
    4. 계층적 상속    : 이 유형의 상속에서는 단일 기본 클래스에서 둘 이상의 하위 클래스가 상속됩니다. 즉, 단일 기본 클래스에서 둘 이상의 파생 클래스가 생성됩니다.
 
 
 
통사론:-
 
class A  {   // body of the class A.  }  class B : public A  {   // body of class B.  }  class C : public A  {   // body of class C.  }  class D : public A  {   // body of class D.  }>
CPP 
// C++ program to implement // Hierarchical Inheritance #include  using namespace std; // base class class Vehicle { public:  Vehicle() { cout << 'This is a Vehicle
'; } }; // first sub class class Car : public Vehicle { }; // second sub class class Bus : public Vehicle { }; // main function int main() {  // Creating object of sub class will  // invoke the constructor of base class.  Car obj1;  Bus obj2;  return 0; }>
   
  산출  
This is a Vehicle This is a Vehicle>
 
    5. 하이브리드(가상) 상속    : 하이브리드 상속은 두 가지 이상의 상속 유형을 결합하여 구현됩니다. 예: 계층적 상속과 다중 상속 결합.  
아래 이미지는 계층적 상속과 다중 상속의 조합을 보여줍니다.
 
 
CPP 
// C++ program for Hybrid Inheritance #include  using namespace std; // base class class Vehicle { public:  Vehicle() { cout << 'This is a Vehicle
'; } }; // base class class Fare { public:  Fare() { cout << 'Fare of Vehicle
'; } }; // first sub class class Car : public Vehicle { }; // second sub class class Bus : public Vehicle, public Fare { }; // main function int main() {  // Creating object of sub class will  // invoke the constructor of base class.  Bus obj2;  return 0; }>
   
  산출  
This is a Vehicle Fare of Vehicle>
C++ 
// Example: #include   using namespace std;  class A  {   protected:   int a;   public:   void get_a()   {   cout << 'Enter the value of 'a' : ';   cin>>아;   } };    클래스 B : 공개 A { 보호: int b;   공개: 무효 get_b() { cout<< 'Enter the value of 'b' : ';  cin>>b;   } };  클래스 C { 보호: int c;   공개: 무효 get_c() { cout<< 'Enter the value of c is : ';   cin>>ㄷ;   } };    클래스 D : 공개 B, 공개 C { 보호: int d;   공개: void mul() { get_a();   get_b();   get_c();   시합<< 'Multiplication of a,b,c is : ' < 
  
 
라제쉬 칸나
 
    6. 하이브리드 상속의 특별한 경우: 다중 경로 상속    :  
두 개의 기본 클래스가 있는 파생 클래스와 이 두 기본 클래스가 하나의 공통 기본 클래스를 갖는 것을 다중 경로 상속이라고 합니다. 이러한 유형의 상속에서는 모호성이 발생할 수 있습니다.  
    예:    
CPP 
// C++ program demonstrating ambiguity in Multipath // Inheritance #include  using namespace std; class ClassA { public:  int a; }; class ClassB : public ClassA { public:  int b; }; class ClassC : public ClassA { public:  int c; }; class ClassD : public ClassB, public ClassC { public:  int d; }; int main() {  ClassD obj;  // obj.a = 10; // Statement 1, Error  // obj.a = 100; // Statement 2, Error  obj.ClassB::a = 10; // Statement 3  obj.ClassC::a = 100; // Statement 4  obj.b = 20;  obj.c = 30;  obj.d = 40;  cout << ' a from ClassB : ' << obj.ClassB::a;  cout << '
 a from ClassC : ' << obj.ClassC::a;  cout << '
 b : ' << obj.b;  cout << '
 c : ' << obj.c;  cout << '
 d : ' << obj.d << '
'; }>
   
  산출  
 a from ClassB : 10 a from ClassC : 100 b : 20 c : 30 d : 40>
 
위의 예에서 ClassB와 ClassC는 모두 ClassA를 상속하며 둘 다 ClassA의 단일 복사본을 갖습니다. 그러나 Class-D는 ClassB와 ClassC를 모두 상속하므로 Class-D에는 ClassB와 ClassC의 두 가지 ClassA 복사본이 있습니다.  
Class-D 객체를 통해 ClassA의 데이터 멤버에 액세스해야 하는 경우 ClassB 또는 ClassC에서 액세스할 경로를 지정해야 합니다. bcoz 컴파일러는 ClassA의 두 복사본을 구별할 수 없습니다. D등급.
 
이러한 모호함을 피하는 방법에는 두 가지가 있습니다.         
    1) 범위 확인 연산자를 사용하여 모호함을 피합니다.    위 예의 문 3과 4에 표시된 것처럼 범위 확인 연산자를 사용하여 데이터 멤버 a에 액세스할 경로를 수동으로 지정할 수 있습니다.
CPP 
obj.ClassB::a = 10; // Statement 3 obj.ClassC::a = 100; // Statement 4>
  
  
      메모:      그래도 Class-D에는 ClassA의 복사본이 두 개 있습니다.  
    2) 가상 기본 클래스를 사용하여 모호함을 피합니다.     
CPP 
#include class ClassA {  public:  int a; }; class ClassB : virtual public ClassA {  public:  int b; }; class ClassC : virtual public ClassA {  public:  int c; }; class ClassD : public ClassB, public ClassC {  public:  int d; }; int main() {  ClassD obj;  obj.a = 10; // Statement 3  obj.a = 100; // Statement 4  obj.b = 20;  obj.c = 30;  obj.d = 40;  cout << '
 a : ' << obj.a;  cout << '
 b : ' << obj.b;  cout << '
 c : ' << obj.c;  cout << '
 d : ' << obj.d << '
'; }>
  
    산출:    
 
a : 100 b : 20 c : 30 d : 40>
위의 예에 따르면 Class-D에는 ClassA의 복사본이 하나만 있으므로 명령문 4는 명령문 3에 지정된 a의 값을 덮어씁니다.