ಸಿ ++ ಆನುವಂಶಿಕತೆ


ವ್ಯಾಖ್ಯಾನ

ಆನುವಂಶಿಕ ವ್ಯಾಖ್ಯಾನ - ಪೋಷಕರು ಅಥವಾ ಪೂರ್ವಜರಿಂದ ಗುಣಮಟ್ಟ ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳಿ. ನಿಮ್ಮ ಹೆತ್ತವರ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀವು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆದಂತೆ.

ಉದಾಹರಣೆ: "ಅವಳು ತನ್ನ ತಾಯಿಯ ಸೌಂದರ್ಯವನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆದಿದ್ದಳು"

ಆಬ್ಜೆಕ್ಟ್ ಓರಿಯೆಂಟೆಡ್ ಪ್ರೊಗ್ರಾಮಿಂಗ್ನಲ್ಲಿನ ಆನುವಂಶಿಕತೆಯನ್ನು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ತರಗತಿಗಳಿಂದ ಹೊಸ ತರಗತಿಗಳನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆ ಎಂದು ವಿವರಿಸಬಹುದು.

ಹೊಸ ತರಗತಿಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ವರ್ಗಗಳ ಕೆಲವು ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ನಡವಳಿಕೆಯನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತವೆ. ಹೊಸ ವರ್ಗದ "ಪೋಷಕ" ಎಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ವರ್ಗವನ್ನು a ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮೂಲ ವರ್ಗ. ಮೂಲ ವರ್ಗದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುವ ಹೊಸ ವರ್ಗವನ್ನು a ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಪಡೆದ ವರ್ಗ.

ಆನುವಂಶಿಕತೆಯು ಕೋಡ್ ಮರುಬಳಕೆಯ ತಂತ್ರವಾಗಿದೆ. ಪಡೆದ ತರಗತಿಗಳನ್ನು ರಚಿಸುವ ಮೂಲಕ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ತರಗತಿಗಳನ್ನು ವಿಸ್ತರಿಸುವ ಸಾಧ್ಯತೆಯನ್ನು ಇದು ಒದಗಿಸುತ್ತದೆ.

ಆನುವಂಶಿಕ ಸಿಂಟ್ಯಾಕ್ಸ್

ಆನುವಂಶಿಕತೆಯ ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್:

class DerivedClass : accessSpecifier BaseClass

ಪ್ರವೇಶ ನಿರ್ದಿಷ್ಟತೆಯು ಸಾರ್ವಜನಿಕ, ಸಂರಕ್ಷಿತ ಮತ್ತು ಖಾಸಗಿಯಾಗಿರಬಹುದು. ಡೀಫಾಲ್ಟ್ ಪ್ರವೇಶ ಸ್ಪೆಸಿಫೈಯರ್ ಆಗಿದೆ ಖಾಸಗಿ. ಪ್ರವೇಶ ವರ್ಗದಿಂದ ಪಡೆದ ಮೂಲ ವರ್ಗದ ಡೇಟಾ ಸದಸ್ಯರ ಪ್ರವೇಶದ ಮೇಲೆ ಪ್ರವೇಶ ಸೂಚಕಗಳು ಪರಿಣಾಮ ಬೀರುತ್ತವೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪಡೆದ ವರ್ಗದ ಹೊರಗಿನ ಮೂಲ ವರ್ಗದ ಡೇಟಾ ಸದಸ್ಯರ ಪ್ರವೇಶವನ್ನು ಇದು ನಿರ್ಧರಿಸುತ್ತದೆ.

ಆನುವಂಶಿಕ ಪ್ರವೇಶ ಸೂಚಕಗಳು

ಸಾರ್ವಜನಿಕ ಆನುವಂಶಿಕತೆ

ಈ ಪಿತ್ರಾರ್ಜಿತ ಮೋಡ್ ಅನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಇದರಲ್ಲಿ ಬೇಸ್ ವರ್ಗದ ಸಂರಕ್ಷಿತ ಸದಸ್ಯ ವ್ಯುತ್ಪನ್ನ ವರ್ಗದ ಸಂರಕ್ಷಿತ ಸದಸ್ಯರಾಗುತ್ತಾರೆ ಮತ್ತು ಸಾರ್ವಜನಿಕರು ಸಾರ್ವಜನಿಕರಾಗುತ್ತಾರೆ.

class DerivedClass : public BaseClass
 ಮೂಲ ವರ್ಗ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಲಾಗುತ್ತಿದೆ ಸಾರ್ವಜನಿಕ ರಕ್ಷಣೆ ಖಾಸಗಿ
 ಮೂಲ ವರ್ಗದಿಂದ ಹೌದು ಹೌದು ಹೌದು
 ಮೂಲ ವರ್ಗದ ವಸ್ತುವಿನಿಂದ ಹೌದು ಇಲ್ಲ ಇಲ್ಲ
 ಪಡೆದ ತರಗತಿಗಳಿಂದ ಹೌದು (ಸಾರ್ವಜನಿಕವಾಗಿ) ಹೌದು (ರಕ್ಷಿಸಿದಂತೆ) ಇಲ್ಲ
 ಪಡೆದ ವರ್ಗದ ವಸ್ತುವಿನಿಂದ ಹೌದು ಇಲ್ಲ ಇಲ್ಲ
 ಪಡೆದ ವರ್ಗಗಳ ವ್ಯುತ್ಪನ್ನ ವರ್ಗದಿಂದ ಹೌದು (ಸಾರ್ವಜನಿಕವಾಗಿ) ಹೌದು (ರಕ್ಷಿಸಿದಂತೆ) ಇಲ್ಲ

ಪಡೆದ ವರ್ಗಗಳ ವ್ಯುತ್ಪನ್ನ ವರ್ಗ: ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ನಾವು ಸಾರ್ವಜನಿಕ ಆನುವಂಶಿಕತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪಡೆದ ವರ್ಗವನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತಿದ್ದರೆ

ವರ್ಗ ಬಿ: ಸಾರ್ವಜನಿಕ ಎ

ವರ್ಗ ಸಿ: ಸಾರ್ವಜನಿಕ ಬಿ

ನಂತರ ಎ ವರ್ಗದ ಸಾರ್ವಜನಿಕ ಮತ್ತು ಸಂರಕ್ಷಿತ ಸದಸ್ಯರನ್ನು ಸಿ ವರ್ಗದಲ್ಲಿ ಕ್ರಮವಾಗಿ ಸಾರ್ವಜನಿಕ ಮತ್ತು ಪ್ರವೇಶಿಸಬಹುದು.

ಸಂರಕ್ಷಿತ ಆನುವಂಶಿಕತೆ

ಸಂರಕ್ಷಿತ ಕ್ರಮದಲ್ಲಿ, ಬೇಸ್ ವರ್ಗದ ಸಾರ್ವಜನಿಕ ಮತ್ತು ಸಂರಕ್ಷಿತ ಸದಸ್ಯರು ಪಡೆದ ವರ್ಗದ ಸಂರಕ್ಷಿತ ಸದಸ್ಯರಾಗುತ್ತಾರೆ.

class DerivedClass : protected BaseClass
 ಮೂಲ ವರ್ಗ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಲಾಗುತ್ತಿದೆ ಸಾರ್ವಜನಿಕ ರಕ್ಷಣೆ ಖಾಸಗಿ
 ಮೂಲ ವರ್ಗದಿಂದ ಹೌದು ಹೌದು ಹೌದು
 ಮೂಲ ವರ್ಗದ ವಸ್ತುವಿನಿಂದ ಹೌದು ಇಲ್ಲ ಇಲ್ಲ
 ಪಡೆದ ತರಗತಿಗಳಿಂದ ಹೌದು (ರಕ್ಷಿಸಿದಂತೆ) ಹೌದು (ರಕ್ಷಿಸಿದಂತೆ) ಇಲ್ಲ
 ಪಡೆದ ವರ್ಗದ ವಸ್ತುವಿನಿಂದ ಇಲ್ಲ ಇಲ್ಲ ಇಲ್ಲ
 ಪಡೆದ ವರ್ಗಗಳ ವ್ಯುತ್ಪನ್ನ ವರ್ಗದಿಂದ ಹೌದು (ರಕ್ಷಿಸಿದಂತೆ) ಹೌದು (ರಕ್ಷಿಸಿದಂತೆ) ಇಲ್ಲ

ಪಡೆದ ವರ್ಗಗಳ ವ್ಯುತ್ಪನ್ನ ವರ್ಗ: ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ನಾವು ಸಂರಕ್ಷಿತ ಆನುವಂಶಿಕತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪಡೆದ ವರ್ಗವನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತಿದ್ದರೆ

ವರ್ಗ ಬಿ: ಸಂರಕ್ಷಿತ ಎ

ವರ್ಗ ಸಿ: ಸಂರಕ್ಷಿತ ಬಿ

ನಂತರ ವರ್ಗ ಎ ಯ ಸಾರ್ವಜನಿಕ ಮತ್ತು ಸಂರಕ್ಷಿತ ಸದಸ್ಯರನ್ನು ಸಿ ವರ್ಗದಲ್ಲಿ ರಕ್ಷಿಸಲಾಗಿದೆ

ಖಾಸಗಿ ಆನುವಂಶಿಕತೆ

ಖಾಸಗಿ ಮೋಡ್‌ನಲ್ಲಿ ಬೇಸ್ ವರ್ಗದ ಸಾರ್ವಜನಿಕ ಮತ್ತು ಸಂರಕ್ಷಿತ ಸದಸ್ಯರು ಪಡೆದ ವರ್ಗದ ಖಾಸಗಿ ಸದಸ್ಯರಾಗುತ್ತಾರೆ.

class DerivedClass : private BaseClass
class DerivedClass : BaseClass   // By default inheritance is private
 ಮೂಲ ವರ್ಗ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಲಾಗುತ್ತಿದೆ ಸಾರ್ವಜನಿಕ ರಕ್ಷಣೆ ಖಾಸಗಿ
 ಮೂಲ ವರ್ಗದಿಂದ ಹೌದು ಹೌದು ಹೌದು
 ಮೂಲ ವರ್ಗದ ವಸ್ತುವಿನಿಂದ ಹೌದು ಇಲ್ಲ ಇಲ್ಲ
 ಪಡೆದ ತರಗತಿಗಳಿಂದ ಹೌದು (ಖಾಸಗಿಯಾಗಿ) ಹೌದು (ಖಾಸಗಿಯಾಗಿ) ಇಲ್ಲ
 ಪಡೆದ ವರ್ಗದ ವಸ್ತುವಿನಿಂದ ಇಲ್ಲ ಇಲ್ಲ ಇಲ್ಲ
 ಪಡೆದ ವರ್ಗಗಳ ವ್ಯುತ್ಪನ್ನ ವರ್ಗದಿಂದ ಇಲ್ಲ ಇಲ್ಲ ಇಲ್ಲ

ಪಡೆದ ವರ್ಗಗಳ ವ್ಯುತ್ಪನ್ನ ವರ್ಗ: ನಾವು ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ಖಾಸಗಿ ಆನುವಂಶಿಕತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪಡೆದ ವರ್ಗವನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತಿದ್ದರೆ

ವರ್ಗ ಬಿ: ಖಾಸಗಿ ಎ

ವರ್ಗ ಸಿ: ಖಾಸಗಿ ಬಿ

ನಂತರ ಎ ವರ್ಗದ ಸಾರ್ವಜನಿಕ ಮತ್ತು ಸಂರಕ್ಷಿತ ಸದಸ್ಯರನ್ನು ಸಿ ವರ್ಗದಲ್ಲಿ ಪ್ರವೇಶಿಸಲಾಗುವುದಿಲ್ಲ


ಆನುವಂಶಿಕ ವಿಧಗಳು

ವಿವಿಧ ರೀತಿಯ ಆನುವಂಶಿಕತೆಗಳಿವೆ:

  1. ಏಕ ಆನುವಂಶಿಕತೆ
  2. ಬಹು ಆನುವಂಶಿಕತೆ
  3. ಬಹುಮಟ್ಟದ ಆನುವಂಶಿಕತೆ
  4. ಕ್ರಮಾನುಗತ ಆನುವಂಶಿಕತೆ
  5. ಹೈಬ್ರಿಡ್ (ವರ್ಚುವಲ್) ಆನುವಂಶಿಕತೆ

ಏಕ ಆನುವಂಶಿಕತೆ

ಒಂದೇ ಮೂಲ ವರ್ಗ ಮತ್ತು ಒಂದು ಪಡೆದ ವರ್ಗ ಇದ್ದಾಗ ಏಕ ಆನುವಂಶಿಕತೆಯು ಒಂದು ರೀತಿಯ ಆನುವಂಶಿಕತೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಒಂದು ವರ್ಗವು a ಅನ್ನು ವಿವರಿಸುತ್ತದೆ ವ್ಯಕ್ತಿ:

ಏಕ-ಆನುವಂಶಿಕತೆ

ಏಕ ಆನುವಂಶಿಕತೆಯ ಉದಾಹರಣೆ

//base class
class Person
{
public:
	Person(string szName, int iYear)
	{
		m_szLastName = szName;
		m_iYearOfBirth = iYear;
	}
	string m_szLastName;
	int m_iYearOfBirth;
	void print()
	{
		cout << "Last name: " << szLastName << endl;
		cout << "Year of birth: " << iYearOfBirth << endl;
	}
protected:
	string m_szPhoneNumber;
};

ನಾವು ಹೊಸ ವರ್ಗವನ್ನು ರಚಿಸಲು ಬಯಸುತ್ತೇವೆ ವಿದ್ಯಾರ್ಥಿ ಅದೇ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿರಬೇಕು ವ್ಯಕ್ತಿ ವರ್ಗ ಜೊತೆಗೆ ವಿಶ್ವವಿದ್ಯಾಲಯದ ಬಗ್ಗೆ ಹೊಸ ಮಾಹಿತಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಪಡೆದ ವರ್ಗವನ್ನು ರಚಿಸಬಹುದು ವಿದ್ಯಾರ್ಥಿ:

//derived class
class Student:public Person
{
public:
	string m_szUniversity;
};

ವರ್ಗ ವಿದ್ಯಾರ್ಥಿ ಮೂಲ ವರ್ಗದ (ವ್ಯಕ್ತಿ) ಎಲ್ಲಾ ಡೇಟಾ ಸದಸ್ಯರಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದ್ದಾನೆ.

ವರ್ಗ ವಿದ್ಯಾರ್ಥಿಗೆ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಇಲ್ಲದಿರುವುದರಿಂದ ನೀವು ಈ ಕೆಳಗಿನಂತೆ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ರಚಿಸಬಹುದು

//will call default constructor of base class automatically
Student(string szName, int iYear, string szUniversity)
{
	m_szUniversity = szUniversity;
}

ವ್ಯುತ್ಪನ್ನ ವರ್ಗದಿಂದ ಬೇಸ್ ವರ್ಗದ ಪ್ಯಾರಾಮೀಟರ್ ಮಾಡಲಾದ (ಬಳಕೆದಾರ ವ್ಯಾಖ್ಯಾನಿತ) ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ನೀವು ಕರೆಯಲು ಬಯಸಿದರೆ, ನಂತರ ನೀವು ಈ ಕೆಳಗಿನಂತೆ ಪಡೆದ ವರ್ಗದ ಪ್ಯಾರಾಮೀಟರ್ ಮಾಡಲಾದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬರೆಯಬೇಕಾಗಿದೆ

Student(string szName, int iYear, string szUniversity) :Person(szName, iYear)
{
	m_szUniversity = szUniversity;
}

ವ್ಯಕ್ತಿ (szName, iYear) ಮೂಲ ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಕರೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ವ್ಯಕ್ತಿ. ಸದಸ್ಯ ವರ್ಗ ಪ್ರಾರಂಭದ ಪಟ್ಟಿಯ ಮೂಲಕ ಮೂಲ ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ಮೌಲ್ಯಗಳನ್ನು ರವಾನಿಸಲಾಗುತ್ತದೆ.

ಪಡೆದ ವರ್ಗದಿಂದ ನಾವು ಮೂಲ ವರ್ಗದ ಸದಸ್ಯ ಕಾರ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಾವು ಹೊಸದನ್ನು ರಚಿಸಬಹುದು ಮುದ್ರಿಸಿ() ಬಳಸಿದ ವರ್ಗದಲ್ಲಿ ಕಾರ್ಯ ಮುದ್ರಿಸಿ() ಮೂಲ ವರ್ಗದ ಸದಸ್ಯರ ಕಾರ್ಯ:

void print()
{
	//call function print from base class
	Person::print();
	cout << "University " << m_szUniversity << endl;
}

ನೀವು ಬೇಸ್ ಕ್ಲಾಸ್‌ನ ಸದಸ್ಯ ಕಾರ್ಯವನ್ನು ಕರೆಯಲು ಬಯಸಿದರೆ ನೀವು ಬೇಸ್ ಕ್ಲಾಸ್‌ನ ಹೆಸರನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ

ಬಹು ಆನುವಂಶಿಕತೆ

ಪಡೆದ ವರ್ಗವು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪಡೆದಾಗ ಬಹು ಆನುವಂಶಿಕತೆಯು ಒಂದು ರೀತಿಯ ಆನುವಂಶಿಕತೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಅನೇಕ ತರಗತಿಗಳು. ಉದಾಹರಣೆಗೆ, ಎ, ಬಿ ಮತ್ತು ಸಿ ಎಂಬ ಮೂರು ವರ್ಗಗಳಿವೆ ಮತ್ತು ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ಪಡೆದ ವರ್ಗ ಡಿ ಆಗಿದೆ:

ಬಹು-ಆನುವಂಶಿಕತೆ

ನೀವು ಅನೇಕ ಮೂಲ ವರ್ಗಗಳೊಂದಿಗೆ ವರ್ಗವನ್ನು ರಚಿಸಲು ಬಯಸಿದರೆ, ನೀವು ಈ ಕೆಳಗಿನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ:

ವರ್ಗ ಪಡೆದ ವರ್ಗ: ಪ್ರವೇಶ ಸ್ಪೆಸಿಫೈಯರ್ ಬೇಸ್‌ಕ್ಲಾಸ್ 1, ಬೇಸ್‌ಕ್ಲಾಸ್ 2,…, ಬೇಸ್‌ಕ್ಲಾಸ್ಎನ್

ಬಹು ಆನುವಂಶಿಕತೆಯ ಉದಾಹರಣೆ

class A
{
	int m_iA;
	A(int iA) :m_iA(iA)
	{
	}
};

class B
{
	int m_iB;
	B(int iB) :m_iB(iB)
	{
	}
};

class C
{
	int m_iC;
	C(int iC) :m_iC(iC)
	{
	}
};

ಈ ಎಲ್ಲಾ ವರ್ಗಗಳ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುವ ಹೊಸ ವರ್ಗವನ್ನು ನೀವು ರಚಿಸಬಹುದು:

class ABC :public A, public B, public C
{
	int m_iABC;
	//here you can access m_iA, m_iB, m_iC 
};

ಬಹುಮಟ್ಟದ ಆನುವಂಶಿಕತೆ

ವ್ಯುತ್ಪನ್ನ ವರ್ಗವು ಮತ್ತೊಂದು ವರ್ಗಕ್ಕೆ ಮೂಲ ವರ್ಗವಾಗಿದ್ದಾಗ ಬಹುಮಟ್ಟದ ಆನುವಂಶಿಕತೆಯು ಒಂದು ರೀತಿಯ ಆನುವಂಶಿಕತೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಪಡೆದ ವರ್ಗದಿಂದ ಒಂದು ವರ್ಗವನ್ನು ಪಡೆಯುವುದನ್ನು ಬಹು-ಹಂತದ ಆನುವಂಶಿಕತೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಸರಳ ಬಹು-ಹಂತದ ಆನುವಂಶಿಕತೆಯನ್ನು ಕೆಳಗಿನ ಚಿತ್ರದಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ, ಅಲ್ಲಿ ವರ್ಗ ಎ ವರ್ಗ ಬಿ ಯ ಪೋಷಕರಾಗಿದ್ದರೆ ಮತ್ತು ವರ್ಗ ಬಿ ವರ್ಗ ಸಿ ಯ ಪೋಷಕರಾಗಿದ್ದಾರೆ

ಬಹು-ಹಂತದ ಆನುವಂಶಿಕತೆಯ ಉದಾಹರಣೆ

ಚಿತ್ರದ ಕೆಳಗೆ ಬಹುಮಟ್ಟದ ಆನುವಂಶಿಕತೆಯ ಉದಾಹರಣೆಯನ್ನು ತೋರಿಸುತ್ತದೆ

ನೀವು ನೋಡುವಂತೆ, ವರ್ಗ ವ್ಯಕ್ತಿ ಎರಡರ ಮೂಲ ವರ್ಗವಾಗಿದೆ ವಿದ್ಯಾರ್ಥಿ ಮತ್ತು ಉದ್ಯೋಗಿ ತರಗತಿಗಳು. ಅದೇ ಸಮಯದಲ್ಲಿ, ವರ್ಗ ವಿದ್ಯಾರ್ಥಿ ಗಾಗಿ ಮೂಲ ವರ್ಗವಾಗಿದೆ ಅದರ ವಿದ್ಯಾರ್ಥಿ ಮತ್ತು ಮ್ಯಾಥ್‌ಸ್ಟೂಡೆಂಟ್ ತರಗತಿಗಳು. ಉದ್ಯೋಗಿ ಗಾಗಿ ಮೂಲ ವರ್ಗವಾಗಿದೆ ಚಾಲಕ ಮತ್ತು ಇಂಜಿನಿಯರ್ ತರಗತಿಗಳು.

ಮಲ್ಟಿಲೆವೆಲ್ ಆನುವಂಶಿಕತೆಯ ಮೇಲಿನ ಉದಾಹರಣೆಯ ಕೋಡ್ ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ಇರುತ್ತದೆ

class Person 
{
	//content of class person
};

class Student :public Person
{
	//content of Student class
};

class Employee : public Person
{
	//content of Employee class
};

class ITStundet :public Student
{
	//content of ITStudent class
};

class MathStundet :public Student
{
	//content of MathStudent class
};

class Driver :public Employee
{
	//content of class Driver
};

class Engineer :public Employee
{
	//content of class Engineer
};

ಕ್ರಮಾನುಗತ ಆನುವಂಶಿಕತೆ

ಒಂದೇ ಮೂಲ ವರ್ಗದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುವ ಅನೇಕ ವ್ಯುತ್ಪನ್ನ ವರ್ಗಗಳನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿರುವಾಗ ಅದನ್ನು ಶ್ರೇಣೀಕೃತ ಆನುವಂಶಿಕತೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ

class base
{
	//content of base class
};

class derived1 :public base
{
	//content of derived1
};

class derived2 :public base
{
	//content of derived
};

class derived3 :public base
{
	//content of derived3
};

class derived4 :public base
{
	//content of derived4
};

ಹೈಬ್ರಿಡ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (ವರ್ಚುವಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಎಂದೂ ಕರೆಯುತ್ತಾರೆ)

ಬಹು-ಹಂತದ ಮತ್ತು ಶ್ರೇಣೀಕೃತ ಆನುವಂಶಿಕತೆಯ ಸಂಯೋಜನೆಯು ನಿಮಗೆ ಹೈಬ್ರಿಡ್ ಆನುವಂಶಿಕತೆಯನ್ನು ನೀಡುತ್ತದೆ.

ವಜ್ರ ಸಮಸ್ಯೆ

ನೀವು ಹೈಬ್ರಿಡ್ ಆನುವಂಶಿಕತೆಯನ್ನು ಹೊಂದಿರುವಾಗ ಡೈಮಂಡ್ ಸಮಸ್ಯೆ ಉದ್ಭವಿಸಬಹುದು. ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ ವ್ಯುತ್ಪನ್ನ ವರ್ಗವು ಮೂಲ ವರ್ಗಕ್ಕೆ ಅನೇಕ ಮಾರ್ಗಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಇದು ಮೂಲ ವರ್ಗದ ನಕಲಿ ಆನುವಂಶಿಕ ಸದಸ್ಯರಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಈ ರೀತಿಯ ಸಮಸ್ಯೆಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ವಜ್ರ ಸಮಸ್ಯೆ

ವರ್ಚುವಲ್ ಆನುವಂಶಿಕತೆ

ನಾವು ಸುಲಭವಾಗಿ ವಜ್ರ ಸಮಸ್ಯೆಯನ್ನು ತಪ್ಪಿಸಬಹುದು ವರ್ಚುವಲ್ ಆನುವಂಶಿಕತೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಮಕ್ಕಳ ತರಗತಿಗಳು ವರ್ಚುವಲ್ ಆನುವಂಶಿಕತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅಜ್ಜಿಯ ವರ್ಗವನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯಬೇಕು:

class Grandparent
{
	//content of grandparent class
};

class Child1 :public virtual Grandparent
{
	//content of Child1 class
};

class Child2 :public virtual Grandparent
{
	//content of Child2 class
};

class grandson :public Child1, public Child2
{
	//content of grandson class
};

ಈಗ ಮೊಮ್ಮಗ ವರ್ಗವು ಅಜ್ಜ-ಅಜ್ಜ ವರ್ಗದ ಡೇಟಾ ಸದಸ್ಯರ ಒಂದೇ ನಕಲನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಕರೆ ಆದೇಶ

ಪಡೆದ ವರ್ಗದ ಡೀಫಾಲ್ಟ್ ಅಥವಾ ಪ್ಯಾರಾಮೀಟರ್ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯುವಾಗ, ಬೇಸ್ ಕ್ಲಾಸ್ನ ಡೀಫಾಲ್ಟ್ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ. ನೀವು ಪಡೆದ ವರ್ಗದ ವಸ್ತುವನ್ನು ರಚಿಸುವಾಗ, ಮೊದಲು ಬೇಸ್ ಕ್ಲಾಸ್‌ನ ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಆ ವ್ಯುತ್ಪನ್ನ ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

ಬೇಸ್ ಕ್ಲಾಸ್‌ನ ಪ್ಯಾರಾಮೀಟರ್ ಮಾಡಲಾದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯಲು ನೀವು ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ಅದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕರೆಯಬೇಕು.

Student(string szName, int iYear, string szUniversity) :Person(szName, iYear)
{

}

ಕೆಳಗಿನ ವರ್ಗವು ಮರಣದಂಡನೆಯ ಕ್ರಮವನ್ನು ತೋರಿಸುತ್ತದೆ, ಅದು ಮೂಲ ವರ್ಗದ ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಮೊದಲು ಮುಗಿದ ನಂತರ ಪಡೆದ ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಒಂದೇ ಆನುವಂಶಿಕತೆಯೊಂದಿಗೆ ಎರಡು ವರ್ಗಗಳಿವೆ:

//base class
class Person
{
public:
	Person()
	{
		cout  << "Default constructor of base class called" << endl;
	}
	Person(string lName, int year)
	{
		cout  << "Parameterized constructor of base class called" << endl;
		lastName = lName;
		yearOfBirth = year;
	}
	string lastName;
	int yearOfBirth;
};

//derived class
class Student :public Person
{
public:
	Student()
	{
		cout  << "Default constructor of Derived class called" << endl;
	}
	Student(string lName, int year, string univer)
	{
		cout  << "Parameterized constructor of Derived class called" << endl;
		university  = univer;
	}
	string university;
};

ಬೇಸ್ ಕ್ಲಾಸ್‌ನ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಸ್ಪಷ್ಟ ಕರೆ ಇಲ್ಲ. ಆದರೆ ಡೀಫಾಲ್ಟ್ ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್ ಮಾಡಲಾದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವಿದ್ಯಾರ್ಥಿ ವರ್ಗದ ಎರಡು ವಸ್ತುಗಳನ್ನು ರಚಿಸುವಾಗ, ಎರಡೂ ಬಾರಿ ಬೇಸ್ ಕ್ಲಾಸ್‌ನ ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.

Student student1; //Using default constructor of Student class
Student student2("John", 1990, "London School of  Economics"); //calling parameterized constructor of Student class

ಮೇಲಿನ ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಬೇಸ್ ಕ್ಲಾಸ್‌ನ ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ವ್ಯುತ್ಪನ್ನ ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ಮೊದಲು ಕರೆಯಲಾಗುತ್ತದೆ.

Default constructor of base class called
Default constructor of Derived class called
Default constructor of base class called
Parameterized constructor of Derived class called

ಬಹು ಆನುವಂಶಿಕತೆಯನ್ನು ಬಳಸಿದಾಗ, ಮೂಲ ವರ್ಗಗಳ ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳನ್ನು ಆನುವಂಶಿಕ ಪಟ್ಟಿಯಲ್ಲಿರುವಂತೆ ಕ್ರಮದಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಪಡೆದ ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯುವಾಗ:

class derived: public class1, public class 2

ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳ ಕರೆಗಳ ಕ್ರಮ ಇರುತ್ತದೆ

class1 default constructor
class2 default constructor
derived constructor

ನೀವು ಬೇಸ್ ಕ್ಲಾಸ್‌ನ ಪ್ಯಾರಾಮೀಟರ್ ಮಾಡಲಾದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯಲು ಬಯಸಿದರೆ ಇದನ್ನು ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ಇನಿಶಿಯಲೈಸರ್ ಪಟ್ಟಿಯನ್ನು ಬಳಸಿ ಮಾಡಬಹುದು.

Student(string lName, int year, string univer) :Person(lName, year)
{
	cout << "Parameterized constructor of Derived class works" << endl;
	university  = univer;
}

ಮೇಲಿನ ಕೋಡ್ ಎಂದರೆ ನೀವು ಮೂಲ ವರ್ಗದ ಪ್ಯಾರಾಮೀಟರೈಸ್ಡ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯುತ್ತಿದ್ದೀರಿ ಮತ್ತು ಅದಕ್ಕೆ ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ರವಾನಿಸುತ್ತಿದ್ದೀರಿ. ಈಗ output ಟ್ಪುಟ್ ಇರುತ್ತದೆ

Default constructor of base class works
Default constructor of Derived class works
Parameterized constructor of base class works
Parameterized constructor of Derived class works

ಬೇಸ್ ಕ್ಲಾಸ್‌ನ ಪ್ಯಾರಾಮೀಟರ್ ಮಾಡಲಾದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ವ್ಯುತ್ಪನ್ನ ವರ್ಗ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಿಂದ ಕರೆಯಲಾಗುತ್ತದೆ ಎಂದು ಈಗ ನೀವು ನೋಡಬಹುದು.