ప్రోగ్రామింగు మాడ్యూల్ 15  C ++ లోకి స్వాగతం.
 ఈ మాడ్యూల్ లో, మనము కాన్స్ట్-నెస్ గురించి చర్చించబోతున్నాము.
 C ++ యొక్క const-ness ను అర్థం చేసుకోవడానికి, వస్తువులు ఈ మాడ్యూల్ యొక్క ప్రధాన లక్ష్యాలు మరియు తరగతి రూపకల్పనలో const-ness const-ness ఎలా ఉపయోగించవచ్చో కూడా చూస్తాము.
 (స్లైడ్‌షో చూడండి: 00:51) చెప్పినట్లుగా, ఇది ఎడమ వైపు ఉంటుంది.
 మేము స్థిరమైన వస్తువుల గురించి మాట్లాడుతాము; సభ్యుల విధులు; డేటా సభ్యులు ఒక వివరణాత్మక ఉదాహరణ తీసుకుంటారు మరియు పరస్పర డేటా సభ్యులను కూడా చర్చిస్తారు.
 మొదట, మేము స్థిరమైన వస్తువులను పరిచయం చేస్తాము.
 మెరుగైన సి (++) భాగం, సి (సి) ++ యొక్క విధానపరమైన పొడిగింపు గురించి మాట్లాడినప్పుడు మనం ఇంతకు ముందు కాన్-నెస్ కాన్-నెస్ చూశాము.
 మేము ఒక వస్తువు స్థిరాంకం లేదా డేటా స్థిరాంకం, వేరియబుల్ స్థిరాంకం చేస్తే, దానిని మార్చలేము; ప్రారంభ సమయంలో ఒక విలువ సెట్ చేయబడిందని మరియు ఆ తరువాత, ఆ విలువను మార్చలేము.
 కాబట్టి, అంతర్నిర్మిత రకం డేటా కోసం మేము చూశాము - పూర్ణాంకానికి (పూర్ణాంకానికి), డబుల్ (డబుల్), పాయింటర్ మరియు మొదలైనవి.
 ఇప్పుడు C ++ వస్తువులతో కూడా ఇదే పని చేయవచ్చు.
 కాబట్టి, అంతర్నిర్మిత రకం వస్తువుల మాదిరిగా, వినియోగదారు నిర్వచించిన రకం వస్తువులను కూడా స్థిరంగా చేయవచ్చు.
 ఇప్పుడు, సహజంగా ఒక వస్తువు స్థిరంగా ఉంటే, దాని డేటా సభ్యులను ఎవరూ మార్చలేరు; ఆబ్జెక్ట్ ఒకటి లేదా అంతకంటే ఎక్కువ డేటా సభ్యులను కలిగి ఉంటుంది.
 మీరు దాన్ని స్తంభింపజేసిన తర్వాత, వాటిలో ఏదీ మార్చబడదు.
 వస్తువును స్థిరంగా చేయడం యొక్క ప్రాథమిక ఫలితం దాని రకం పాయింటర్.
 ఈ పాయింటర్ ఈ వస్తువు నివసించే చిరునామాను సూచిస్తుందని మేము గుర్తుంచుకున్నాము, ఈ పాయింటర్ ఇప్పుడు స్థిరమైన వస్తువు యొక్క పాయింటర్ అవుతుంది.
 కాబట్టి, మొదట మేము ఈ పాయింటర్‌ను ప్రవేశపెట్టినప్పుడు, ఇది ఈ పాయింటర్ రకం అని మేము చూశాము, ఇది తరగతి యొక్క వస్తువుకు స్థిరమైన పాయింటర్, కానీ ఇప్పుడు అది తరగతి యొక్క పాయింటర్. స్థిరమైన కోసం స్థిరమైన పాయింటర్ సృష్టించబడుతుంది వస్తువు.
 కాబట్టి, ఈ స్థితిని పాయింటర్ రకానికి పరిచయం చేయడం ఒక వస్తువు స్థిరాంకాన్ని ప్రకటించిన ఫలితం.
 సహజంగానే, స్థిరమైన వస్తువు కక్ష్య యొక్క సాధారణ పద్ధతులను ప్రారంభించదు.
 ఇది అర్ధమే ఎందుకంటే వస్తువు యొక్క డేటా సభ్యులను మార్చడానికి స్థిరమైన వస్తువును అనుమతించరాదని మేము చెబుతున్నాము.
 ఇప్పుడు, నేరుగా మార్చడానికి బదులుగా, ఒక పద్ధతి అమలు చేయబడితే, ఆ పద్ధతి డేటా సభ్యుడిని మార్చగలదు.
 అందువల్ల, డేటా సభ్యుడిని ఆహ్వానించడానికి నిరంతర వస్తువులు అనుమతించబడవని చెప్పడానికి, మేము సభ్యుల విధులను అమలు చేస్తాము.
 స్థిరమైన వస్తువులు వాస్తవానికి ఎలా పని చేస్తాయో మనం చూస్తాము.
 (స్లైడ్‌షో చూడండి: 03:43) కాబట్టి, దీన్ని అర్థం చేసుకోవడానికి మొదట ఒక ఉదాహరణ తీసుకుందాం.
 కాబట్టి, స్థిరమైన కాని వస్తువు యొక్క ఉదాహరణ ఇక్కడ ఉంది.
 కాబట్టి, ఈ స్థిరమైన వస్తువుకు ఇద్దరు సభ్యులు ఉన్నారు, ఒకరు ప్రైవేట్.
 కాబట్టి, ఈ స్టాటిక్ కాని వస్తువుకు ప్రైవేట్ సభ్యుడు మరియు పబ్లిక్ సభ్యుడు ఉన్నారు.
 అందువల్ల, మేము రెండు సభ్యుల విధులను ప్రవేశపెట్టాము; సభ్యుడిని పొందండి మరియు సభ్యుడిని ప్రైవేట్ సభ్యునికి చదవడానికి మరియు వ్రాయడానికి సెట్ చేయండి మరియు సహజంగా ప్రజా సభ్యుడిని నేరుగా చదవడం లేదా వ్రాయడం సాధ్యం కాదు.
 కాబట్టి, ఇక్కడ ప్రైవేట్ సభ్యుడిని చదవడానికి, ప్రైవేట్ సభ్యునికి వ్రాయడానికి, పబ్లిక్ సభ్యుడిని చదవడానికి మరియు అన్ని వస్తువులను ముద్రించడానికి ప్రయత్నిస్తున్న ఒక అప్లికేషన్ ఉంది.
 కాబట్టి, ఇవన్నీ చక్కగా పనిచేస్తాయి.మీరు ఇప్పటికే బాగా అర్థం చేసుకున్నారు.
 ఇప్పుడు, మేము స్థిరమైన వస్తువును తీసుకుంటాము.
 కాబట్టి, అదే ఉదాహరణ, ఇప్పుడు మనం చేస్తున్న వ్యత్యాసం; మీరు వస్తువును స్థిరంగా చేసారు.
 కాబట్టి, వస్తువు యొక్క ప్రకటనకు ముందు మనం const వ్రాసాము.
 కాబట్టి, ఈ వస్తువు ద్వారా నా const ఆబ్జెక్ట్ స్థిరమైన వస్తువు అవుతుంది, మిగిలిన తరగతి ఒకేలా ఉంటుంది.
 ఇది మనం నిరంతరం సృష్టించిన వస్తువు యొక్క ఉపయోగం మాత్రమే, ఇప్పుడు ఈ నాలుగు ఉపయోగం సంకలనం-సంకలన లోపాన్ని ఇస్తుందని మీరు చూస్తారు.
 అందువల్ల, మొదటి సందర్భంలో అది ఒక సభ్యుడిని ప్రైవేట్ సభ్యుడిని చదివి ప్రింట్ చేయడానికి ఆహ్వానించడానికి ప్రయత్నిస్తుంది.
 ఇప్పుడు, మీరు ఇక్కడ చూడగలిగినట్లుగా ఇది లోపం ఇస్తుంది, ఈ పాయింటర్ రూపం const (const) myClass ని myClass & కు మార్చలేమని చెప్పింది.
 వాస్తవానికి దీని అర్థం ఏమిటనే దాని గురించి మేము కొంచెం ఎక్కువ అర్థం చేసుకుంటాము, కాని బాటమ్ లైన్ తీసుకోవటానికి, కంపైలర్ ఆబ్జెక్ట్ స్టాటిక్ అయినందున, సభ్యుల ఫంక్షన్ (ఫంక్షన్) చేయగలమని మీరు దీనిని ఉపయోగించరు.
 సెట్ సభ్యుడి విషయంలో కూడా ఇదే లోపం లభిస్తుంది, ముద్రణ లోపం 1, 2 మరియు 4 విషయంలో, అవన్నీ ఒకే లోపం ఇస్తాయి మరియు మనం ఇక్కడ చేయటానికి ప్రయత్నిస్తున్నప్పుడు పబ్లిక్ ఆర్ సభ్యునికి నేరుగా వ్రాయడానికి ప్రయత్నిస్తే; ప్రజా సభ్యుడు.
 అందువల్ల, మేము ఈ పబ్లిక్ సభ్యునికి నేరుగా వ్రాయడానికి ప్రయత్నిస్తే, మాకు వేరే లోపం వస్తుంది, ఇది వస్తువు స్థిరంగా ఉన్నప్పుడు మీరు డేటా సభ్యుడిని కేటాయించలేమని చెబుతుంది.
 కాబట్టి, ఆ వస్తువు స్థిరంగా ప్రకటించబడితే, ఆ వస్తువు ద్వారా మేము నిర్దిష్ట తరగతి యొక్క డేటా సభ్యుడి విధులను యాక్సెస్ చేయలేము లేదా మార్చలేము.
 ఇప్పుడు, సహజంగా దాని యొక్క ఒక వైపు డేటా సభ్యులను రక్షించగలిగినందున ప్రయోజనాన్ని సాధిస్తుంది, స్థిరంగా ఉండటం వలన డేటా సభ్యులను మార్చలేని వాటిని రక్షించవలసి ఉంటుంది, కానీ ఇప్పుడు మరొక వైపు అది అసలైనది. ఫారం ఓడిస్తుంది ప్రయోజనం, ఉదాహరణకు, నేను ఇక్కడ మాదిరిగానే చదవాలనుకుంటే, నేను ప్రైవేట్ సభ్యుడిని చదవాలనుకుంటున్నాను, అప్పుడు నేను అలా చేయలేను లేదా నేను ప్రింట్ చేయాలనుకున్న వస్తువును చదవాలనుకుంటున్నాను.
 నేను దీన్ని కూడా చేయలేను ఎందుకంటే నేను ఏ సభ్యుల ఫంక్షన్‌ను అమలు చేయలేను.
 కాబట్టి, దీన్ని చేయటానికి మనకు C ++ లో మరొక మద్దతు అవసరం, అనగా స్థిరమైన సభ్యుల ఫంక్షన్ల కోసం, స్థిరమైన వస్తువుల కోసం మనం నిరంతర సభ్యుల ఫంక్షన్లను ప్రారంభించాలి.
 ఇది ఎలా జరుగుతుందో చూద్దాం.
 అందువల్ల, నిరంతర సభ్యుల ఫంక్షన్ C ++ లో కాన్స్ట్-నెస్‌కు మద్దతు ఇవ్వడానికి కొత్త లక్షణం.
 ఇది మరొక సభ్యుల ఫంక్షన్ లాగా ఉంటుంది, ఫంక్షన్ ప్రోటోటైప్ తర్వాత నిరంతర సభ్యుల ఫంక్షన్‌లో హెడర్ మాత్రమే తేడా; ఇది హెడర్ భాగం మరియు ఫంక్షన్ యొక్క ప్రధాన భాగం.
 ఈ రెండింటి మధ్య, మీరు కీవర్డ్ కాన్స్ట్ వ్రాస్తారు మరియు మీరు ఈ కీవర్డ్ కాన్స్ట్ రాసేటప్పుడు, సభ్యుల ఫంక్షన్‌ను స్థిరమైన సభ్యుల ఫంక్షన్ అంటారు.
 ఇప్పుడు, ఇది ఏమిటంటే, ఒక వస్తువు తరగతి యొక్క సభ్యుల ఫంక్షన్‌ను ప్రారంభించాలనుకున్నప్పుడు, ఆ సభ్యుడిలోని ఆ వస్తువు యొక్క చిరునామా ఈ పాయింటర్ ప్రయాణిస్తున్నప్పుడు మరియు పాయింటర్ రకాన్ని మనకు తెలుసు.
 ఇప్పుడు, మీరు నిరంతర సభ్యుల ఫంక్షన్‌ను ప్రకటించినప్పుడు, అది వెళ్ళే పాయింటర్ యొక్క సంతకంగా మారుతుంది.
 ఇది ఇప్పుడు, స్టాటిక్ ఆబ్జెక్ట్ యొక్క సూచిక ఎందుకంటే మీరు సభ్యుడు పాయింటర్ (పాయింటర్) ఒక స్టాటిక్ మెంబర్ ఫంక్షన్ అని చెప్తున్నారు, కాబట్టి కంపైలర్ ఏమి నొక్కి చెప్పాలనుకుంటున్నారు; నిరంతర వస్తువులు మాత్రమే ఈ సభ్యుల పనితీరును అమలు చేయగలవు.
 కాబట్టి, స్థిరమైన వస్తువులు ఈ రకమైన పాయింటర్ లక్షణాన్ని కలిగి ఉన్నాయని మేము ఇప్పటికే చూశాము, అవి స్థిరమైన బిందువులు, నిరంతర వస్తువు వస్తువులు మరియు స్థిరమైన సభ్యుల పనితీరుకు ఒకే రకమైన ఈ పాయింటర్ అవసరం.
 కాబట్టి, ఇప్పుడు, స్థిరమైన వస్తువు ఈ స్థిరమైన సభ్యుల ఫంక్షన్‌ను అమలు చేయగలదు.
 ఫలితం ఇక్కడ ఇవ్వబడింది, సభ్యుల ఫంక్షన్ స్థిరంగా ఉంటే, ఆ ఫంక్షన్‌లో డేటా సభ్యుడిని మార్చలేరు.
 అందువల్ల, మనకు సెట్ మెంబర్ ఫంక్షన్ ఉంటే మరియు అది స్టాటిక్ మెంబర్ ఫంక్షన్ అని ప్రకటిస్తే.
 కాబట్టి, ఒక స్టాటిక్ ఆబ్జెక్ట్ దీన్ని అమలు చేయగలదు, అప్పుడు మనకు కంపైల్ లోపం వస్తుంది ఎందుకంటే ఈ ఫంక్షన్‌లో డేటా సభ్యుడిని ఒక అసైన్‌మెంట్‌గా మార్చడానికి ప్రయత్నిస్తున్నాము.
 అందువల్ల, స్థిరమైన సభ్యుల ఫంక్షన్ యొక్క మొత్తం డేటా సభ్యులను మాత్రమే చదవడానికి డేటా సభ్యులను యాక్సెస్ చేయడానికి మాత్రమే ఉపయోగించబడుతుంది, కానీ డేటా సభ్యులను వ్రాయడానికి లేదా మార్చడానికి వాటిని ఉపయోగించదు. కావచ్చు మరియు ఏ సందర్భంలోనైనా నిరంతర సభ్యుల విధులను అమలు చేయలేము నిరంతర వస్తువు.
 అందువల్ల, ఈ రెండింటినీ కలపడం ద్వారా, స్టాటిక్ ఆబ్జెక్ట్ ఇప్పటికే ఒకే విలువలను కలిగి ఉన్న డేటా సభ్యులను మాత్రమే నిలుపుకోగలదనే లక్ష్యాన్ని మేము సాధిస్తాము, కాని డేటా సభ్యులను ఇవ్వగల విలువలను మార్చడానికి ఇది అనుమతించదు.
 ఇప్పుడు, ఇక్కడ తదుపరి పాయింట్ కూడా ఆసక్తికరంగా ఉంటుంది, కాని స్థిరమైన వస్తువు నిరంతర సభ్యుల ఫంక్షన్‌ను ప్రారంభించగలదు.
 ఇది చాలా సులభం ఎందుకంటే స్థిరమైన సభ్యుల ఫంక్షన్ అది ఒక వస్తువును మార్చదని హామీ ఇస్తుంది, వస్తువు కూడా స్థిరంగా లేకపోతే, అది మార్చబడినా లేదా మార్చబడకపోయినా మేము పట్టించుకోము.
 కాబట్టి, ఇది స్థిరమైన వస్తువు అని మీరు చెబుతున్నారు మరియు దానిపై నిరంతర సభ్యుడు పనిచేస్తాడు, అంటే నేను ఎటువంటి మార్పులు చేయను. వైరుధ్యం లేదు.
 కాబట్టి సారాంశంలో, నాన్-స్టాటిక్ ఆబ్జెక్ట్ (ఆబ్జెక్ట్) స్థిరమైన సభ్యుల ఫంక్షన్‌తో పాటు కాని స్థిరమైన సభ్యుల ఫంక్షన్‌ను ప్రారంభించగలదు, కాని స్టాటిక్ ఆబ్జెక్ట్ (ఆబ్జెక్ట్) స్థిరమైన సభ్యుల ఫంక్షన్‌ను మాత్రమే ప్రారంభించగలదు.
 అందువల్ల, ఒక వస్తువును మార్చవలసిన అవసరం లేని అన్ని సభ్యుల ఫంక్షన్లను నిరంతర సభ్యుల ఫంక్షన్లుగా ప్రకటించాలి, ఏదైనా స్థిరమైన వస్తువు (వస్తువు) కూడా వాటిని ఉపయోగించగలదని నిర్ధారించడానికి, సభ్యులు ఫంక్షన్లను కూడా ఆహ్వానించవచ్చు.
 మళ్ళీ ఒక ఉదాహరణ చూద్దాం.
 మేము అదే ఉదాహరణకి తిరిగి వస్తాము, మనం ఇప్పుడు ఏమి చేస్తున్నాము, మేము సభ్యుల విధులను పరిశీలిస్తాము మరియు అవి స్థిరంగా ఉండాలా వద్దా అని నిర్ణయిస్తాము; అందుకున్న సభ్యుడు మీరు స్థిరంగా ఉండే ఒక విలువను మాత్రమే చదువుతున్నారు, ముద్రణ చదవడానికి మాత్రమే మరియు డేటా సభ్యుల ముద్రణ విలువలు స్థిరంగా ఉంటాయి, కానీ ఈ, సెట్ సభ్యుడు మేము స్థిరమైన సభ్యుల ఫంక్షన్ చేయలేము ఎందుకంటే సెట్ సభ్యుల డేటా మార్చబడింది సభ్యుడిగా ఉండటానికి ఉద్దేశించబడింది.
 మనకు ఇప్పుడు రెండు వస్తువులు ఉంటే, ఒకటి నాన్-స్టేషనరీ మరియు ఒక నాన్ స్టేషనరీ, అప్పుడు మీరు చూడగలిగినట్లుగా నాన్-స్టేషనరీ ఆబ్జెక్ట్ మనం ఇంతకు ముందు చూసినట్లుగా అన్ని మార్పులను చేయవచ్చు.
 నిరంతర వస్తువు ఇప్పుడు అందుకున్న సభ్యుల ఫంక్షన్‌ను ప్రారంభించగలదు ఎందుకంటే ఇది స్థిరమైన సభ్యుల ఫంక్షన్ మరియు సభ్యుల డేటా విలువను మైప్రైమ్ చదువుతుంది.
 ఇది ముద్రించగలదు ఎందుకంటే ముద్రణ నిరంతర సభ్యుల ఫంక్షన్, కానీ ఇది వీటిలో ఏదీ చేయలేము, అందుకే నేను వాటిపై వ్యాఖ్యానించాను.
 ఇది ప్రైవేట్ సభ్యుని విలువను మార్చడానికి సెట్ సభ్యుడిని ఆహ్వానించదు; సెట్ సభ్యుడు స్థిరమైన వస్తువు ద్వారా ప్రారంభించబడని స్థిరమైన సభ్యుల ఫంక్షన్ కనుక, ఇది నిరంతర వస్తువు (వస్తువు) అయినందున అది నేరుగా ఒక ప్రజా సభ్యునికి అప్పగించదు.
 కాబట్టి, ఇది ఒక సభ్యుని యొక్క ఏ విధులను స్థిరమైన వస్తువు ద్వారా ప్రారంభించవచ్చో మనం నియంత్రించగల లక్ష్యాన్ని సాధిస్తాము మరియు డేటా సభ్యుల యొక్క అన్ని విలువలను వారు నిర్మిస్తున్నప్పుడు వాటిని రక్షించగలము.
 ఇప్పుడు, మేము సి ++ కి మద్దతిచ్చే మూడవ రకం కాన్స్ట్-నెస్‌ను పరిచయం చేసాము.
 మేము నిరంతర వస్తువుల గురించి మాత్రమే మాట్లాడాము, ఇక్కడ నేను ఒక వస్తువును స్థిరంగా చేస్తే ఆ వస్తువు యొక్క మొత్తం భాగం స్థిరంగా ఉంటుంది.
 నేను ఆ వస్తువులో ఎటువంటి మార్పులు చేయలేను, డేటా సభ్యుడిని మార్చలేము, కాని తరచుగా మనకు అవసరమైన విషయం ఏమిటంటే మనం కొంతమంది డేటా సభ్యులను మార్చవలసి ఉంటుంది, మరికొన్ని డేటా (డేటా) సభ్యులు స్థిరంగా ఉండాలి మరియు నేను చాలా మందిని పేర్కొన్నాను ఉదాహరణలు.
 ఉదాహరణకు, ఇక్కడ ఉద్యోగి రికార్డును సృష్టించడం మరియు ఆ ఉద్యోగి రికార్డు కోసం మీకు ఉద్యోగి ID ఉంది, మీకు పుట్టిన తేదీ ఉంది.
 ఖచ్చితంగా, ఒక రికార్డ్ సృష్టించబడిన తర్వాత, ఉద్యోగి ID లు మారగలవని మేము అనుకోము మరియు పుట్టిన తేదీని మార్చలేము, కాని అదే రికార్డ్ అదే వస్తువు యొక్క హోదా, చిరునామా, జీతం, ఇవన్నీ వేరియబుల్ అయి ఉండాలి ఎందుకంటే ఏమి ప్రోగ్రామింగ్.
 కాబట్టి, మరెన్నో ఉదాహరణలు. నేను ఒక విద్యార్థితో కలిసి పనిచేస్తుంటే రోల్ నంబర్, పుట్టిన తేదీ వేరియబుల్ గా ఉండాలి, మనం ఇంతకుముందు చర్చించిన క్రెడిట్ కార్డ్ ఉదాహరణ గురించి మాట్లాడుతుంటే, కార్డ్ ది సన్నీయర్ మరియు హోల్డర్ కార్డు తప్పనిసరిగా వేరియబుల్ కానిదిగా ఉండాలి, అయితే కార్డులు నిర్ణీత వ్యవధిని కలిగి ఉంటాయి.
 అందువల్ల, అవి ముగిసిన తర్వాత, మేము కార్డులను తిరిగి జారీ చేయాలనుకుంటున్నాము.
 అందువల్ల, గడువు తేదీ, ఇష్యూ తేదీ, ఇవన్నీ మారుతాయి. సివివి హోల్డర్ కూడా దరఖాస్తు చేసుకోవచ్చు మరియు చిరునామా కోసం మార్చవచ్చు.
 కాబట్టి, ఇది వేరియబుల్ అయి ఉండాలి.
 కాబట్టి, నిరంతర డేటా సభ్యుడు ఎంచుకోవడానికి ఒక లక్షణం, అంటే సెలెక్టివ్ కాన్-నెస్ వస్తువు యొక్క ఒక భాగం.
 కాబట్టి, డేటా డిక్లరేషన్ ముందు కాన్స్ట్ కీవర్డ్ ఉపయోగించి డేటా సభ్యులను స్థిరంగా మార్చడం ద్వారా మేము దీన్ని చేస్తాము.
 అందువల్ల, వస్తువు స్థిరంగా లేనప్పుడు కూడా స్టాటిక్ డేటా సభ్యుడిని మార్చలేరు.
 వాస్తవానికి, ఒక వస్తువు స్థిరంగా ఉంటే, అప్పుడు ఏమీ మార్చలేము, కానీ ఒక వస్తువు నిరంతరంగా లేకపోయినా, స్థిరమైన డేటా సభ్యుడు దాని విలువను మార్చలేరు, కనుక ఇది తప్పక వస్తువుగా నిర్ణయించబడాలి ప్రారంభించడం.
 కాబట్టి, దీనిపై శ్రద్ధ చూపుదాం.
 ఇప్పుడు, మనకు ఇద్దరు ప్రైవేట్ సభ్యులు ఉన్న ఒక ఉదాహరణ ఉంది, ఇది స్థిరమైన స్థిరాంకం మరియు ఇది స్థిరంగా ఉంటుంది, ఈ కాన్స్ట్ కీవర్డ్ పెట్టడం ద్వారా మేము దానిని స్థిరంగా చేసాము.
 అదేవిధంగా, నేను ఇద్దరు పబ్లిక్ డేటా సభ్యులను చూపించాను, వారిలో ఒకరు నిరంతరాయంగా, మరొకరు నిరంతరాయంగా ఉన్నారు.
 వీటన్నింటినీ ప్రారంభించే తయారీదారులు మాకు ఉన్నారు మరియు ఈ సభ్యులందరికీ సెట్లు ఉన్నాయి.
 సహజంగానే, నా యొక్క ఈ డేటా సభ్యుడు స్థిరంగా ఉన్నాడని నేను చెబితే, అది మారుతుందని నేను don't హించను.
 కాబట్టి, మేము ఈ డేటా సభ్యునిపై ఒక సెట్ ఫంక్షన్‌ను వ్రాయడానికి ప్రయత్నించినప్పుడు, అది cprimem కు విలువను అందిస్తుంది, కంపైలర్ (కంపైలర్) మీకు లోపం ఇస్తుంది ఎందుకంటే ఇది ఎటువంటి లోపం లేకుండా కంపైల్ చేయగలిగితే, అప్పుడు ఒక వస్తువు దానిపై దాడి చేయగలదు మరియు డేటా సభ్యునికి మార్పులు చేయండి.
 అర్థం చేసుకోవడానికి జాగ్రత్తగా ఉండండి, ఈ సందర్భంలో సభ్యుల ఫంక్షన్ సభ్యుల ఫంక్షన్ కానవసరం లేదు.
 ఇది నాన్-కాన్స్ట్ మెంబర్ ఫంక్షన్, కానీ మీకు లోపం రావడానికి కారణం, ఆ సభ్యుడు, మీరు మార్చాలనుకుంటున్న డేటా సభ్యుడు, స్టాటిక్ అని ప్రకటించారు.
 కాబట్టి, సెట్ ఫంక్షన్ అమలు చేయబడదు.
 అదేవిధంగా, మీరు స్థిరంగా ఉన్నట్లు ప్రకటించబడిన పబ్లిక్ డేటా సభ్యునికి విలువను కేటాయించడానికి ప్రయత్నిస్తున్న ఈ పంక్తిని చూస్తే, కంపైలర్ (కంపైలర్) నుండి మాకు మరొక లోపం వస్తుంది ఎందుకంటే మీరు పబ్లిక్ డేటాను ఉపయోగిస్తుంటే (డేటా ) సభ్యుల ప్రకటనను చూసినప్పుడు, పబ్లిక్ డేటా సభ్యుడు స్థిరంగా ప్రకటించబడతారు.
 కాబట్టి, ఇది వేరియబుల్ కాకూడదు.
 కాబట్టి, డేటా సభ్యుల ముందు const-ness ను ఉపయోగించడం ద్వారా మేము మార్పులు చేయగలిగేటప్పుడు మీరు డేటా సభ్యులను స్థిరంగా చేసుకోవచ్చు, ఉదాహరణకు, ఈ ప్రత్యేక డేటా సభ్యుడి కోసం మేము ఇక్కడ ఒక నియామకాన్ని సృష్టిస్తున్నాము, ఇది a పబ్లిక్ సభ్యుడు మరియు ఈ నియామకం మీకు లోపం ఇవ్వదు, మేము దానిని మారుస్తున్నాము, ఇది స్థిరమైన సభ్యుడు కానందున ఇది కూడా అనుమతించబడుతుంది.
 కాబట్టి, ఇప్పుడు మన క్రెడిట్ కార్డ్ ఉదాహరణను మళ్ళీ చూద్దాం మరియు క్రెడిట్ కార్డ్ క్లాస్ యొక్క మంచి రూపకల్పన కోసం స్థిరమైన డేటా సభ్యుడిని ఎలా ఉపయోగించవచ్చో చూద్దాం.
 మీరు ఇప్పటికే ఈ సంకేతాలు మరియు తరగతి నమూనాలను చూశారు.
 అందువల్ల, నేను వాటిని పునరావృతం చేయను, చేసిన చిన్న మార్పులకు మాత్రమే శ్రద్ధ వహించండి, ఉదాహరణకు, మేము ఇక్కడ ప్రవేశపెట్టిన ఈ స్ట్రింగ్ తరగతిని చూస్తే.
 మేము కాపీ కన్స్ట్రక్టర్ మరియు అసైన్‌మెంట్ ఆపరేటర్‌ను పరిచయం చేసాము, ఇది మాడ్యూల్ 14 లో చర్చించబడింది మరియు ముఖ్యంగా ప్రింట్ ఫంక్షన్‌లో, మేము ఒక తారాగణాన్ని ప్రవేశపెట్టాము ఎందుకంటే మీరు చెప్పినట్లుగా, ప్రింట్ ఫంక్షన్ ఏ డేటా సభ్యుడిని మారుస్తుందని and హించలేదు మరియు మేము నేర్చుకున్నాము డేటా సభ్యులను మార్చని ఏదైనా సభ్యుల ఫంక్షన్ ప్రకటన ఒక వస్తువు దానిని మార్చలేదని నిర్ధారించడానికి స్థిరమైన సభ్యుల ఫంక్షన్‌గా ప్రకటించాలి.
 కాబట్టి, మేము ఈ ప్రింట్ ఫంక్షన్లన్నింటినీ const గా చేస్తాము.
 తేదీ తరగతి; తేదీ తరగతిలో మళ్ళీ మేము కాపీ చేయడానికి నిబంధనలు అందించాము మరియు మేము ఈ పనులన్నింటినీ ప్రింట్, చెల్లుబాటు అయ్యే తేదీ, రోజు, పూర్తి చేశాము, ఈ ఫంక్షన్లన్నింటినీ మేము అంగీకరించిన ప్రోటోకాల్‌లో ఉన్నట్లుగా కాన్స్టాంట్ సభ్యునిగా.
 నేమ్ క్లాస్ మళ్ళీ కాపీలు జోడించబడింది మరియు ప్రింట్ ఫంక్షన్ నిరంతర సభ్యుల ఫంక్షన్ లో నిర్మించబడింది.
 మేము ఈ తరగతిని ఇంతకు ముందే చూశాము, ఇది ఏ వ్యక్తి పేరునైనా నిర్వచించడానికి ఉపయోగపడుతుంది.
 చిరునామా తరగతి యొక్క నకలు జోడించబడింది మరియు ముద్రణ ఫంక్షన్ నిరంతర సభ్యుల ఫంక్షన్గా చేయబడిందని నేను భావిస్తున్నాను.
 ఇప్పుడు, చివరకు, మేము క్రెడిట్ కార్డుల తరగతితో ఉన్నాము, ఇది ఈ స్ట్రింగ్ తేదీ, పేరు, చిరునామా, ఈ తరగతులన్నింటినీ ఉపయోగిస్తుంది మరియు మాకు ఒకే డేటా సభ్యులు మరియు కార్యాచరణ ఉంటుంది.
 ఇప్పుడు, మనం ఏమి చేస్తున్నామో, మేము అనేక సూచించిన పద్ధతులను పరిచయం చేస్తున్నాము.
 ఇంతకుముందు, మేము క్రెడిట్ కార్డ్ ఆబ్జెక్ట్‌ని మాత్రమే సృష్టించి ప్రింట్ చేస్తున్నాము..
 ఇప్పుడు, క్రెడిట్ కార్డ్ ఆబ్జెక్ట్ యొక్క వేర్వేరు డేటా సభ్యులను మార్చగల అనేక సెట్ పద్ధతులను మేము ప్రవేశపెట్టాము, ఇది నేను క్రొత్త హోల్డర్ పేరును సెట్ చేయగలను, నేను చిరునామాను సెట్ చేయగలను, ఇష్యూ తేదీని సెట్ చేయవచ్చు మరియు మొదలైనవి కోర్సు, ముద్రణ స్థిరంగా ఉంటుంది.
 కాబట్టి, ఇది మేము చేసిన మార్పు మరియు దానితో ఫలితాలు ఏమిటో చూద్దాం.
 అందువల్ల, మీరు క్రెడిట్ కార్డు దరఖాస్తును పరిశీలిస్తే.
 ఇప్పుడు, అనువర్తనంలో మార్పులు చేయడానికి సెట్ సభ్యులను ఉపయోగించాము.
 అందువల్ల, ఈ మార్పులన్నీ మొదట చేయబడ్డాయి, ఈ అంశం స్థిర చిరునామాల కోసం మరియు షెర్లాక్ హోమ్స్ కోసం కొన్ని తేదీల కోసం సృష్టించబడింది మరియు ఇప్పుడు, వేర్వేరు చిరునామాలతో వేరే హోల్డర్ పేరు కోసం సవరించబడింది.
 అందువల్ల, ఈ విభిన్న రంగాలన్నింటినీ మనం మార్చగలము, కాని కలతపెట్టే విషయం ఏమిటంటే, క్రెడిట్ కార్డ్ జారీ విధానం ప్రకారం సాధ్యం కాని హోల్డర్ పేరును మనం మార్చగలుగుతున్నాము.
 కొంతమందికి కార్డులు జారీ చేయడం మరెవరికీ ఇవ్వబడదు.
 అందువల్ల, హోల్డర్ పేరు మార్చడానికి ఈ అవకాశాన్ని మేము ఆపాలి.
 కాబట్టి, ఇక్కడే మనం స్థిరమైన డేటా సభ్యుని సాధనాన్ని ఉపయోగిస్తాము.
 కాబట్టి, మనం ఇప్పుడు ఏమి చేస్తున్నామో, ఎలా చేయాలో నేర్చుకున్నాము.
 హోల్డర్ పేరు మార్చబడకూడదనుకుంటే, హోల్డర్ పేరు ప్రకటించబడటానికి ముందే మేము ఆఫర్ చేసాము.
 కాబట్టి, హోల్డర్ పేరు ఇప్పుడు నిరంతర డేటా సభ్యుడిగా మారుతుంది.
 అందువల్ల, ఇది క్రెడిట్ ఆబ్జెక్ట్‌లో సవరించబడదు అంటే, సెట్ హోల్డర్‌ను మేము వ్రాసిన సెట్ హోల్డర్ (ఫంక్షన్) ఫంక్షన్ ఇప్పుడు లోపంగా మారుతుంది ఎందుకంటే అది ఆ హోల్డర్‌ను కేటాయించడానికి ప్రయత్నిస్తోంది.ఈ స్థిరాంకాన్ని నిర్వచిస్తుంది.
 కాబట్టి, మీకు అలాంటి ఫంక్షన్ ఉండదని చెప్పి కొంత కంపైలర్ లోపం వస్తుంది.
 నేను అలాంటి పని చేయలేకపోతే, సహజంగానే నేను హోల్డర్ పేరును మార్చలేను.
 కాబట్టి, మేము ఆ లక్ష్యాన్ని సాధిస్తాము.
 కాబట్టి, తరగతి శుభ్రం చేయబడినది.
 మేము ఇప్పుడు సెట్ హోల్డర్ (హోల్డర్) ఫంక్షన్‌ను తీసివేసాము ఎందుకంటే ఆ ఫంక్షన్ కంపైల్ చేయబడదు మరియు అందువల్ల, సెట్ హోల్డర్ (హోల్డర్) ను మార్చడానికి మార్గం లేదు మరియు మేము దానిని కూడా ఉపయోగిస్తాము.
 అప్లికేషన్ ద్వారా మరోసారి వెళ్ళండి.
 ఇప్పుడు, అప్లికేషన్‌లో, ఇది చేయలేమని మేము వ్యాఖ్యానించాము, కాని మిగిలిన మార్పులు ఇంకా చేయవచ్చు.
 వారు ఇప్పటికీ చిరునామా, ఇష్యూ చేసిన తేదీ మరియు అన్నింటినీ మార్చవచ్చు.
 కాబట్టి, మేము సురక్షితంగా ఉన్నాము, కాని నేను కార్డు సంఖ్యను మాత్రమే మార్చగలను.
 నేను కార్డ్ నంబర్‌ను సవరించగలను లేదా కార్డ్ నంబర్‌ను మార్చగలను, వేరే కార్డ్ నంబర్‌ను నమోదు చేయవచ్చు.
 కాబట్టి, మేము దానిని ఎలా నివారించాలి? దీన్ని మార్చలేమని మనం ఎలా గుర్తుంచుకోవాలి? దీని కోసం, కార్డు సంఖ్య పాయింటర్ వేరియబుల్ అని మనం చూడాలి.
 అందువల్ల, ఇది తప్పనిసరిగా కేటాయించబడాలి మరియు అది స్ట్రింగ్‌కు సూచించబడుతుంది.
 కాబట్టి, కార్డ్ నంబర్‌ను ప్రభావితం చేసే రెండు మార్గాలు ఉన్నాయి, ఒకటి నేను ఈ పాయింటర్‌ను తరలించి స్ట్రింగ్‌ను మార్చగలను, నేను వస్తువును సవరించగలను.
 రెండవది, నేను క్రొత్త వస్తువును తిరిగి పొందగలను మరియు కార్డ్ నంబర్ స్థానంలో ఉంచగలను, అంటే నేను దాన్ని తిరిగి పొందగలను.
 కాబట్టి, ఇది కార్డ్ నంబర్, కార్డ్ నంబర్లు 4, 3, 8, 6 మరియు మొదలైన వాటి కేటాయింపు ఉంది.
 కాబట్టి, నేను దీన్ని సవరించగలను లేదా మార్చగలను, క్రొత్త కార్డ్ నంబర్‌ను జోడించగలను.
 కాబట్టి ఈ రెండింటినీ ఆపాలి.+
 ఇది సాధ్యం కాకూడదు మరియు మేము ఈ పరిస్థితిని చర్చిస్తాము, ఇక్కడ మనకు అవసరమైన వాటిపై పాయింటర్ల యొక్క కాన్-నెస్ గురించి చర్చించాము, ఇక్కడ మనకు పాయింటర్ మరియు పరిష్కరించబడిన వస్తువు రెండూ అవసరం. (ఆబ్జెక్ట్) అవసరం.
 కాబట్టి, ఇది మేము ఇప్పుడే చేస్తాము, మేము దానిని స్థిరమైన పాయింటర్‌గా చేస్తాము మరియు దానిని స్థిరమైన స్ట్రింగ్ స్థిరమైన వస్తువుకు సూచిస్తాము మరియు దానితో అది సాధ్యం కాకూడదు, దాన్ని మార్చడం సాధ్యం కాదు, కానీ ఇప్పుడు అది ఒక ముఖాలు వేరే సమస్య.
 సమస్య ఏమిటంటే ఇది కన్స్ట్రక్టర్ యొక్క శరీరంలో ఎలా ప్రారంభించబడిందో, ఈ సమయంలో సృష్టించబడిన వస్తువు ప్రారంభించడం పూర్తయిందని మీకు తెలుసు మరియు దీనిలో మేము కార్డు సభ్యుడిని వ్రాయడం వల్ల ప్రారంభించలేదు, దీనికి కొన్ని సంకేతాలు ఉన్నాయి, ప్రారంభించడానికి.
 మేము ఇక్కడ చేసే స్ట్రింగ్‌ను మీరు కేటాయించాలి.
 దీనికి ముందు మనం స్ట్రింగ్ యొక్క పొడవును పొందాలి, తరువాత మేము స్ట్రింగ్‌ను కేటాయించి, దానిలో ఇచ్చిన సంఖ్యలను కాపీ చేస్తాము.
 అందువల్ల, మేము దీనిని కన్స్ట్రక్టర్ యొక్క శరీరంలో చేయాలని నిర్ణయించుకున్నాము, కానీ ఇప్పుడు అది స్థిరమైన పాయింటర్‌గా మారింది, ఈ నియామకం సాధ్యం కాదు, ఎందుకంటే కార్డు యొక్క సభ్యుడు ఇప్పటికే ఫార్వర్డ్ జాబితాలో ప్రారంభించబడ్డాడు. వెళ్ళిన తరువాత, వస్తువు కూడా స్థిరంగా ఉంటుంది.
 ఈ కాపీయింగ్ సాధ్యం కాదు ఎందుకంటే ఆబ్జెక్ట్ కూడా స్టాటిక్, ఇది స్టాటిక్ ఆబ్జెక్ట్‌ను సూచిస్తుంది.
 కాబట్టి, నేను strcpy చేస్తే, నేను స్ట్రింగ్‌ను అనుకరిస్తే, నేను నిజంగా ఆ స్ట్రింగ్ ఆబ్జెక్ట్‌ని మారుస్తున్నాను.
 కాబట్టి, ఈ రెండూ లోపం ఇస్తాయి.
 కాబట్టి, మనం ఈ పనులన్నింటినీ ప్రారంభ జాబితాలోనే చేస్తామని గుర్తుంచుకోవాలి.
 మేము దీన్ని కన్స్ట్రక్టర్ బాడీలో చేయలేము.
 ఇప్పుడు, మీరు జాగ్రత్తగా చూస్తే, మేము కార్డు సభ్యుని ప్రారంభించడం ఇక్కడ ప్రవేశపెట్టాము.
 దయచేసి దీన్ని అర్థం చేసుకోవడానికి ప్రయత్నించండి, ఈ వ్యక్తీకరణ యొక్క స్వల్ప సంక్లిష్టతతో మీరు భయపడవద్దు, మీరు సి స్ట్రింగ్ అయితే మొదట సి నంబర్ వన్ ఇచ్చారు.
 కాబట్టి, మొదట దాని పొడవును కనుగొని, దాని కోసం మేము ఒక కేటాయింపు చేస్తాము.
 కాబట్టి, కార్డ్ నంబర్‌ను చొప్పించగలిగేంత స్థలం ఉన్న పాయింటర్‌ను మేము పొందుతాము, ఆపై మేము సి నంబర్‌ను ఈ స్థానానికి కాపీ చేయడానికి ప్రయత్నిస్తాము.
 కాబట్టి, ఇది మొదట మనకు పొడవు వస్తుంది.
 కాబట్టి, పొడవు 16, మేము 1 ని జోడిస్తాము; కాబట్టి మనకు 17 వస్తుంది.
 ఇది 1 శూన్య అక్షరం కోసం అయితే మీరు కేటాయింపు చేస్తారు.
 అందువల్ల, మనకు కొన్ని చోట్ల 16 యొక్క శ్రేణి కేటాయింపు ఉంది, ఆపై మేము strcp y ని ఉపయోగించి నా ఇన్పుట్ స్ట్రింగ్ (str) ను కాపీ చేస్తాము.
 అందువల్ల, నా కార్డు యొక్క సభ్యుడు ఈ స్ట్రింగ్‌కు ప్రారంభించబడ్డాడు మరియు దీన్ని ఇక్కడ తప్పక చేయాలి, దీన్ని ప్రారంభ జాబితాలో చేయండి ఎందుకంటే పాయింటర్ కార్డ్ రెండూ MEM నంబర్ పాయింటర్ అలాగే స్ట్రింగ్ ఇది ఇప్పుడు నిరంతరంగా ఉంటుందని సూచిస్తుంది, కానీ తో క్రెడిట్ కార్డ్ ఆబ్జెక్ట్ సృష్టించబడిన తర్వాత మీరు కార్డ్ నంబర్‌లో ఎటువంటి మార్పు చేయలేని విధంగా మేము ఆ వస్తువును ఒక విధంగా రక్షించగలము మరియు సృష్టించగలము.
 నిరంతర వస్తువులు, స్థిరమైన సభ్యుల విధులు మరియు స్థిరమైన డేటా సభ్యులను ఎలా సృష్టించాలో మరియు దానిని డిజైన్‌లో ఎలా ఉపయోగించాలో మనం చూశాము.