Constants and Inline Functions-accmUsQzNk0

 C ++  ప్రోగ్రామింగ్ మాడ్యూల్ 6 కు స్వాగతం.
 మొదటి ఐదు మాడ్యూల్స్లో మనము C ప్రోగ్రామింగ్ లాంగ్వేజ్(programming language), C స్టాండర్డ్ గ్రంథాలయం (standard library) మరియు C భాష యొక్క వివిధ నిర్మాణాలను పునఃపరిశీలించాము.+
 ప్రాధమిక ఇన్పుట్, అవుట్పుట్, అంకగణిత కార్యకలాపాలు, శ్రేణులు, తీగలను మరియు ముఖ్యంగా డేటా నిర్మాణాన్ని ఉపయోగించడానికి లూప్ రకం ఉదాహరణలతో ప్రారంభించి మేము అనేక ఉదాహరణలు తీసుకున్నాము., C ++ మరియు C ++ లైబ్రరీలో ప్రోగ్రామింగ్ ఎలా ఉంటుందో చూపించడానికి మేము నాలుగు ఉదాహరణలను తీసుకున్నాము లైబ్రరీని న్యాయంగా ఉపయోగించుకోండి.
 C ++ లో ప్రోగ్రామింగ్ వాస్తవానికి మరింత సమర్థవంతంగా మరియు తక్కువ లోపంతో చేయటం సులభం.
 ఈ మాడ్యూల్‌తో, మేము ఇప్పుడు C ++ ప్రోగ్రామింగ్ భాషలో వివిధ లక్షణాలను చర్చించడం ప్రారంభిస్తాము.
 తరువాతి కొన్ని మాడ్యూళ్ళలో, సి ++ లో ఉన్న ఆబ్జెక్ట్ ఓరియంటేషన్ యొక్క ప్రాథమిక నమూనాను ఉపయోగించని లక్షణాలు అయిన మెరుగైన సి ఫీచర్స్ అని పిలువబడే లక్షణాల సమితితో మేము ప్రత్యేకంగా వ్యవహరిస్తాము. హుహ్.
 కానీ ఇవి సి భాషకు విధానపరమైన పొడిగింపులు, ఇవి ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్‌ను సాధ్యం చేయడానికి అవసరమవుతాయి మరియు ఇవి సిలో ఉండగల మంచి లక్షణాలు. యాదృచ్ఛికంగా సి రూపకల్పన చేసినప్పుడు కూడా వారు ఆలోచించలేదు.
 మరింత ఆసక్తికరంగా, C ++ లో ప్రవేశపెట్టిన తర్వాత ఈ లక్షణాలలో కొన్ని ఉన్నాయి మరియు ఈ మాడ్యూల్‌లో ఆ లక్షణాలలో ఒకదాన్ని మేము చర్చించబోతున్నాము.
 ఈ లక్షణాలలో కొన్ని అప్పటి నుండి సి ప్రోగ్రామింగ్‌లోకి తీసుకోబడ్డాయి మరియు ఇప్పుడు C99 ప్రమాణంలో అందుబాటులో ఉన్నాయి.
 మేము ఈ మాడ్యూల్ 6 ను ప్రారంభిస్తాము, ఇక్కడ మేము స్థిరాంకాలు మరియు ఇన్లైన్ ఫంక్షన్ల గురించి చర్చిస్తాము.
 అందువల్ల, మేము C ++ లో const ను అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము మరియు అదే భావనతో సరిగ్గా అదే భావన కాదు, కానీ అదే భావన C లో నిరంతరం కనిపిస్తుంది మరియు C + లో ఇన్లైన్ ఫంక్షన్లను వివరించడానికి ప్రయత్నిస్తాము. + మరియు దీనికి విరుద్ధంగా వాటిని మాక్రోలతో.
 కాబట్టి, ఇవి మేము చర్చించబోయే విషయాలు, మీరు దానిని స్క్రీన్ ఎడమ వైపున చూడగలరని మేము క్రమంగా వెల్లడిస్తాము.
 కాబట్టి సి లోని మానిఫెస్ట్ స్థిరాంకాలతో ప్రారంభిద్దాం.
 మేము # నిర్వచించును వ్రాస్తే అక్షర లేదా వ్యక్తీకరణను ఉపయోగించి స్థిరమైన విలువను లేదా స్థిర విలువను నిర్వచించగలమని మనందరికీ తెలుసు.
 ఒక పేరు తరువాత మరియు మేము నిర్వచించదలిచిన ప్రత్యేక వ్యక్తీకరణ.
 అందువల్ల, ఎడమ వైపున మనకు ఇక్కడ ఉన్నదానికి ఉదాహరణలు చూడవచ్చు; TWO ఒక నిర్వచించిన విలువ చూడండి.
 2. అదేవిధంగా, వ్యక్తీకరణ పరంగా నిర్వచించబడిన పైని ఎలా నిర్వచించాలో మేము చూపించాము.
 పై; అటాన్ (1.0) ఇది PI నుండి 4, కాబట్టి మీరు దానిని 4 తో గుణిస్తే మీరు పై విలువను పొందుతారు.
 ఒక వృత్తం యొక్క చుట్టుకొలతను లెక్కించడానికి మేము వాటిని ఇక్కడ వ్యక్తీకరణలో ఉపయోగిస్తాము.
 ఇది సి లో చాలా సాధారణంగా ఉపయోగించే ప్రోగ్రామ్ మరియు మీలో చాలామంది ఇంతకు ముందు వ్రాశారు.
 ఇప్పుడు, మేము ఈ కార్యక్రమాన్ని కొద్దిగా భిన్నంగా చూస్తాము, కుడి వైపు చూద్దాం.
 TWO వద్ద మేము ఇక్కడ కలిగి ఉన్న # నిర్వచించు చివరికి ఈ సమయంలో సి ప్రిప్రాసెసర్ ద్వారా భర్తీ చేయబడుతుంది.
 అందువల్ల, ప్రోగ్రామ్ సంకలనంలోకి వెళ్ళే ముందు ఈ పంక్తి తొలగించబడుతుంది మరియు TWO ఎక్కడ సంభవించినా, ఈ గుర్తు మొదట సంభవించింది, ఇక్కడ నేను గుర్తు ఉండాలి అని నిర్వచించే ముందు.
 కాబట్టి, ఈ పైలో మొత్తం వ్యక్తీకరణ ద్వారా భర్తీ చేయబడిందని మీరు చూడవచ్చు మరియు ఇది సి కంపైలర్ను కంపైల్ చేయడానికి వాస్తవానికి వెళ్ళే కోడ్.
 ఇది తెర వెనుక దృష్టాంతంలో ఉంది మరియు మీరు మీ కంపైలర్‌లో ప్రత్యేక ఎంపికను ఉంచకపోతే మేము సాధారణంగా దీన్ని చేయము.ఈ ప్రోగ్రామ్ యొక్క ఈ సంస్కరణను మీరు చూడలేరు, ఇక్కడ ఈ # నిర్వచనాలు మార్చబడ్డాయి
 # నిర్వచించు యొక్క ఉద్దేశ్యం ఏమిటంటే చిహ్నం మరియు వ్యక్తీకరణకు ఒకే పేరు ఇవ్వడం మరియు సి ప్రిప్రాసెసర్ ప్రత్యామ్నాయాన్ని చేయగలదు.
 మానిఫెస్ట్ స్థిరాంకం యొక్క దృష్టాంతం ఏమిటో మీరు అర్థం చేసుకోవడం మాత్రమే? కాబట్టి, ఫలితం ఏమిటి? ఫలితం ఏమిటంటే, నేను స్థిరంగా చికిత్స చేయాలనుకున్న విలువను ఉపయోగించాలని నేను నిజంగా కోరుకున్నాను, కాని నేను దాన్ని మళ్ళీ చూసి, వ్యాఖ్యలోని చివరి పంక్తిపై దృష్టి పెడితే నేను కనుగొన్నాను కాబట్టి, నేను దీన్ని ఉచితంగా ఉపయోగించాలనుకున్నాను స్థిరంగా మరియు ప్రక్రియలో కంపైలర్‌కు అవి TWO అని పిలువబడే వేరియబుల్ రూపంలో ఉన్నాయో లేదో తెలియదు లేదా అవి TWO, కంపైలర్ అనే చిహ్నంగా ఉన్నాయా. (కంపైలర్) ఆ సంఖ్యా 3 ను భర్తీ చేసినప్పుడు చూస్తుంది.
 కాబట్టి దీనిని జాగ్రత్తగా చూసుకోవటానికి ఒక భావన ప్రవేశపెట్టబడింది.
 కాబట్టి, const (ness) ఎలా జరిగిందో చూస్తే, మేము ఒక ప్రకటన చేస్తున్నట్లు మీరు చూస్తారు, అక్కడ మేము n యొక్క డిక్లరేషన్‌ను కొత్త కీవర్డ్ const (const) ద్వారా ఉపసర్గ చేస్తాము.
 నేను int n initize 10 ను వ్రాస్తే, n అనేది పూర్ణాంక రకం వేరియబుల్ అని తెలుసు, దీని ప్రారంభ విలువ 10.
 మేము ఈ కాన్స్ట్ కీవర్డ్‌తో ప్రిఫిక్స్ చేస్తున్నాము, అంటే దాని అర్థం n యొక్క ప్రారంభ విలువ 10 అని మరియు భవిష్యత్తులో దీనిని మార్చలేమని కూడా చెబుతుంది, ఇది ఒక అసైన్‌మెంట్ కాదు. (అసైన్‌మెంట్) లేదా నేను చేయగల ఇతర మార్గాలు మార్పు n, n ప్రోగ్రామ్ ద్వారా 10 వరకు ఉంటుంది.
 కాబట్టి, నేను ఇక్కడ ఇలాంటివి చేయటానికి ప్రయత్నిస్తే, అది 5 కి కేటాయించబడింది మరియు ఆ కోడ్‌ను కంపైల్ చేయడానికి ప్రయత్నిస్తే, కంపైలర్ (కంపైలర్) n స్థిరంగా ఉందని లోపం ఇస్తుంది, దానిని మార్చలేము.
 నేను దానిని దాటవేయడానికి ప్రయత్నించవచ్చు మరియు సాధారణంగా నేను మరొక వేరియబుల్ m మరియు పాయింటర్ p కలిగి ఉంటే అది పూర్ణాంక రకం పాయింటర్ అయితే నేను m మరియు p యొక్క చిరునామాను తీసుకుంటాను మరియు వాస్తవానికి నేను ఒక పాయింటర్‌ను ఉపయోగించవచ్చు, m యొక్క విలువ, నేను ఏడు నుండి * p కి కేటాయించినట్లయితే అది మీటర్‌ను వాస్తవంగా మారుస్తుంది.
 కానీ, నేను ఇక్కడ అదే చేయటానికి ప్రయత్నిస్తే, నేను సూచించిన వేరియబుల్ (p) లో n యొక్క ఈ విలువను మరియు తరువాత n యొక్క విలువను మార్చడానికి ప్రయత్నిస్తే, నేను 5 నుండి * p వరకు కేటాయించవచ్చు. నేను దానిని అనుమతించలేను.
 అది చెయ్యి.
 కాబట్టి, మేము ఒక వేరియబుల్‌ను const గా నిర్వచించి, ఆపై ఒక పాయింటర్‌ను ఉపయోగించటానికి ప్రయత్నించి, దాని చిరునామాను కూడా కనుగొంటే, ఇది సంకలన లోపం అని మీరు కొద్దిగా ఆశ్చర్యపోవచ్చు.
 మరియు అది సంకలన లోపం. అది లోపం కాకపోతే, మీరు దీన్ని చేయగలుగుతారు, ఇది మేము నిర్వచించటానికి ప్రయత్నిస్తున్న const-ness సూత్రాన్ని ఉల్లంఘిస్తోంది, n ను మార్చలేము అని మేము చెబుతున్నాము .
 ఫలితం ఏమిటి? దీని తదుపరి సహజ పరిణామం ఏమిటంటే, ఒక కాన్ వేరియబుల్ తప్పక ప్రారంభించబడాలి.
 ఇది నిర్వచించబడిన వెంటనే ఇది ప్రారంభించబడాలి, ఎందుకంటే మీరు దానిని ప్రారంభించకపోతే, దాని విలువను మార్చడానికి మార్గం లేదు, కాబట్టి చెత్త విలువ ఏమైనప్పటికీ, అది కేవలం చెత్త అవుతుంది.
 అందువల్ల, మీరు ప్రారంభం లేకుండా ఒక స్థితిని ప్రకటించినట్లయితే, అది సంకలన లోపంగా మారుతుంది.
 కాబట్టి మనం వేర్వేరు రకాల వేరియబుల్స్ ను కూడా డిక్లేర్ చేయవచ్చు, ఎందుకంటే కాస్ట్ టైప్ వాడకం ఒక సంక్లిష్ట సంఖ్యను చెప్పే వేరియబుల్ యొక్క ఉదాహరణ మరియు మేము దానిని స్థిరంగా నిర్వచించగలము, దీని అర్ధం రాశితో మీరు విలువను మార్చలేరు వేరియబుల్ సి.
 నిర్వచనం ప్రకారం re 2.3 ఎందుకంటే మేము ప్రారంభించాము మరియు c అనేది const అని మేము చెప్పినందున, c const అయితే అది పూర్తయింది, ఎందుకంటే నేను ఏ భాగాన్ని మార్చలేను.
 కాబట్టి, నేను c.re కి 3.5 ని కేటాయించడానికి ప్రయత్నిస్తే అది సంకలన లోపం అవుతుంది.
 ఇది కాన్ - నెస్ యొక్క భావన.
 కాబట్టి మనం దాన్ని ఎలా ఉపయోగిస్తామో చూద్దాం.
 కాబట్టి, ఇప్పుడు మనకు ఎడమవైపు రెండు ప్రోగ్రామ్‌లు ఉన్నాయి, నిర్దిష్ట సి ప్రోగ్రామ్ # నిర్వచించును ఉపయోగిస్తుంది మరియు కుడి వైపున సి ++ లో ఇలాంటి ప్రోగ్రామ్‌ను వ్రాస్తాము, అదే ప్రయోజనాన్ని సాధించడానికి కాన్-నెస్‌ను ఉపయోగిస్తుంది.
 ఇంతకుముందు మేము TWO ని విలువ 2 లో నిర్వచించాము, ఇప్పుడు మేము TWO అనేది 2 తో ప్రారంభించిన పూర్ణాంకం అని చెప్తున్నాము, కానీ ఇది కాస్ట్ వేరియబుల్, కాబట్టి మీరు దీన్ని మార్చలేరు.
 దీని యొక్క ప్రధాన ఫలితం ఏమిటంటే, కుడి వైపున ఉన్న ఈ ప్రోగ్రామ్, ఈ ప్రోగ్రామ్ సరైనది అయినప్పుడు, సి ప్రిప్రాసెసర్ ఖచ్చితంగా ఇది # నిర్వచించబడదని చెప్పింది, కాబట్టి ఈ సమయంలో TWO చిహ్నం భర్తీ చేయబడదు.
 అదేవిధంగా, PI చిహ్నం అలాగే ఉంటుంది మరియు కంపైలర్ ఇవి ప్రోగ్రామ్‌లో ఉన్న విభిన్న వేరియబుల్స్ అని చూస్తాయి మరియు కంపైలర్‌కు అవి మార్చలేని స్థిరాంకాలు అని తెలుసు.
 కాబట్టి మీరు C లో కలిగి ఉన్న అదే లక్ష్యాన్ని మీరు సాధించవచ్చు మరియు ఇప్పుడు కంపైలర్ ఇవన్నీ చూడగల అదనపు ప్రయోజనాన్ని మీరు పొందవచ్చు మరియు కంపైలర్ TWO రకం ఏమిటో కంపైలర్కు తెలుస్తుంది. కంపైలర్. (కంపైలర్) రకం ఏమిటో తెలుస్తుంది PI లేదా దాని కోసం. ఏదైనా వేరియబుల్, మీరు నిర్వచించిన ఏ విలువను అయినా const const ఉపయోగించి నిరంతరాయంగా నిర్వచించండి.
 కాబట్టి మీరు దానిని ఉపయోగించడం ద్వారా చాలా ప్రయోజనాలను పొందుతారు.
 మీరు స్థిరమైన విలువలను ఉపయోగించాలనుకునే రెండు ప్రధాన సందర్భాలు ఉన్నాయి; ఒక సూచన ఏమిటంటే, మీరు పై వంటి విభిన్న సహజ స్థిరాంకాలతో వ్యవహరించేటప్పుడు ఇ వంటి బంగారు నిష్పత్తి ఫై, తప్పుడు విలువ సున్నా విలువ వంటి బూలియన్ నిజమైన విలువ మరియు మొదలైనవి.
 ఒక ప్రోగ్రామ్‌లో చాలా సహజ స్థిరాంకాలు ఉన్నాయి, అవి వాటి విలువను కలిగి ఉంటాయి, వాటి రకాన్ని కలిగి ఉంటాయి మరియు సహజ స్థిరాంకం సహజంగా మీరు వారి అసలు ఆస్తిని కలిగి ఉంటారు, మీరు విలువను మార్చలేరు PI యొక్క లేదా మీరు E విలువను మార్చలేరు, కాబట్టి ఆస్తి కూడా అలాగే ఉంచబడుతుంది.
 అలాగే, మనం తరచుగా స్థిరంగా ఉపయోగించే మరొక ప్రదేశం నా ప్రోగ్రామ్ కోసం ఏదో స్థిరంగా ఉంటుంది లేదా ఒక నిర్దిష్ట ఫంక్షన్ కోసం ఏదో స్థిరంగా ఉంటుంది.
 కాబట్టి, దీని కోసం మనం మరొక నిర్వచనం యొక్క సమితిని ఉపయోగిస్తాము, అంటే మనకు శ్రేణి ఆకారాన్ని స్థిరంగా నిర్వచించవచ్చు.
 ఇవి సార్వత్రిక సహజ స్థిరాంకాలు కాదు, కానీ అవి నా పనికి స్థిరాంకాలు.
 నేను ఇలా చేసి ఉంటే, మనకు లభించే ప్రయోజనం, మనం ప్రోగ్రామ్ రాసేటప్పుడు, వాటిని ఈ వేరియబుల్స్ సందర్భంలో వ్రాయవచ్చు, తద్వారా తరువాత మనం వాటిని మార్చవలసి వస్తే, మనం ప్రారంభ ప్రోగ్రామ్‌ను నిరంతరం మార్చవచ్చు.) ఎగువన లేదా బహుశా కొన్ని హెడర్ ఫైల్‌లో.
 దీన్ని చేయడం వల్ల మరొక ప్రయోజనం ఏమిటంటే, మీరు # నిర్వచించినట్లయితే, # నిర్వచించు మొత్తం ఫైల్‌లో స్కోప్ ఉంటుంది.
 ఒక నిర్దిష్ట నిర్దిష్ట స్థిరమైన విలువ కోసం నేను కొంత విలువ n ని పేర్కొంటే, నా ప్రోగ్రామ్‌లో n ఉన్నచోట, అది ఈ # నిర్వచించే విలువతో భర్తీ చేయబడుతుంది.
 కాని const అనేది వేరియబుల్ డిక్లరేషన్, కాబట్టి ఇది ఏ పరిధిలోనైనా చేయవచ్చు, నేను దీన్ని ఒక ఫంక్షన్‌లో చేయగలను, నేను ఒక ఫంక్షన్‌లో ఒక బ్లాక్‌లో చేయగలను మరియు ఏదైనా వేరియబుల్ డిక్లరేషన్ లాగా, const యొక్క వేరియబుల్ డిక్లరేషన్ కూడా దానిలో పరిమితం అవుతుంది పరిధి.
 కాబట్టి ఒకే ఫైల్‌లో రెండు వేర్వేరు ఫంక్షన్లలో ఒకే వేరియబుల్ (ఎన్) జరిగే అవకాశం ఉంది, రెండు ప్రదేశాలలో ఇది స్థిరంగా ఉంటుంది, కానీ దీనికి వేర్వేరు విలువలు ఉన్నాయి, మీరు దీన్ని # నిర్వచనంతో చేయవచ్చు ప్రభావాన్ని సాధించలేరు.
 మేము # నిర్వచించుట కంటే ఎక్కువ const (const) ను ఇష్టపడతామని సంగ్రహించాము ఎందుకంటే ఇది రకం సందర్భంలో సురక్షితం కాదు, ఇది CPP చేత భర్తీ చేయబడుతుంది, ఇక్కడ const (const) లేనిది.
 అందువల్ల, మీరు డీబగ్గర్ ఉపయోగిస్తుంటే, మీరు డీబగ్గర్లో # చిహ్నాలను నిర్వచించలేరు, ఎందుకంటే మీరు చూడగలరు.
 ఇతర దుష్ప్రభావం ఏమిటంటే, # ప్రతి దశలో వ్యక్తీకరణను నిర్వచించినందున, ఇది చాలాసార్లు భర్తీ చేయబడినందున మూల్యాంకనం చేయాల్సిన అవసరం ఉంది, ఇక్కడ కాన్ విషయంలో ఇది ప్రారంభ బిందువు వద్ద మాత్రమే అంచనా వేయబడుతుంది.
 కాబట్టి, తారాగణం ఖచ్చితంగా # నిర్వచించటం కంటే సంపూర్ణ ప్రయోజనం.
 ఇప్పుడు, ముఖ్యంగా const ని నిర్వచించే కొన్ని ఫలితాలను చూద్దాం, పాయింటర్ రకం డేటా యొక్క const - ness ను పరిశీలిస్తాము.
 పాయింటర్ రకం డేటాలో, మనకు పాయింటర్ ఉందని మనకు తెలుసు మరియు అది వేరియబుల్‌ను సూచిస్తుంది.
 కాబట్టి ప్రశ్న ఏమిటంటే, మేము const-ness గురించి మాట్లాడుతుంటే, మనం ఏ const-ness గురించి మాట్లాడుతున్నాము, మీరు పాయింటర్ యొక్క const-ness లేదా పాయింటర్ డేటా యొక్క const-ness గురించి మాట్లాడుతున్నారా?
 ఇక్కడ, డేటా స్థిరంగా ఉందా లేదా పాయింటర్ కాదా లేదా పాయింటర్ స్థిరంగా ఉందా అని స్థిరమైన డేటాను సూచించే రెండు విషయాల గురించి మాట్లాడుతాము, కాని డేటా (డేటా) స్థిరంగా ఉండవచ్చు లేదా ఉండకపోవచ్చు.
 ఇక్కడ నేను పాయింటర్ మరియు పాయింటర్‌తో ఎలా లెక్కించాలో ఒక నిర్దిష్ట ఉదాహరణ మాత్రమే చూపిస్తాము.మేము రెండు వేరియబుల్స్ ని నిర్వచించాము, కాబట్టి మనకు పాయింటర్ ఉన్న పాయింటర్ ఉంది. చిరునామా తీసుకుంటుంది మరియు దానిని ఉపయోగించడం ద్వారా నేను నేరుగా వేరియబుల్ మార్చగలను లేదా నేను చేయగలను పాయింటర్ ద్వారా దాన్ని మార్చండి.
 అదేవిధంగా, ఈ పంక్తిలో, మొదటి పాయింటర్ n కు గురిపెట్టింది, ఇప్పుడు అది m కు సూచించడానికి మార్చబడింది మరియు వారు m యొక్క విలువను మార్చడానికి దాన్ని మళ్ళీ ఉపయోగించవచ్చు.
 ఇది పాయింటర్-పాయింటి దృష్టాంతంలో ఒక సాధారణ ఉపయోగం.
 అందువల్ల, const ని ఉపయోగించడం ద్వారా ఈ మార్పును ఎలా నియంత్రించవచ్చో దానితో చర్చిస్తాము.
 (స్లైడ్ సమయం చూడండి: 17:34) కాబట్టి మొదటిది, స్థిరమైన డేటా కోసం నాకు సూచిక ఉంటే.
 కాబట్టి, మనం ఇక్కడ చేస్తున్నది ఏమిటంటే, డేటాకు ముందు, పాయింటర్ ఏ రకమైన విలువను సూచిస్తుందో ముందు స్థిరంగా వ్రాసాము.
 నేను ఈ సమయంలో const వ్రాస్తే, సూచించిన డేటా స్థిరంగా ఉందని అర్థం, దానిని మార్చలేము.
 కాబట్టి, n ను స్థిరమైన విలువగా నిర్వచించారు.
 N యొక్క విలువను మార్చడానికి ప్రయత్నించడం లోపం అని మనకు ఇప్పటికే తెలుసు, ఎందుకంటే n స్థిరంగా ఉంటే, మరియు p ను n కు పాయింటర్‌గా భావించాము.
 కాబట్టి, * p ని కేటాయించిన 7 ను ఉపయోగించి n యొక్క విలువను మార్చడానికి ప్రయత్నించడం కూడా లోపం.
 కానీ, p అనేది ఒక స్థిరాంకం కాదు, అందుకే నేను వేరే వేరియబుల్ కోసం p పాయింట్ చేయగలనని కోరుకుంటే, m ఇక్కడ ఒక వేరియబుల్, ఇది స్థిరమైన వేరియబుల్ (వేరియబుల్)) కాదు.
 నేను m ని p పాయింట్‌గా చేయగలను, ఆపై m యొక్క విలువను మార్చడానికి నేను ఈ * p కేటాయించిన 8 ని ఉపయోగించవచ్చు, m ఇప్పుడు 8 అవుతుంది, అది 4 అవుతుంది, ఇప్పుడు 8 అవుతుంది.
 ఇప్పుడు మీరు చూస్తే, నాకు స్థిరంగా లేని వేరియబుల్ ఉంటే, పూర్ణాంకానికి 5 తో ప్రారంభించిన పూర్ణాంక రకంగా నిర్వచించబడింది మరియు నాకు ఒక పాయింటర్ ఉంది, అది p అనేది స్థిరమైన పూర్ణాంక విలువ యొక్క రకాన్ని సూచిస్తుంది మరియు నేను ప్రవేశించాను.
 P లో n యొక్క చిరునామా.
 ఇప్పుడు, సహజంగా 6 నుండి n వరకు m కేటాయింపు చెల్లుతుంది ఎందుకంటే n కూడా స్థిరంగా ఉండదు.
  P కేటాయించిన 6 చెల్లుబాటు అయ్యేది, కానీ నేను అలా చేయటానికి ప్రయత్నిస్తే * p 6 ని కేటాయించారు, ఇది చెల్లుబాటు కాదు, ఎందుకంటే m ఒక స్థిరమైన పూర్ణాంకానికి సూచిస్తుంది.
 కాబట్టి చాలా ఆసక్తికరమైన దృశ్యం; నేను ఇక్కడ n ను సూచిస్తూ AP కలిగి ఉన్నాను.
 P కి తెలుసు, నేను * P వ్రాస్తే స్థిరంగా ఉంటుందని తెలుసు.
 ఈ విలువను మార్చడానికి P ఉపయోగించబడదు, కాని n కూడా స్థిరంగా ఉండదు.
 కాబట్టి, n మార్చవచ్చు.
 ఇప్పుడు, ఇది చెల్లుతుంది ఎందుకంటే మీరు ఏమి చెప్తున్నారో, మీకు కావాల్సిన దానికంటే ఎక్కువ చెబుతున్నారు, n దాని స్వంతంగా మారగలదని మీరు చెబుతున్నారు.
 కాబట్టి, నేను దానిని నేరుగా n గా మార్చినా లేదా పాయింటర్ (పాయింటర్) ద్వారా మార్చినా, అది పట్టింపు లేదు ఎందుకంటే n మారవచ్చు, కాని పాయింటర్ (పాయింటర్) నేను మార్చడానికి పరిమితం చేయబడిందని చెప్పాడు.
 మీరు నా గుండా వెళితే విలువను మార్చడానికి నేను అనుమతించను అని పాయింటర్ చెప్పింది.
 కాబట్టి, వేరియబుల్ వాస్తవానికి మార్చగల దృష్టాంతం ఇక్కడ ఉంది, కానీ పాయింటర్ దానిని మార్చడానికి మిమ్మల్ని అనుమతించని ఒక వీక్షణను ఇస్తుంది, కానీ నేను నేరుగా వెళితే లేదా స్థిరమైన విలువను సూచించని కొన్ని ఇతర పాయింటర్ (పాయింటర్) కావాలనుకుంటే , అప్పుడు మేము మార్చగలుగుతాము.
 చివరగా, మేము రివర్స్ చేయడానికి ప్రయత్నిస్తే, నాకు స్థిరమైన వేరియబుల్ (n) ఉంటే మరియు నేను స్థిరంగా లేని విలువ p కోసం పాయింటర్‌ను ఉపయోగించటానికి ప్రయత్నిస్తే, నేను ఇప్పటికీ అలా చేయలేను.
 కాబట్టి, మేము ఇప్పుడు వివరించడానికి ప్రయత్నిస్తే, ఇక్కడ చివరి చివరి కేసు ఉంది, కాబట్టి మేము ఈ కేసు గురించి మాట్లాడుతున్నాము, నాకు n ను సూచించే ఒక కోతి ఉంటే, అది నిరంతరంగా ఉంటుంది మరియు * p మనకు స్థిరంగా లేదు, అప్పుడు లోపం చాలా చెల్లుతుంది, ఎందుకంటే n స్థిరంగా ఉంటుంది.
  P స్థిరంగా లేకపోతే, * p n ను సూచించడానికి ప్రయత్నిస్తుంటే, n యొక్క విలువను మార్చడానికి నేను ఎల్లప్పుడూ * p ని ఇక్కడ ఉపయోగించగలను.
 కాబట్టి మనం ఇక్కడ నేర్చుకున్నది ఒక విలువ స్థిరంగా లేనట్లయితే, దాన్ని పొందటానికి, నిరంతరాయంగా సూచించడానికి నేను దానిని ఉపయోగించగలను, కాని నేను దానిని ఆ పాయింటర్ (పాయింటర్) అని పిలుస్తాను.
 విలువ స్థిరంగా ఉంటే, స్థిరమైన విలువను సూచించే పాయింటర్‌ను నేను ఉపయోగించలేను. ఈ స్థిరమైన వేరియబుల్ (పాయింటర్) చిరునామాతో ఆ కాన్స్ట్ (పాయింటర్) ను కేటాయించనివ్వండి ఎందుకంటే ఇది ప్రారంభించడానికి అనుమతించబడదు ఎందుకంటే ఇది ఉల్లంఘిస్తుంది స్థిరమైన-నెస్ యొక్క ప్రాథమిక సూత్రం.
 తరువాత, మరొక వైపు స్థిరమైన నెస్‌ను చూద్దాం, పాయింటర్ స్థిరంగా ఉంటే? కాబట్టి, మేము ఇక్కడే ఉన్నామని మీరు ఇక్కడ చూస్తే, మేము తారాగణం వ్రాసిన స్థానాన్ని కొద్దిగా మార్చాము.
 ఇంతకుముందు ఇక్కడ ఈ స్థిరాంకం వ్రాయబడింది, ఇప్పుడు ఖర్చు స్టార్ గుర్తు తర్వాత వ్రాయబడింది, పాయింటర్ స్థిరంగా ఉందని చెప్తుంది, కానీ అది సూచించే విలువ స్థిరంగా లేదు.
 నేను దానిని గీస్తే, p అనేది const మరియు n const కాదు.
 కాబట్టి, దీని అర్థం ఏమిటంటే, ఇది n const కాదని నేను సులభంగా వ్రాయగలిగితే, నేను దాని విలువను మార్చగలను, ఎందుకంటే n const కాదు కాబట్టి, నేను దీన్ని చేయటానికి p derence ని ఉపయోగించవచ్చు. ఏడు నుండి * p వరకు కేటాయిస్తుంది, ఇది విలువను మారుస్తుంది యొక్క n.
 ఎందుకంటే నేను దేనినీ ఉల్లంఘించడం లేదు, కానీ నేను అలా చేయలేను, p లో నిల్వ చేసిన చిరునామాను నేను మార్చలేను.
 నేను ఇకపై p ను క్రొత్త వేరియబుల్ m కి సూచించలేను, ఎందుకంటే పాయింటర్ కూడా స్థిరంగా ఉందని నేను చెప్పాను. ఈ వైపు స్థిరంగా ఉంటుంది. ఇప్పుడు రెండవ వైపు స్థిరంగా ఉంది.
 సహజంగానే, మనకు ఇది ఉంటే, పొడిగింపు ద్వారా పాయింటర్ మరియు అది సూచించే డేటా నిరంతరంగా ఉండవచ్చని కూడా మనం జోడించవచ్చు.
 కాబట్టి, ఇక్కడ మనం రెండు వైపులా కాస్ట్‌లు వ్రాసే ఒక ఉదాహరణను చూపిస్తున్నాము, అంటే p అనేది నిరంతర డేటాకు పాయింటర్, అంటే p కూడా మరొకదానికి సూచించబడదు. N కాకుండా వేరే వేరియబుల్స్ కోసం తయారు చేయవచ్చు, లేదా చేయలేము n విలువను మార్చడానికి p ని ఉపయోగించండి.
 కాబట్టి, ఇవన్నీ ఇప్పుడు లోపం అవుతాయి.
 ఇప్పుడు, వాస్తవానికి, మేము సూచించిన డేటా లేదా పాయింటర్‌పై const - ness వ్రాస్తున్నందున, నేను ఎక్కడ const వ్రాయాలి అనేది కొన్నిసార్లు గందరగోళంగా ఉంటుంది మరియు const const keyword ఉంచడం ద్వారా ఏమి జరుగుతుంది.
 బొటనవేలు నియమం చాలా సులభం, మీకు ఈ ప్రకటన ఉన్నప్పుడు ప్రకటన అంతటా స్టార్ సింబల్‌లో కనిపిస్తుంది.
 మానసికంగా ఒక నిలువు వరుసను గీయండి, తద్వారా మీరు దీన్ని చేయటానికి ప్రయత్నిస్తుంటే const int * p, మొదలైనవి చెబుతున్నారు. ఈ నక్షత్ర చిహ్నం ద్వారా నిలువు వరుసను గీయండి మరియు const కీవర్డ్ ఏ వైపున కనిపిస్తుంది అని చూడండి, ఇది మీ డేటా వైపు మరియు ఇది మీ పాయింటింగ్ వైపు.
 కాస్ట్-నెస్ డేటా వైపు ఉంటే, మీరు సూచించేది స్థిరంగా ఉంటుంది.
 దీనికి విరుద్ధంగా మీకు int * const p et cetera ఉంటే, అది const పాయింటర్‌లో ఉంటుంది కాబట్టి పాయింటర్ స్థిరంగా ఉంటుంది.
 కాబట్టి ఇది ప్రాథమిక బొటనవేలు నియమం, వీటిలో ఏది స్థిరంగా ఉందో మీరు నిర్ణయించవచ్చు.
 ఉదాహరణలు క్రింద ఇవ్వబడ్డాయి.
 కాబట్టి, మీరు దీన్ని ఉపయోగించవచ్చు మరియు ఇది నేను పనిచేసిన స్ట్రింగ్‌కు ఒక ఉదాహరణ. మీరు దీన్ని జాగ్రత్తగా చదవవచ్చు మరియు స్ట్రింగ్ ఇవ్వబడిందని అర్థం చేసుకోవడానికి ప్రయత్నించవచ్చు మరియు మా వద్ద మీకు స్ట్రింగ్ ఉంటే, మీరు మీరు రెండు మార్గాలను మార్చవచ్చు స్ట్రింగ్‌ను సవరించవచ్చు లేదా మీరు స్ట్రింగ్‌ను మార్చవచ్చు.
 ఎగువన ఉన్న కోడ్‌లో మేము స్ట్రింగ్‌ను సవరించడం లేదా మొత్తం స్ట్రింగ్‌ను పూర్తిగా మార్చడం యొక్క ప్రభావాన్ని చూపుతాము.
 మీరు ఇలా ఏదైనా చేస్తే, ఇక్కడ స్థిరాంకం ఉంచండి, మీరు ఇక్కడ ఒక కాన్స్ట్ ఉంచినట్లయితే, స్ట్రింగ్ స్థిరంగా మారుతుంది, కాబట్టి మీరు స్ట్రింగ్ చేయవచ్చు) ఏ అక్షరాన్ని మార్చలేరు.
 అందువల్ల, మీరు ఇకపై చేయలేని మొదటి గుర్తుకు n వ్రాయగలరని మీరు ఇక్కడ చేయలేరు.
 అయితే, మీరు ఈ వైపు ప్రసారం చేస్తే, మీరు ఇప్పుడు స్ట్రింగ్‌లోని ఏదైనా చిహ్నాన్ని మార్చవచ్చు, కానీ మీరు స్ట్రింగ్‌ను మొత్తంగా మార్చలేరు.
 ఇక్కడ మీరు స్ట్రింగ్‌ను మార్చవచ్చు.ఇప్పుడు మీరు స్ట్రింగ్‌ను మార్చలేరు ఎందుకంటే పాయింటర్‌ను మార్చడం దీని అర్థం.
 మీరు పాయింటర్‌కు ఇరువైపులా ప్రసారం చేస్తే, మీరు వరుసగా నాలుగు అక్షరాలను సూచించే నాలుగు నక్షత్రాల నక్షత్రం ఉంటే, రెండింటినీ సవరించలేకపోతే, మీరు రెండు సవరణలను మరియు పేరు మార్పును రక్షించవచ్చు.
 అలాగే మార్చలేరు.
 రెండు వైపులా కాస్ట్-నెస్ ఎలా వర్తించబడుతుందో చూపించడానికి ఒక ఉదాహరణ.
 అందువల్ల, const - ness యొక్క ప్రాథమిక భావనను మరియు పాయింటర్ల పరంగా const - ness ఎలా వర్తించబడుతుందో చర్చించాము.