C++లో వారసత్వం

వారసత్వం అనేది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ (OOP) యొక్క ముఖ్య స్తంభాలలో ఒకటి. ఇది కొత్త తరగతిని (ఉత్పన్నమైన లేదా చైల్డ్ క్లాస్ అని పిలుస్తారు) ఇప్పటికే ఉన్న తరగతి (బేస్ లేదా పేరెంట్ క్లాస్ అని పిలుస్తారు) నుండి సభ్యులను (గుణాలు మరియు పద్ధతులు) వారసత్వంగా పొందేందుకు అనుమతిస్తుంది, కోడ్ పునర్వినియోగాన్ని ప్రోత్సహిస్తుంది.

ప్రాథమిక సింటాక్స్

C++లో, వారసత్వం అనేది : ఆపరేటర్‌ని ఉపయోగించి ఉత్పన్నమైన తరగతి పేరు తర్వాత, యాక్సెస్ స్పెసిఫైయర్ (సాధారణంగా public) మరియు బేస్ క్లాస్ పేరును ఉపయోగించి పేర్కొనబడుతుంది.

class Shape {
public:
    void setColor(std::string c) {
        color = c;
    }
protected:
    std::string color; // Accessible by derived classes
};

// Rectangle inherits publicly from Shape
class Rectangle : public Shape {
public:
    double getArea() {
        return width * height;
    }
private:
    double width {0.0};
    double height {0.0};
};

యాక్సెస్ స్పెసిఫైయర్: protected

public మరియు privateతో పాటు, వారసత్వం protected స్పెసిఫైయర్‌ని పరిచయం చేస్తుంది:

• private బేస్ క్లాస్ సభ్యులు కాదు ఉత్పన్నమైన తరగతి నుండి నేరుగా యాక్సెస్ చేయలేరు.
• protected బేస్ క్లాస్ సభ్యులు బయటి నుండి యాక్సెస్ చేయలేరు, కానీ ఉత్పన్నమైన తరగతుల లోపల నేరుగా యాక్సెస్ చేయగలరు.

బేస్ క్లాస్ ఇనిషియలైజేషన్

కన్‌స్ట్రక్టర్‌లు స్వయంచాలకంగా వారసత్వంగా పొందబడరు. ఉత్పన్నమైన తరగతిని ఇన్‌స్టాంటియేట్ చేసినప్పుడు, బేస్ క్లాస్ కన్‌స్ట్రక్టర్‌ని మొదట అంటారు. బేస్ క్లాస్‌కు ఆర్గ్యుమెంట్‌లు అవసరమైతే, మేము దానిని తప్పనిసరిగా డెరైవ్డ్ కన్‌స్ట్రక్టర్ యొక్క సభ్యుని ఇనిషియలైజర్ జాబితాలో స్పష్టంగా అమలు చేయాలి.

class Parent {
public:
    Parent(int x) {
        std::cout << "Parent: " << x << std::endl;
    }
};

class Child : public Parent {
public:
    // Explicit call to Parent constructor
    Child(int x, int y) : Parent(x) {
        std::cout << "Child: " << y << std::endl;
    }
};

మీరే ప్రయత్నించండి