C++లో మాడిఫైయర్‌లను యాక్సెస్ చేయండి
క్లాస్ డేటా యొక్క యాక్సెసిబిలిటీ మరియు విజిబిలిటీని మేనేజ్ చేయడానికి యాక్సెస్ మాడిఫైయర్‌లు ఉపయోగించబడతాయి. వారు డేటా సభ్యులకు కొన్ని పరిమితులను సెట్ చేస్తారు, తద్వారా వారు బయటి ఫంక్షన్ల ద్వారా యాక్సెస్ చేయబడలేరు. యాక్సెస్ మాడిఫైయర్‌లు C++లో మూడు రకాలుగా ఉంటాయి:
C++లో పబ్లిక్ యాక్సెస్ మాడిఫైయర్
పబ్లిక్ కీవర్డ్ కింద ప్రకటించబడిన తరగతి సభ్యులందరూ ప్రోగ్రామ్‌లోని తరగతి వెలుపల ఉన్న అన్ని ఫంక్షన్‌లకు అందుబాటులో ఉంటారు. డాట్ ఆపరేటర్ అని కూడా పిలువబడే డైరెక్ట్ మెంబర్ యాక్సెస్ ఆపరేటర్ (.) ఈ డేటా మెంబర్‌లను యాక్సెస్ చేయడానికి నిర్దిష్ట తరగతి యొక్క వస్తువుతో ఉపయోగించవచ్చు.
ఉదాహరణ
పబ్లిక్ యాక్సెస్ మాడిఫైయర్ తరగతిని ప్రకటించడానికి ఉపయోగించబడుతుంది మరియు ప్రోగ్రామ్‌లోని ఇతర ఫంక్షన్ల ద్వారా దాని డేటా సభ్యులు యాక్సెస్ చేయబడతారు.
#include
#
#include
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
తరగతి త్రిభుజం
{
ప్రజా :
తేలుతుంది x , మరియు , తో ;
శూన్యం ఇన్పుట్ ( )
{
కోట్ << 'త్రిభుజం వైపు xని నమోదు చేయండి:-' ;
ఆహారపు >> x ;
కోట్ << 'త్రిభుజం వైపు yని నమోదు చేయండి:-' ;
ఆహారపు >> మరియు ;
కోట్ << 'త్రిభుజం వైపు z నమోదు చేయండి:-' ;
ఆహారపు >> తో ;
}
శూన్యం ప్రాంతం ( )
{
తేలుతుంది లు = ( x + మరియు + తో ) / 2 ;
తేలుతుంది ప్రాంతం = చ ( లు * ( లు - x ) * ( లు - మరియు ) * ( లు - తో ) ) ;
కోట్ << ' \n త్రిభుజం ప్రాంతం =' << ప్రాంతం ;
}
} ;
int ప్రధాన ( )
{
త్రిభుజం t1 ;
t1. ఇన్పుట్ ( ) ;
t1. ప్రాంతం ( ) ;
తిరిగి 0 ;
}
ట్రయాంగిల్ క్లాస్‌గా నిర్వచించబడింది మరియు దాని పారామితులు పబ్లిక్ కీవర్డ్‌లో ఉన్నాయి. పబ్లిక్ మాడిఫైయర్ యొక్క డేటా సభ్యులను యాక్సెస్ చేయడం ద్వారా త్రిభుజం యొక్క వైశాల్యం ఈ తరగతి వెలుపల లెక్కించబడుతుంది.
త్రిభుజం యొక్క మూడు భుజాలు వినియోగదారుచే ఇన్పుట్ చేయబడతాయి మరియు త్రిభుజం యొక్క వైశాల్యం 13.4164 అనే ప్రామాణిక సూత్రాన్ని ఉపయోగించి తరగతి వెలుపల ఉన్న విలువలను యాక్సెస్ చేయడం ద్వారా లెక్కించబడుతుంది.
C++లో ప్రైవేట్ యాక్సెస్ మాడిఫైయర్
ప్రైవేట్ కీవర్డ్ కింద ప్రకటించిన తరగతి సభ్యులందరూ ప్రోగ్రామ్‌లోని తరగతి వెలుపల ఏ ఫంక్షన్‌కు అందుబాటులో ఉండరు. ఈ ప్రైవేట్ సభ్యులను ఒకే తరగతిలోని ప్రత్యక్ష సభ్యులు మాత్రమే చదవగలరు. అయితే, స్నేహితుని విధులు మరియు తరగతులు కూడా డేటాను యాక్సెస్ చేయగలవు.
ఉదాహరణ
పబ్లిక్ మరియు ప్రైవేట్ అనే రెండు తరగతులు ప్రకటించబడ్డాయి మరియు ప్రోగ్రామ్ యొక్క రిటర్న్ విలువ త్రిభుజం యొక్క ప్రాంతంగా ఉండాలి.
#include#
#include
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
తరగతి త్రిభుజం
{
ప్రైవేట్ :
తేలుతుంది x , మరియు , తో ;
ప్రజా :
శూన్యం ఇన్పుట్ ( )
{
కోట్ << 'త్రిభుజం వైపు xని నమోదు చేయండి:-' ;
ఆహారపు >> x ;
కోట్ << 'త్రిభుజం వైపు yని నమోదు చేయండి:-' ;
ఆహారపు >> మరియు ;
కోట్ << 'త్రిభుజం వైపు z నమోదు చేయండి:-' ;
ఆహారపు >> తో ;
}
శూన్యం ప్రాంతం ( )
{
తేలుతుంది లు = ( x + మరియు + తో ) / 2 ;
తేలుతుంది ప్రాంతం = చ ( లు * ( లు - x ) * ( లు - మరియు ) * ( లు - తో ) ) ;
కోట్ << ' \n త్రిభుజం ప్రాంతం =' << ప్రాంతం ;
}
} ;
int ప్రధాన ( )
{
త్రిభుజం t1 ;
t1. ఇన్పుట్ ( ) ;
t1. ప్రాంతం ( ) ;
తిరిగి 0 ;
}
మెయిన్(), ఆబ్జెక్ట్ t1 ప్రైవేట్ క్లాస్ వేరియబుల్ ఫ్లోట్ x, y మరియు z లను నేరుగా యాక్సెస్ చేయదు, కాబట్టి ఇది పబ్లిక్ ఫంక్షన్ ఇన్పుట్() ద్వారా మాత్రమే పరోక్షంగా మార్చబడుతుంది, ఎందుకంటే ఈ ఫంక్షన్ x, y మరియు z విలువలను పొందుతుంది.
పబ్లిక్ క్లాస్‌ని ఉపయోగించి తారుమారు చేయడం ద్వారా ప్రైవేట్ తరగతిని యాక్సెస్ చేయడం ద్వారా త్రిభుజం యొక్క వైశాల్యం పొందబడుతుంది. x, y మరియు z విలువలు పబ్లిక్ క్లాస్‌లో ప్రకటించబడకపోతే, అవి లెక్కల కోసం మెయిన్()లో యాక్సెస్ చేయబడవు.
C++లో రక్షిత యాక్సెస్ మాడిఫైయర్
రక్షిత కీవర్డ్‌లోని సభ్యులు మరియు ఫంక్షన్‌లు రక్షించబడతాయి, అవి తరగతి మరియు ఉత్పన్నమైన తరగతిలో మాత్రమే యాక్సెస్ చేయబడతాయి. మిగిలిన తరగతులు వారి డేటాను యాక్సెస్ చేయలేరు. వారు అత్యంత రక్షించబడ్డారు.
ఉదాహరణ
రక్షిత కీవర్డ్ క్రింద ఉన్న రక్షిత డేటా తరగతి లోపల మరియు ఉత్పన్నమైన తరగతి అయిన తరగతి ద్వారా మాత్రమే చదవబడుతుంది. ఈ ఉదాహరణ రక్షిత యాక్సెస్ మాడిఫైయర్ యొక్క ఆచరణాత్మక ప్రదర్శన.
#include#
#include
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
//తల్లిదండ్రుల తరగతి
తరగతి త్రిభుజం
{
రక్షించబడింది :
తేలుతుంది x , మరియు , తో ;
} ;
//పిల్లల తరగతి
తరగతి ట్రయాంగిల్ చైల్డ్ : పబ్లిక్ ట్రయాంగిల్ {
ప్రజా :
శూన్యం ఇన్పుట్ ( )
{
కోట్ << 'త్రిభుజం x వైపు నమోదు చేయండి:-' ;
ఆహారపు >> x ;
కోట్ << 'త్రిభుజం వైపు yని నమోదు చేయండి:-' ;
ఆహారపు >> మరియు ;
కోట్ << 'త్రిభుజం వైపు z నమోదు చేయండి:-' ;
ఆహారపు >> తో ;
}
శూన్యం ప్రాంతం ( )
{
తేలుతుంది లు = ( x + మరియు + తో ) / 2 ;
తేలుతుంది ప్రాంతం = చ ( లు * ( లు - x ) * ( లు - మరియు ) * ( లు - తో ) ) ;
కోట్ << ' \n త్రిభుజం ప్రాంతం =' << ప్రాంతం ;
}
} ;
int ప్రధాన ( )
{
ట్రయాంగిల్ చైల్డ్ ;
పిల్లవాడు. ఇన్పుట్ ( ) ;
పిల్లవాడు. ప్రాంతం ( ) ;
తిరిగి 0 ;
}
ట్రయాంగిల్ చైల్డ్ అనేది క్లాస్ ట్రయాంగిల్ నుండి ఉద్భవించిన వారసత్వ తరగతి. వేరియబుల్స్ x, y మరియు z ట్రయాంగిల్‌లో రక్షిత కీవర్డ్‌తో డిక్లేర్ చేయబడతాయి. దీనర్థం ఈ వేరియబుల్స్ రక్షించబడ్డాయి, అయితే ట్రయాంగిల్ దాని పేరెంట్ క్లాస్ అయినందున ట్రయాంగిల్ చైల్డ్ ద్వారా యాక్సెస్ చేయవచ్చు. వేరియబుల్స్ విలువలు ట్రయాంగిల్ క్లాస్‌లో డిక్లేర్ చేయబడినప్పటికీ ట్రయాంగిల్ చైల్డ్‌లో కేటాయించబడ్డాయి.
చైల్డ్ క్లాస్ ద్వారా వేరియబుల్స్ యాక్సెస్ చేయబడతాయి, ఆపై త్రిభుజం యొక్క వైశాల్యం లెక్కించబడుతుంది.
ముగింపు
డేటా దాచడం అనేది బయటి నుండి తరగతి డేటాకు అవాంఛిత ప్రాప్యతను నిరోధిస్తుంది. ప్రోగ్రామ్‌లోని డేటా యొక్క ప్రాప్యత మరియు దృశ్యమానతను నిర్వహించడానికి యాక్సెస్ మాడిఫైయర్‌లు ఉపయోగించబడతాయి. డేటాను దాచడానికి ప్రైవేట్, రక్షిత మరియు పబ్లిక్ యాక్సెస్ మాడిఫైయర్‌లు ఉపయోగించబడతాయి. పబ్లిక్ కీవర్డ్ కింద ఉన్న డేటాను తరగతి వెలుపలి నుండి కూడా ఫంక్షన్ల ద్వారా చదవవచ్చు. ప్రైవేట్‌గా ప్రకటించబడిన డేటా తరగతి లోపల మాత్రమే చదవబడుతుంది, అయితే రక్షిత డేటాను తల్లిదండ్రులు మరియు పిల్లల తరగతి కూడా యాక్సెస్ చేయవచ్చు.