నిల్వ తరగతి సి ++ వేరియబుల్ / ఫంక్షన్ల యొక్క జీవితకాలం & దృశ్యమానతను నిర్వచిస్తుంది. జీవితకాలం అంటే వేరియబుల్ చురుకుగా ఉండే వ్యవధి & దృశ్యమానత అనేది ప్రోగ్రామ్ యొక్క వివిధ మాడ్యూళ్ళ నుండి వేరియబుల్ యొక్క ప్రాప్యత. ఇది ప్రోగ్రామ్ యొక్క రన్టైమ్ సమయంలో ఒక నిర్దిష్ట వేరియబుల్ ఉనికిని తెలుసుకోవడానికి సహాయపడుతుంది. ఈ నిల్వ తరగతుల బ్లాగులో, మేము C ++ లో ఉపయోగించే వివిధ నిల్వ తరగతులను పరిశీలిస్తాము.
ప్రారంభిద్దాం.
సి ++ లో నిల్వ తరగతి అంటే ఏమిటి?
C ++ లోని ప్రతి వేరియబుల్‌లో డేటా రకం మరియు నిల్వ తరగతి ఉంటుంది. డేటా రకం ఇంటెంట్, ఫ్లోట్, చార్ వంటి వేరియబుల్‌లో నిల్వ చేయగల డేటా రకాన్ని నిర్దేశిస్తుంది. నిల్వ తరగతి వేరియబుల్ యొక్క రెండు వేర్వేరు లక్షణాలను నియంత్రిస్తుంది: జీవితకాలం మరియు స్కోప్.
ప్రతి వేరియబుల్‌కు డేటా రకం ఉందని మీరు చూస్తారు, కాని మీరు ఇప్పటివరకు వేరియబుల్‌కు జతచేయబడిన ఏ నిల్వ తరగతిని చూడకపోవచ్చు. వాస్తవానికి, మీరు నిల్వ తరగతిని నిర్వచించకపోతే, కంపైలర్ స్వయంచాలకంగా దానికి డిఫాల్ట్ నిల్వ తరగతిని కేటాయిస్తుంది. వేరియబుల్ యొక్క నిల్వ తరగతి మెమరీలో వేరియబుల్ యొక్క నిల్వ స్థానం, డిఫాల్ట్ ప్రారంభ విలువ, వేరియబుల్ యొక్క పరిధి మరియు దాని జీవితకాలం గురించి సమాచారాన్ని ఇస్తుంది.
నిల్వ తరగతి రకాలు
సి ++ ప్రోగ్రామ్‌లో ఐదు నిల్వ తరగతులు ఉన్నాయి:
- దానంతట అదే
- నమోదు
- స్టాటిక్
- బాహ్య
- మార్చగల
ప్రతి నిల్వ తరగతులను వివరంగా చర్చిద్దాం.
ఆటో నిల్వ తరగతి
ఆటోమేటిక్ (ఆటో) స్టోరేజ్ క్లాస్ అన్ని స్థానిక వేరియబుల్స్ కోసం డిఫాల్ట్ స్టోరేజ్ క్లాస్, ఇవి ఫంక్షన్ లేదా బ్లాక్ లోపల ప్రకటించబడతాయి. రాసేటప్పుడు ఆటో కీవర్డ్ చాలా అరుదుగా ఉపయోగించబడుతుంది సి ++ ప్రోగ్రామ్ .
ఆటో వేరియబుల్స్ యొక్క పరిధి అవి ప్రకటించబడిన ఫంక్షన్ లేదా బ్లాక్‌లో ఉన్నాయి & ఆ ఫంక్షన్ లేదా బ్లాక్ వెలుపల దీన్ని యాక్సెస్ చేయలేరు. ఆటో వేరియబుల్ ప్రకటించిన పేరెంట్ బ్లాక్ / ఫంక్షన్‌లోని నెస్టెడ్ బ్లాక్‌లలో కూడా దీన్ని యాక్సెస్ చేయవచ్చు.
పాయింటర్ వేరియబుల్ ఉపయోగించి మీరు వారి పరిధికి వెలుపల ఆటో వేరియబుల్స్ యాక్సెస్ చేయవచ్చు. మీరు వేరియబుల్స్ నివసిస్తున్న అదే మెమరీ స్థానానికి సూచించాలి.
దీని జీవితకాలం ఫంక్షన్ యొక్క జీవితకాలం వలె ఉంటుంది. ఒక ఫంక్షన్ యొక్క అమలు పూర్తయిన తర్వాత, వేరియబుల్ నాశనం అవుతుంది.
అప్రమేయంగా, డిక్లరేషన్ సమయంలో చెత్త విలువ వారికి కేటాయించబడుతుంది.
సింటాక్స్:
డేటాటైప్ var_name1 [= విలువ]
లేదా
ఆటో డేటాటైప్ var_name1 [= విలువ]
పై ఉదాహరణలో, ఒకే వేరియబుల్‌తో రెండు వేరియబుల్స్ నిర్వచించబడతాయి. ఆటో స్థానిక వేరియబుల్స్‌ను నిర్వచించడానికి మాత్రమే ఉపయోగించబడుతుంది, అనగా ఫంక్షన్లలో.
నిల్వ తరగతి నమోదు
పేరు సూచించినట్లుగా, రిజిస్టర్ నిల్వ తరగతి రిజిస్టర్ వేరియబుల్స్ డిక్లేర్ చేయడానికి ఉపయోగించబడుతుంది. ఉచిత రిజిస్టర్ అందుబాటులో ఉంటే కంపైలర్ ఈ వేరియబుల్స్ ను మైక్రోప్రాసెసర్ యొక్క రిజిస్టర్లో నిల్వ చేయడానికి ప్రయత్నిస్తుంది తప్ప, రిజిస్టర్ వేరియబుల్ యొక్క అన్ని ఫంక్షనలైజ్ ఆటో వేరియబుల్ వలె ఉంటుంది. ఉచిత రిజిస్టర్ అందుబాటులో లేకపోతే, ఇవి మెమరీలో మాత్రమే నిల్వ చేయబడతాయి.
అందువల్ల, రిజిస్టర్ వేరియబుల్స్ పై ఆపరేషన్లు ప్రోగ్రామ్ యొక్క రన్టైమ్ సమయంలో మెమరీలో నిల్వ చేయబడిన ఇతర వేరియబుల్స్ కంటే చాలా వేగంగా ఉంటాయి.
సాధారణంగా, ప్రోగ్రామ్‌లో తరచుగా ప్రాప్యత చేయవలసిన కొన్ని వేరియబుల్స్ ప్రోగ్రామ్ యొక్క నడుస్తున్న సమయాన్ని మెరుగుపరచడానికి రిజిస్టర్ స్టోరేజ్ క్లాస్‌లో ప్రకటించబడతాయి. పాయింటర్లను ఉపయోగించి రిజిస్టర్ వేరియబుల్ యొక్క చిరునామా పొందలేము.
వేరియబుల్ యొక్క గరిష్ట పరిమాణం రిజిస్టర్ పరిమాణానికి సమానం (అనగా సుమారు ఒక పదం). మెమరీ స్థానం లేనందున దీనికి వర్తించే ‘&’ ఆపరేటర్ ఉండకూడదు.
సింటాక్స్:
డేటాటైప్ var_name1 ను నమోదు చేయండి [= విలువ]
ఉదాహరణ:
జావాలో గరిష్ట కుప్ప అమలు
{int pi ని నమోదు చేయండి}‘రిజిస్టర్’ ని నిర్వచించడం అంటే వేరియబుల్ రిజిస్టర్లో నిల్వ చేయబడుతుందని కాదు. ఇది హార్డ్‌వేర్ మరియు అమలు పరిమితులను బట్టి రిజిస్టర్లో నిల్వ చేయబడుతుంది.
రిజిస్టర్ & ఆటో నిల్వ తరగతుల ఉదాహరణను చూద్దాం.
ఉదాహరణ:
# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి // బాహ్యంగా చేయవలసిన వేరియబుల్‌ను ప్రకటించడం // ఒక అంతర్గత విలువను x int x శూన్యమైన ఆటోస్టోరేజ్‌క్లాస్ () {printf ('n ఆటో క్లాస్‌న్‌ను ప్రదర్శించడం') // ఆటో వేరియబుల్‌గా ప్రకటించడం (కేవలం // 'int a = 32' రాయడం కూడా పనిచేస్తుంది) int num = 32 // ఆటో వేరియబుల్ 'a' printf ('వేరియబుల్ యొక్క విలువ' num '' 'ఆటోగా ప్రకటించబడింది:% dn', num) printf ( '--------------------------------')} శూన్యమైన రిజిస్టర్‌స్టోరేజ్‌క్లాస్ () {printf ('n రిజిస్టర్ క్లాస్‌ని ప్రదర్శిస్తోంది') / / రిజిస్టర్ వేరియబుల్ రిజిస్టర్ చార్ c = 'G' // రిజిస్టర్ వేరియబుల్ 'b' printf ('వేరియబుల్' సి '' 'రిజిస్టర్‌గా ప్రకటించబడింది:% dn', సి) printf ('---- ---------------------------- ')} int main () {// ఆటో స్టోరేజ్ క్లాస్ ఆటోస్టొరేజ్క్లాస్ () ప్రదర్శించడానికి // ప్రదర్శించడానికి రిజిస్టర్ స్టోరేజ్ క్లాస్ రిజిస్టర్ స్టోరేజ్క్లాస్ () రిటర్న్ 0}అవుట్పుట్:
స్టాటిక్ స్టోరేజ్ క్లాస్
స్టాటిక్ స్టోరేజ్ క్లాస్ డిక్లేర్ చేయడానికి ఉపయోగించబడుతుంది స్టాటిక్ వేరియబుల్స్ . స్టాటిక్ వేరియబుల్స్ వాటి పరిధిని కోల్పోయినప్పుడు కూడా వాటి విలువను (అనగా చివరి విలువ) సంరక్షిస్తాయి. స్టాటిక్ వేరియబుల్స్ ఒకసారి మాత్రమే ప్రారంభించబడతాయి &కార్యక్రమం ముగిసే వరకు ఉనికిలో ఉంది.
మెమరీ స్టాటిక్ వేరియబుల్‌కు ఒక్కసారి మాత్రమే కేటాయించబడుతుంది & కొత్త మెమరీ కేటాయించబడదు ఎందుకంటే అవి తిరిగి ప్రకటించబడవు. గ్లోబల్ స్టాటిక్ వేరియబుల్స్ ప్రోగ్రామ్‌లో ఎక్కడైనా యాక్సెస్ చేయవచ్చు. అప్రమేయంగా, వాటిని కంపైలర్ చేత విలువ 0 కేటాయించబడుతుంది.
ఒక కన్స్ట్రక్టర్ ప్రైవేట్ కావచ్చు
C ++ లో, క్లాస్ డేటా సభ్యునిపై స్టాటిక్ ఉపయోగించినప్పుడు, ఆ సభ్యుని యొక్క ఒక కాపీని మాత్రమే దాని తరగతిలోని అన్ని వస్తువులు పంచుకుంటాయి.
సింటాక్స్:
స్టాటిక్ డేటాటైప్ var_name1 [= విలువ]
ఉదాహరణ:
# శూన్య ఫంక్షన్ (శూన్యమైన) స్టాటిక్ పూర్ణాంకం సి = 5 // గ్లోబల్ స్టాటిక్ వేరియబుల్ మెయిన్ () {అయితే (సి--) {ఫంక్షన్ ()} రిటర్న్ 0} శూన్య ఫంక్షన్ (శూన్యమైనది) కౌట్<< 'cnt is ' << cnt std::cout << ' and c is ' << c << std::endl } అవుట్పుట్:
బాహ్య నిల్వ తరగతి
బహుళ ఫైళ్ళలో వేరియబుల్స్ పంచుకోవలసి వచ్చినప్పుడు బాహ్య నిల్వ తరగతి అవసరం. బాహ్య వేరియబుల్స్ గ్లోబల్ స్కోప్ కలిగివుంటాయి మరియు ఈ వేరియబుల్స్ అవి ప్రకటించిన ఫైల్ వెలుపల కనిపిస్తాయి. బాహ్య వేరియబుల్ అన్ని ప్రోగ్రామ్‌లకు కనిపిస్తుంది. రెండు లేదా అంతకంటే ఎక్కువ ఫైళ్లు ఒకే వేరియబుల్ లేదా ఫంక్షన్‌ను పంచుకుంటే ఇది ఉపయోగించబడుతుంది.
బాహ్య వేరియబుల్స్ యొక్క జీవితకాలం అది ప్రకటించిన ప్రోగ్రామ్ ముగిసినంత కాలం ఉంటుంది. ఏదైనా ఫంక్షన్ / బ్లాక్‌లో డిక్లరేషన్ / డెఫినిషన్‌కు ముందు ‘బాహ్య’ కీవర్డ్‌ని ఉంచడం ద్వారా సాధారణ గ్లోబల్ వేరియబుల్‌ను బాహ్యంగా చేయవచ్చు.
మీరు ‘బాహ్య’ ఉపయోగించినప్పుడు వేరియబుల్ ప్రారంభించబడదు ఎందుకంటే ఇది అంతకుముందు నిర్వచించిన నిల్వ ప్రదేశంలో వేరియబుల్ పేరును సూచిస్తుంది.
సింటాక్స్
బాహ్య డేటా రకం var_name1
ఉదాహరణ
# int cnt extern void write_extern () main () {cnt = 5 write_extern ()}రెండవ ఫైల్: support.cpp
# బాహ్య int cnt void write_extern (void) {std :: cout<< 'Count is ' << cnt << std::endl } ఇక్కడ, మరొక ఫైల్‌లో cnt ని ప్రకటించడానికి బాహ్య కీవర్డ్ ఉపయోగించబడుతోంది. ఇప్పుడు ఈ రెండు ఫైళ్ళను ఈ క్రింది విధంగా కంపైల్ చేయండి & మైనస్
$ g ++ main.cpp support.cpp -o వ్రాయండి
ఇది రైట్ ఎక్జిక్యూటబుల్ ప్రోగ్రామ్‌ను ఉత్పత్తి చేస్తుంది, వ్రాతను అమలు చేయడానికి ప్రయత్నించండి మరియు ఫలితాన్ని ఈ క్రింది విధంగా & మైనస్‌గా తనిఖీ చేయండి
$. / వ్రాయండి
5
C ++ లో నిల్వ తరగతితో ముందుకు వెళుతున్నప్పుడు, చివరిదాన్ని చూద్దాం, అనగా మ్యూటబుల్ స్టోరేజ్ క్లాస్.
మ్యూటబుల్ స్టోరేజ్ క్లాస్
మ్యూటబుల్ స్పెసిఫైయర్ క్లాస్ ఆబ్జెక్ట్‌లకు మాత్రమే వర్తిస్తుంది, ఇది ఒక వస్తువు యొక్క సభ్యుడు కాన్స్ట్ మెంబర్ ఫంక్షన్‌ను భర్తీ చేయడానికి అనుమతిస్తుంది. అంటే, పరివర్తన చెందిన సభ్యుడిని కాన్స్ట్ మెంబర్ ఫంక్షన్ ద్వారా సవరించవచ్చు.
చివరికి, విభిన్న నిల్వ తరగతుల మధ్య తేడాలను అర్థం చేసుకోవడానికి పోలిక పట్టికను చూద్దాం.
నిల్వ తరగతి | కీవర్డ్ | జీవితకాలం | దృశ్యమానత | ప్రారంభ విలువ |
స్వయంచాలక | దానంతట అదే | ఫంక్షన్ బ్లాక్ | స్థానిక | చెత్త |
బాహ్య | బాహ్య | మొత్తం కార్యక్రమం | ప్రపంచ | సున్నా |
స్టాటిక్ | స్టాటిక్ | మొత్తం కార్యక్రమం | స్థానిక | సున్నా |
నమోదు చేయండి | నమోదు | ఫంక్షన్ బ్లాక్ | స్థానిక | చెత్త జావా కాస్ట్ డబుల్ టు పూర్ణాంకానికి |
మ్యూటబుల్ | మార్చగల | తరగతి | స్థానిక | చెత్త |
ఇప్పుడు పై C ++ ప్రోగ్రామ్‌ల ద్వారా వెళ్ళిన తరువాత, C ++ లోని విభిన్న నిల్వ తరగతులు ఏమిటి మరియు వాటిని ఎలా అమలు చేయాలో మీరు అర్థం చేసుకుంటారు. ఈ బ్లాగ్ మీకు సమాచారం మరియు అదనపు విలువను ఇస్తుందని నేను ఆశిస్తున్నాను.
ఈ విధంగా మేము ‘సి ++ లోని నిల్వ తరగతులు’ పై ఈ వ్యాసం చివరకి వచ్చాము.
మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.