// 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>> id;  cout<< 'Enter the Name:';  cin>> vārds;  } void display_p() { cout<< endl <<'Id: '<< id << '
Name: ' << name <> kurss;  cout<< 'Enter the Course Fee:';  cin>> maksa;  } void display_s() { display_p();  cout<<'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>>id;  cout<<'Enter the Name:';  cin>>nosaukums; } void Persona::displejs_p() { cout<>kurss;  cout<<'Enter the Course Fee:';  cin>> maksa; } void Students::displejs() { displejs_p();  cout<<'
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->id=id;  strcpy(šis->nosaukums,n);  } void Persona::displejs_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>>a;    } void disp_A() { cout<Izvade: - ievadiet vērtību A= 3 3 Ievadiet vērtību B= 5 5 reizinājums no 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. Daudzkārtējs mantojums:    Daudzkārtēja mantošana ir C++ iezīme, kurā klase var mantot no vairāk nekā vienas klases. i., viens    apakšklase    ir mantots no vairāk nekā viena    bāzes klase    .
 
 
 
    Sintakse    :
 
class subclass_name : access_mode base_class1, access_mode base_class2, .... {  // body of subclass }; class B {  ... .. ...  }; class C { ... .. ... }; class A: public B, public C { ... ... ... };>
Šeit bāzes klašu skaits tiks atdalīts ar komatu (', '), un ir jānorāda katras bāzes klases piekļuves režīms.
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; }>
   
  Izvade  
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>>a;    } void disp_A() { cout<Lai uzzinātu vairāk par to, lūdzu, skatiet rakstu Vairāki mantojumi .
 
  
    3. Daudzlīmeņu mantošana    : šāda veida mantojumā atvasināta klase tiek izveidota no citas atvasinātas klases.
 
 
mamma kulkarni
 
Sintakse:-
 
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; }>
   
  Izvade  
This is a Vehicle Objects with 4 wheels are vehicles Car has 4 Wheels>
 
    4. Hierarhiskā mantošana    : šāda veida mantojumā vairāk nekā viena apakšklase tiek mantota no vienas bāzes klases. i., no vienas bāzes klases tiek izveidotas vairāk nekā viena atvasināta klase.
 
 
 
Sintakse:-
 
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; }>
   
  Izvade  
This is a Vehicle This is a Vehicle>
 
    5. Hibrīdā (virtuālā) mantošana    : Hibrīda mantošana tiek īstenota, apvienojot vairāk nekā vienu mantojuma veidu. Piemēram: hierarhiskā mantojuma un vairāku mantojuma apvienošana.  
Zemāk redzamajā attēlā parādīta hierarhiskā un vairāku mantojuma kombinācija:
 
 
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; }>
   
  Izvade  
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>>a;   } };    klase B : publisks A {aizsargāts: int b;   publisks: void get_b() { cout<< 'Enter the value of 'b' : ';  cin>>b;   } };  klase C {aizsargāts: int c;   publisks: void get_c() { cout<< 'Enter the value of c is : ';   cin>>c;   } };    klase D : publiska B, publiska C { aizsargāts: int d;   publisks: void mul() { get_a();   get_b();   get_c();   cout<< 'Multiplication of a,b,c is : ' < 
  
 
 
    6. Īpašs hibrīda mantojuma gadījums: daudzceļu mantošana    :  
Atvasinātu klasi ar divām bāzes klasēm, un šīm divām bāzes klasēm ir viena kopīga bāzes klase, sauc par daudzceļu mantojumu. Šāda veida mantojumā var rasties neskaidrības.  
    Piemērs:    
java vs c++
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 << '
'; }>
   
  Izvade  
 a from ClassB : 10 a from ClassC : 100 b : 20 c : 30 d : 40>
 
Iepriekš minētajā piemērā gan ClassB, gan ClassC manto ClassA, un tām abām ir viena ClassA kopija. Tomēr D klase manto gan B klasi, gan C klasi, tāpēc D klasei ir divas A klases kopijas, viena no B klases un otra — no C.  
Ja mums ir jāpiekļūst ClassA datu dalībniekam, izmantojot D klases objektu, mums ir jānorāda ceļš, no kura tiks piekļūts, neatkarīgi no tā, vai tas ir no ClassB vai ClassC, bcoz kompilators nevar atšķirt divas ClassA kopijas. D klase.
 
Ir 2 veidi, kā izvairīties no šīs neskaidrības:         
    1) Neskaidrību novēršana, izmantojot tvēruma izšķirtspējas operatoru:    Izmantojot tvēruma izšķirtspējas operatoru, mēs varam manuāli norādīt ceļu, no kura tiks piekļūts datu dalībniekam a, kā parādīts 3. un 4. priekšrakstā iepriekš minētajā piemērā.
CPP 
obj.ClassB::a = 10; // Statement 3 obj.ClassC::a = 100; // Statement 4>
  
  
      Piezīme:      Tomēr D klasē ir divas A klases kopijas.  
    2) Izvairīšanās no neskaidrībām, izmantojot virtuālo bāzes klasi:     
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 << '
'; }>
  
    Izvade:    
 
a : 100 b : 20 c : 30 d : 40>
Saskaņā ar iepriekš minēto piemēru D klasei ir tikai viena A klases kopija, tāpēc 4. priekšraksts pārrakstīs a vērtību, kas norādīta 3. priekšrakstā.