ఆప్టిమైజేషన్ ప్రారంభించబడినప్పుడు, కోడ్ ఆశించిన విధంగా పని చేయకపోవడాన్ని కలిగి ఉండే అస్థిరమైన క్వాలిఫైయర్‌ను మేము ఉపయోగించకపోతే సమస్యలు సంభవించవచ్చు. అంతరాయాలను ఉపయోగించినప్పుడు మరియు ప్రారంభించబడినప్పుడు, కోడ్ ప్రణాళికాబద్ధంగా పనిచేయదు. పవర్ ఆన్‌లో ఉన్నప్పుడు మాత్రమే డేటా అస్థిర నిల్వలో ఉంచబడుతుంది. సరఫరా తీసివేయబడినప్పుడు, డేటా నష్టం జరుగుతుంది.
అయితే, నాన్-వోలటైల్ స్టోరేజ్ కరెంటు పోయినప్పటికీ డేటాను ఉంచుతుంది. ప్రక్రియ సమాచారం అస్థిర నిల్వలో క్లుప్తంగా నిల్వ చేయబడుతుంది, ఎందుకంటే ఇది అస్థిర నిల్వ కంటే చాలా వేగంగా ఉంటుంది. అస్థిర నిల్వకు విరుద్ధంగా, సున్నితమైన డేటాను రక్షించడానికి అస్థిర నిల్వ మరింత అనుకూలంగా ఉంటుంది. ఎందుకంటే విద్యుత్ సరఫరా స్విచ్ ఆఫ్ అయినప్పుడు డేటా అందుబాటులో ఉండదు. అస్థిర నిల్వ చాలా ఖర్చవుతుంది ఎందుకంటే కంప్యూటర్ సిస్టమ్‌లు దానిలో కొన్ని MB నుండి కొన్ని GB వరకు మాత్రమే ఉంచగలవు.
C++లో అస్థిర క్వాలిఫైయర్ యొక్క లక్షణాలు
C++ అస్థిర క్వాలిఫైయర్ అంటే ఇక్కడ ప్రదర్శించబడుతుంది. మేము వేరియబుల్‌ని ప్రకటించినప్పుడు, క్వాలిఫైయర్ “అస్థిర” వర్తించబడుతుంది. విలువ ఏ సమయంలోనైనా మారవచ్చు అని కంపైలర్‌కు ఇది రిమైండర్‌గా పనిచేస్తుంది. అస్థిరమైనవి దిగువ జాబితా చేయబడిన కొన్ని లక్షణాలను కలిగి ఉంటాయి.
• అస్థిర కీవర్డ్‌తో మెమరీ అసైన్‌మెంట్ మార్చబడదు.
• రిజిస్టర్ యొక్క వేరియబుల్స్ కాష్ చేయబడవు.
• అసైన్‌మెంట్ పరంగా, విలువను మార్చడం సాధ్యం కాదు.
C++లో వోలటైల్ క్వాలిఫైయర్‌ని ఉపయోగించడం
1. మీ కోడ్ వేరియబుల్ విలువను సవరించనప్పటికీ, అది అలా చేయవచ్చు. ఫలితంగా, కంపైలర్ వేరియబుల్ యొక్క స్థితిని తనిఖీ చేసిన ప్రతిసారీ, ఇది దాని నుండి చదివిన ఇటీవలి విలువ లేదా నిల్వ చేయబడిన అత్యంత ఇటీవలి విలువతో సమానమని భావించలేము; బదులుగా, అది వేరియబుల్ విలువను మరోసారి పొందాలి.
2. కంపైలర్ విలువను నిల్వ చేసే చర్యను తొలగించాల్సిన అవసరం లేదు, ఎందుకంటే ఇది బయటి నుండి చూడగలిగే 'సైడ్ ఎఫెక్ట్' మరియు ఒక విలువ అస్థిర వేరియబుల్‌లో సేవ్ చేయబడినప్పుడు సంభవిస్తుంది. ఉదాహరణకు, ఒక వరుసలో రెండు విలువలను ఉంచినట్లయితే, కంపైలర్ తప్పనిసరిగా రెండుసార్లు విలువను ఉంచాలి.
C++లో వోలటైల్ క్వాలిఫైయర్ యొక్క సింటాక్స్
# అస్థిర డేటా_రకం వేరియబుల్_పేరుడిక్లరేషన్లో అస్థిర కీవర్డ్ తప్పనిసరిగా ఉపయోగించబడాలి మరియు డేటా రకం అనేది డబుల్, ఫ్లోట్ లేదా పూర్ణాంకాలతో సహా ఏదైనా డేటా రకాన్ని సూచిస్తుంది. చివరగా, మేము వేరియబుల్ కోసం ఒక పేరును ఎంచుకుంటాము. రెండు డిక్లరేషన్‌లు చెల్లుబాటు అయ్యేవి కనుక మనం ఈ పద్ధతుల్లో దేనినైనా ఉపయోగించి అస్థిర చరరాశిని నిర్వచించవచ్చు.
ఉదాహరణ: C++లో ఇతర థ్రెడ్‌లు లేదా బయటి చర్యల ద్వారా సవరించగలిగే వస్తువులను గుర్తించడానికి అస్థిర క్వాలిఫైయర్ ఉపయోగించబడుతుంది.
ఆబ్జెక్ట్ బాహ్య సిగ్నల్ లేదా అంతరాయంగా పనిచేసే విధానం ద్వారా మార్చబడినట్లయితే, ఈ సమయంలో కాష్ చేయబడిన స్థితి ఇకపై తగినది కాదు కాబట్టి మార్చబడిన విలువ RAM నుండి తిరిగి పొందవలసి ఉంటుంది. ఫలితంగా, కంపైలర్ అస్థిర వస్తువులకు తగిన విధంగా యాక్సెస్‌ను నిర్వహిస్తుంది.
##
#<థ్రెడ్> చేర్చండి
std ఉపయోగించి :: కోట్ ;
std ఉపయోగించి :: endl ;
std ఉపయోగించి :: cerr ;
std ఉపయోగించి :: ఆహారపు ;
త్వరగా ఆవిరి అయ్యెడు int సెకన్లు = 0 ;
శూన్యం ఐదు సెకన్ల ఆలస్యం ( ) {
అయితే ( సెకన్లు < 3 ) {
నిద్రపోవడం ( 200000 ) ;
cerr << 'వెయిటింగ్...' << endl ;
}
}
శూన్యం ఇంక్రిమెంట్ సెకన్లు ( ) {
కోసం ( int i = 0 ; i < 5 ; ++ i ) {
నిద్ర ( 1 ) ;
cerr << 'పెరిగిన' << endl ;
సెకన్లు = సెకన్లు + 1 ;
}
}
int ప్రధాన ( ) {
నిర్మాణం సమయ ప్రారంభం { } ;
నిర్మాణం సమయ ముగింపు { } ;
std :: దారం థ్రెడ్1 ;
థ్రెడ్1 = std :: దారం ( ఇంక్రిమెంట్ సెకన్లు ) ;
ఐదు సెకన్ల ఆలస్యం ( ) ;
థ్రెడ్1. చేరండి ( ) ;
తిరిగి EXIT_SUCCESS ;
}
సంభావ్య దృష్టాంతాన్ని వివరించడానికి, మేము 'int' డేటా రకం యొక్క సెకన్లుగా డిక్లేర్ చేయబడిన వేరియబుల్‌ను కలిగి ఉన్న అస్థిర కీవర్డ్‌ని ఉపయోగించాము మరియు దానికి 0 విలువను కేటాయించాము. అప్పుడు, మేము రెండు ఫంక్షన్‌లను నిర్మిస్తాము: ఒకటి గ్లోబల్ అస్థిర పూర్ణాంక వేరియబుల్‌ని మార్చే “డిలేఫైవ్‌సెకండ్స్” మరియు మరొకటి లూప్ లోపల అదే మూల్యాంకనాన్ని చేసే “ఇంక్రిమెంట్ సెకండ్స్”. ఈ ఉదాహరణ సెకనులు 3 కంటే తక్కువగా ఉన్నప్పుడు లూప్‌ని సెకన్లలో లూప్ చేయడానికి అనుమతిస్తుందని గమనించాలి.
పరిస్థితి కలిసినప్పుడు, అయితే అయితే బ్లాక్ అమలు చేయబడుతుంది. అయితే బ్లాక్ లోపల, మేము “వెయిటింగ్” స్టేట్‌మెంట్‌ను ప్రింట్ చేసే అన్‌స్లీప్ పద్ధతిని ప్రారంభించాము. 'IncrementSceonds' ఫంక్షన్‌లో లూప్ ఉంది. పునరావృతం చేసిన తర్వాత, నిద్ర పద్ధతి అమలు చేయబడుతుంది, ఇది 'ఇంక్రిమెంట్' స్టేట్‌మెంట్‌ను ప్రింట్ చేస్తుంది మరియు 'సెకన్ల' వేరియబుల్‌ను పెంచుతుంది. 'IncrementSeconds' ఫంక్షన్ యొక్క ప్రారంభ అమలు ప్రధాన ఫంక్షన్ ద్వారా సృష్టించబడిన ప్రత్యేక థ్రెడ్ ద్వారా చేయబడుతుంది. 'DelayFiveSeconds' పద్ధతిని ప్రధాన థ్రెడ్ ద్వారా పిలుస్తారు, సెకనుల వేరియబుల్ 5 విలువ కంటే ఎక్కువగా కదలకపోతే అది ముగియని లూప్‌ను నమోదు చేస్తుంది.
సెకనుల వేరియబుల్ విలువ మారిందని ప్రధాన థ్రెడ్ గమనించిన వెంటనే, అది పద్ధతి నుండి తిరిగి వస్తుంది ఎందుకంటే మరొక థ్రెడ్ ఇప్పటికే ఏకకాలంలో దాన్ని పెంచడం ప్రారంభించింది.
C++లో థ్రెడ్ కోడ్‌ని అమలు చేయడానికి, మనం “g++ -pthread –o filename filename.cc” ఆదేశాన్ని ఉపయోగించాలి. మీరు కమాండ్‌లో “-pthread”ని అమలు చేయకపోతే, కంపైలర్ ద్వారా మినహాయింపు విసిరే అవకాశం ఉంది. ఫలితంగా, అస్థిర వస్తువు బయటి శక్తి ద్వారా మార్చబడే వరకు వేచి ఉండే షరతులతో కూడిన నిరీక్షణ ఫంక్షన్‌ని మేము సమర్థవంతంగా చేసాము. అప్‌డేట్ కోడ్ బ్లాక్ వేరే అనువాద విభాగం లేదా బాహ్య సిగ్నల్ చర్య నుండి రావచ్చని గుర్తుంచుకోవడం ముఖ్యం, అయినప్పటికీ అస్థిరమైన క్వాలిఫైయర్‌ని తీసివేసి, సాంప్రదాయిక గ్లోబల్ వేరియబుల్ ఉపయోగించినట్లయితే, ఈ కోడ్ ఇప్పటికీ అలాగే పని చేస్తుంది.
ముగింపు
ఇక్కడ, మేము సింటాక్స్, వినియోగం మరియు మంచి అవగాహన కోసం తగిన ఉదాహరణలతో పాటు C++లో అస్థిరత యొక్క స్థూలదృష్టిని పరిశీలిస్తాము. కంపైలర్ విలువను అంచనా వేయలేనందున, C ప్రోగ్రామింగ్‌లో అస్థిరత కీలకం. అస్థిరతను ఉపయోగించడం యొక్క ప్రాథమిక ప్రయోజనం ఏమిటంటే, వినియోగదారు దానిని సవరించమని అభ్యర్థించినప్పుడు లేదా అదే వేరియబుల్‌ని ఉపయోగించే ఇతర థ్రెడ్ సక్రియంగా ఉన్నప్పుడు దాని విలువ మారవచ్చు.