Static Members (Lecture 31)-l1JYbPhh9Vw

 ప్రోగ్రామింగ్ ఇన్ C ++ యొక్క మాడ్యూల్ 16 కు స్వాగతం.
 ఈ మాడ్యూల్ లో, మనము స్టాటిక్ మెంబర్స్ గురించి మాట్లాడతాము; ప్రత్యేకంగా మనము స్టాటిక్ డేటా మెంబర్స్ మరియు స్టాటిక్ మెంబర్ ఫంక్షన్ ను అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము.
 ఈ ఆకృతిలో రెండు రకాల మెంబర్స్ ఉంటుంది, మరియు సింగిల్టన్ క్లాసెస్ (singleton classes) గురించిన ఒక చర్చ ఉంటుంది.
 ప్రతి స్లయిడ్ యొక్క ఎడమ వైపున అవుట్లైన్ కనిపిస్తుంది.
 స్టాటిక్ డేటా సభ్యుడు, మేము డేటా సభ్యుల గురించి తెలుసుకున్నాము.
 కాబట్టి, డేటా సభ్యుడు తరగతి నిర్మాణంలో ఒక భాగం.
 అందువల్ల, ఒక వస్తువు ఒక వస్తువును సూచించినప్పుడు, ఆ వస్తువులో డేటా సభ్యులు ఉంటారు, మరియు మనకు తెలిసిన డేటా సభ్యులు, వాటిని ఆబ్జెక్ట్ యొక్క పాయింటర్ నుండి లేదా వస్తువు యొక్క సభ్యుల ఫంక్షన్ల నుండి యాక్సెస్ చేయవచ్చు.
 స్టాటిక్ డేటా సభ్యుడి పరంగా, విషయాలు చాలా భిన్నంగా ఉంటాయి.
 స్టాటిక్ డేటా సభ్యులు వస్తువుతో సంబంధం కలిగి ఉండరు; డేటా సభ్యులు వంటి వస్తువుకు సాధారణ డేటా సభ్యులు జతచేయబడతారు, కాని స్టాటిక్ డేటా సభ్యులు దీనికి విరుద్ధంగా ఉంటారు, వీటిలో తరగతి సభ్యులు శ్రేణికి జతచేయబడతారు.
 కాబట్టి, స్టాటిక్ డేటా సభ్యుడి యొక్క ముఖ్యమైన ఆస్తి ఏమిటంటే, ఏ తరగతి యొక్క స్టాటిక్ డేటా సభ్యుడితో సంబంధం లేకుండా, ఏ తరగతికి ఎన్ని ఉదాహరణలు సృష్టించబడతాయి.ఒక ఉదాహరణ మాత్రమే ఉంటుంది.
 కాబట్టి, ఇది తరగతిలోని అన్ని వస్తువులచే పంచుకోబడుతుంది.
 వాస్తవానికి, వ్యక్తిగత సందర్భాల్లో మనం చూసే ఆసక్తికరమైన విషయం ఏమిటంటే, తరగతికి వస్తువు లేనప్పుడు కూడా స్టాటిక్ డేటా సభ్యుడు ఉండగలడు.
 కాబట్టి, స్టాటిక్ సభ్యుని యొక్క ఉద్దేశ్యం ప్రధానంగా తరగతికి ప్రత్యేకమైన డేటాను నిర్వహించడానికి డేటాను నిలుపుకోవడం, కానీ ప్రతి సందర్భానికి ప్రత్యేకమైనది కాదు.
 మరియు చాలా ప్రోగ్రామింగ్ పరిస్థితులు ఉన్నాయని మేము చూస్తాము, అలాంటి స్టాటిక్ డేటా సభ్యుడు నిజంగా సహాయపడే అనేక సమస్యలు.
 మీలో జావాతో పరిచయం ఉన్నవారికి, ఉదాహరణ వేరియబుల్ మాదిరిగా కాకుండా, స్టాటిక్ డేటా సభ్యుడు జావాలో క్లాస్ వేరియబుల్, ఇది సి ++ లో సాధారణ నాన్-స్టాటిక్ డేటా సభ్యుడు. డేటా సభ్యుడు.
 స్టాటిక్ డేటా సభ్యుడి కోసం, మేము కొన్ని అదనపు అడ్డంకులను చూస్తాము; సాధారణ డేటా సభ్యుల మాదిరిగా తరగతి లోపల స్టాటిక్ డేటా సభ్యులను ప్రకటించినట్లు మనం చూస్తాము.
 ఇది తరగతి వెలుపల నిర్వచించాల్సిన అవసరం ఉంది, ఇది స్టాటిక్ డేటా సభ్యునికి మెమరీ బైండింగ్, ఇది తరగతి వెలుపల చేయాలి, సాధారణంగా ఒక సోర్స్ ఫైల్‌లో, ఇది ప్రారంభించబడుతుంది. చేయవచ్చు.
 మరియు ఆసక్తికరమైన విషయం ఏమిటంటే ఇది ఖచ్చితంగా స్టాటిక్ సభ్యుడు, డేటా సభ్యుడు ఒక వస్తువు కావచ్చు.
 కాబట్టి, స్టాటిక్ డేటా సభ్యుడు కూడా ఒక వస్తువు.
 ప్రధాన పని ప్రారంభమయ్యే ముందు స్టాటిక్ డేటా సభ్యులు సృష్టించబడతారు; ఇది మీరు మునుపటి సందర్భాలలో చూడని విషయం.
 మేము అమలు చేయడం ప్రారంభించినప్పుడు, ప్రధానమైనది వస్తువు (లు) నిర్మించడం ప్రారంభించినప్పుడు, కాని స్టాటిక్ సభ్యులను సృష్టించవచ్చు లేదా ప్రధాన ప్రారంభానికి ముందు సృష్టించబడుతుంది మరియు సుష్టంగా ఉంటాయి అవి ప్రధానమైన తర్వాత పూర్తవుతాయి. వాపసు.
 కాబట్టి, మేము దీనిని ఉదాహరణ ద్వారా చూస్తాము, స్టాటిక్ డేటా సభ్యుడు పబ్లిక్ లేదా ప్రైవేట్ కావచ్చు ఏదైనా యాక్సెస్ స్పెసిఫైయర్ కోసం.
 ఇప్పుడు స్టాటిక్ డేటా సభ్యుడిని యాక్సెస్ చేసే విషయంలో మనం క్లాస్ పేరును ఉపయోగించాల్సి ఉంటుంది ఎందుకంటే నేను ఇక్కడ ఇప్పటికే చెప్పినట్లుగా ఇది క్లాస్‌తో సంబంధం కలిగి ఉంది మరియు ఒక వస్తువుతో కాదు. (ఆబ్జెక్ట్) తో.
 కాబట్టి, స్టాటిక్ డేటా సభ్యులను యాక్సెస్ చేయడానికి నిర్దిష్ట ఆబ్జెక్ట్ డాట్‌ను యాక్సెస్ చేయడానికి సంజ్ఞామానం ఉత్తమ మార్గం కాదు.
 క్లాస్ అనే పెద్దప్రేగు-పెద్దప్రేగు లేదా స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ను ఉపయోగించడం ద్వారా వాటిని యాక్సెస్ చేస్తారు.
 మరియు వాడుక పరంగా, స్టాటిక్ డేటా సభ్యులు గ్లోబల్ వేరియబుల్స్ మాదిరిగానే ఉండరు.
 గ్లోబల్ స్కోప్‌లో గ్లోబల్ వేరియబుల్స్ ఉనికిలో ఉన్న ఏకైక తేడా లేదా ముఖ్యమైన తేడా ఏమిటంటే, స్టాటిక్ డేటా సభ్యుడు (స్కోప్) డేటా సభ్యుడు) తరగతి పరిధిలో స్టాటిక్ మెంబర్ సభ్యుడు ఉంటాడు.
 అందువల్ల, ప్రోగ్రామ్‌లో ఏదైనా గ్లోబల్ డేటా ఉండవలసిన అవసరాన్ని అవి తొలగిస్తాయి.
 కాబట్టి, ఈ పరిచయంతో, ఒక సాధారణ ఉదాహరణ ద్వారా మీకు చెప్తాను, ఆపై ఈ అంశాలు మరింత స్పష్టంగా తెలుస్తాయి.
 ఇది స్టాటిక్ డేటా సభ్యునికి ఉదాహరణ; ఇది చాలా సులభమైన కేసు.
 కాబట్టి, నా దగ్గర ఉన్నదంతా ఒక తరగతి, ఇది ఈ తరగతిని చాలా అర్ధవంతం చేయని విషయం, దీనిని నా తరగతి పిలుస్తారు మరియు దీనికి సాధారణ డేటా సభ్యుడు ఉన్నారు. Int x.
 కాబట్టి, ఎడమ కాలమ్‌లో, మీరు చూసేది స్టాటిక్ సభ్యుడిని ఉపయోగించదు.డేటా సభ్యులు మరియు సభ్యుల ఫంక్షన్ల పరంగా మీరు ఇంతకు ముందు పరిచయం చేయబడ్డారు.
 కాబట్టి, x అనేది డేటా సభ్యుడు, x వద్ద 15 నుండి ప్రారంభమయ్యే సభ్యుల ఫంక్షన్.
 మరియు ప్రింట్ మెంబర్ ఫంక్షన్ ఉంది, ఇది x యొక్క ప్రస్తుత విలువను తీసుకుంటుంది, దానిని పెంచుతుంది లేదా దానికి 10 ని జోడిస్తుంది, ఆపై ఆ విలువను ప్రింట్ చేస్తుంది.
 కాబట్టి, ఇది మేము చేయడానికి ప్రయత్నిస్తున్న సాధారణ విషయం.
 కాబట్టి, ఇప్పుడు మనం ఇక్కడ అప్లికేషన్ కోడ్‌ను పరిశీలిస్తే, ఆబ్జెక్ట్ 1 మరియు ఆబ్జెక్ట్ 2 అనే రెండు వస్తువులను సృష్టిస్తున్నాము, మీరు చూడగలిగినట్లుగా క్లాస్‌లో కన్స్ట్రక్టర్ లేరు.
 కాబట్టి, ఉచిత డిఫాల్ట్ కన్స్ట్రక్టర్ ఉపయోగించబడుతుందని మాకు తెలుసు; మరియు ఆ కన్స్ట్రక్టర్ ద్వారా, x ఒక నిర్దిష్ట విలువకు కేటాయించబడదు.
 కాబట్టి, మేము ఆబ్జెక్ట్ 1 ను పిలుస్తాము.
 కాబట్టి, మనం ఇక్కడ ఆబ్జెక్ట్ 1 వద్దకు వస్తే, ఆబ్జెక్ట్ 1 కోసం, కాబట్టి నేను దానిలో డ్రా చేయగలిగితే, ఇది నా ఆబ్జెక్ట్ 1, ఇది నా ఆబ్జెక్ట్ (ఆబ్జెక్ట్) 2, కాబట్టి రెండింటిలో నాకు x ఉంది.
 నేను ఆబ్జెక్ట్ 1 ను పొందినప్పుడు, అది 15 అవుతుంది; నేను ఆబ్జెక్ట్ 2 కోసం వచ్చినప్పుడు, అది 15 అవుతుంది, ఆపై నేను ప్రింట్ చేస్తే, ఆబ్జెక్ట్ ఒకదానికి ప్రింట్‌ను పిలుస్తుంది, కాబట్టి ఇది ప్రింట్ చేస్తుంది (ప్రింట్) ఈ విలువను 15 గా తీసుకుంటుంది ఎందుకంటే ఇక్కడ దీనికి 10 జోడించండి.
 కాబట్టి, ఇది 25 అవుతుంది, అందువల్ల, ఇది 25 ను ప్రింట్ చేస్తుంది.
 ఇది x 25 ముద్రణకు సమానం.
 అదేవిధంగా, ఆబ్జెక్ట్ 2 కోసం మళ్ళీ ప్రింట్ చేయండి, ఇది మళ్ళీ 15 అని అనుకుంటుంది, ఇది 15 కి 10 ని జతచేస్తుంది, ఎందుకంటే నేను ప్రింట్, విలువ 25 అని పిలిచాను మరియు ఇది ప్రింట్.
 కాబట్టి, మీరు ఈ ప్రవర్తనను చూస్తే, ఈ ప్రవర్తన మీ కోసం ఇప్పటికే స్పష్టంగా ఉంది.
 కాబట్టి, నేను ఆబ్జెక్ట్స్ 1 మరియు ఆబ్జెక్ట్ 2 లతో ఒకే పని చేస్తున్నానని మీకు తెలుస్తుంది, అందువల్ల, రెండూ x కోసం ఒకే విలువను 25 ప్రింట్ చేస్తాయి.
 ఇప్పుడు, మనం స్టాటిక్ డేటా మెంబర్‌ను ఉపయోగించడానికి ప్రయత్నిస్తున్న కుడి కాలమ్‌ను చూద్దాం.
 కాబట్టి, నేను స్టాటిక్ సభ్యుడిని ఎలా ఉపయోగించగలను, అంతకుముందు నేను int x అని చెప్తున్నాను, ఇప్పుడు నేను స్టాటిక్ int x అని చెప్తున్నాను.
 అందువల్ల, నేను డేటా సభ్యుల ప్రకటనకు స్టాటిక్ కీవర్డ్‌ను ప్రిఫిక్స్ చేసాను.
 కాబట్టి, ఇది నాన్-స్టాటిక్ డిక్లరేషన్, ఇది ఇప్పుడు స్టాటిక్ డిక్లరేషన్ గా మారింది.
 ఇప్పుడు వ్యత్యాసం ఏమిటంటే, నేను నాన్-స్టాటిక్ డేటాతో ఉన్న వైపు ఉంటే, నేను 1 ఆబ్జెక్ట్, ఆబ్జెక్ట్ 2, డేటా మెంబర్ x, డేటా మెంబర్ (డేటా మెంబర్) x ను పొందుతాను. పంక్తి, నాకు ఆబ్జెక్ట్ 1 ఉంది, నాకు ఆబ్జెక్ట్ 2 ఉంది, కానీ ఆబ్జెక్ట్ 1 మరియు ఆబ్జెక్ట్ 2 ఎక్స్‌లోని ఏవైనా వస్తువులు డేటా సభ్యుడి రూపంలో లేవు ఎందుకంటే x ఒక స్టాటిక్ డేటా సభ్యుడు మరియు నిర్దిష్ట వస్తువుతో సంబంధం లేదు. కాబట్టి, మైక్లాస్ :: x, నా క్లాస్ :: x అనే మరో వస్తువు ఉంది, ఇది ఈ తరగతి యొక్క స్టాటిక్ డేటా సభ్యుడు x.
 కాబట్టి, నేను నిర్వచించిన క్షణం స్థిరంగా ఉందని, నా డేటా సభ్యుడు ఆబ్జెక్ట్ యొక్క భాగం కాదని, ఆబ్జెక్ట్ పార్ట్ 1 లేదా ఆబ్జెక్ట్ (ఆబ్జెక్ట్) 2 లో ఒక భాగం కాదని మీరు చూడవచ్చు, కానీ అది ఒక ప్రత్యేక స్థలం అవుతుంది, అది ప్రత్యేక వస్తువు అవుతుంది.
 ఇప్పుడు x అని పేరు పెట్టని ఏకైక విషయం మైక్లాస్: x అంటే అది క్లాస్ పేరుతో అర్హత పొందింది మరియు నేను దానిని ఎలా యాక్సెస్ చేస్తాను.
 కాబట్టి, నేను కలిగి ఉన్న అదే అనువర్తనాన్ని ఉపయోగించి నేను దానిని ఉపయోగించటానికి ప్రయత్నించినప్పుడు, ఈ అనువర్తనానికి మరియు ప్రధానంగా ఈ అనువర్తనానికి తేడా లేదు.
 మనం చూసినట్లుగా వస్తువులు సృష్టించబడతాయి.
 నాకు లభిస్తుంది, కాబట్టి x 15 కి కేటాయించబడుతుంది. 
 కాబట్టి, దీని అర్థం x, x అంటే x ఇక్కడ మైక్లాస్ యొక్క x, కాబట్టి ఇది వేరియబుల్.
 కాబట్టి, ఇది 15 అవుతుంది.
 ఇది స్థిర విలువ 15 అవుతుంది.
 ఆబ్జెక్ట్ 2 ను పొందడానికి నేను ఎగ్జిక్యూట్ చేస్తాను, అదే x 15 ని కేటాయించబడుతుంది, ఎందుకంటే x స్టాటిక్. ఇది రెండు వస్తువుల మధ్య సాధారణం.
 కాబట్టి, x రెండుసార్లు 15 కు సెట్ చేయబడింది.
 ఇప్పుడు నేను ఆబ్జెక్ట్ 1 కోసం ప్రింట్ అని పిలుస్తాను, కాబట్టి x యొక్క విలువ 15 మరియు 10 దానికి జోడించబడుతుంది, కాబట్టి x యొక్క విలువ ఇప్పుడు 25 అవుతుంది, ఎందుకంటే 10 జోడించబడింది మరియు ప్రింట్ చేయబడే విలువ.
 కాబట్టి, నేను obj1.print x 25 గా ముద్రించినప్పుడు.
 ఈ సమయం వరకు, నాన్-స్టాటిక్ కేసు నుండి ప్రవర్తనలో తేడా లేదు.
 ఆబ్జెక్ట్ 2 కు ప్రింట్ వర్తించినప్పుడు తదుపరిదాన్ని పరిగణించండి.
 ఆబ్జెక్ట్ 2 కోసం ముద్రణను పిలిచినప్పుడు, x యొక్క విలువ ఇప్పుడు 25, ఇది ఇకపై పదిహేను కాదు.
 కాబట్టి, ఇది 10 కు జోడిస్తుంది, ఇప్పుడు అది 35 అవుతుంది మరియు x ఇప్పుడు 35 అవుతుంది.
 అందువల్ల, నేను ఈ ముద్రణ పద్ధతి ప్రకారం ముద్రించినప్పుడు, నేను ముద్రించే విలువ 35 అవుతుంది, ఎందుకంటే స్టాటిక్ ఆబ్జెక్ట్ రెండూ ఆబ్జెక్ట్.
 అందువల్ల, నేను రెండుసార్లు ముద్రణను, ఒకసారి ఆబ్జెక్ట్ 1 ద్వారా, మరియు ఒకసారి ఆబ్జెక్ట్ 2 ద్వారా, 10 విలువ x కు రెండుసార్లు జోడించబడుతుంది.
 కాబట్టి, అంతకుముందు ఇది 25; రెండవ సందర్భంలో, ఇప్పుడు స్టాటిక్ డేటా సభ్యుడితో, ఇది 35 అవుతుంది, కాబట్టి ఇది మనం నేర్చుకోవలసిన స్టాటిక్ డేటా సభ్యుడి ప్రాథమిక ప్రవర్తన.
 అందువల్ల, x ఒక స్టాటిక్ డేటా సభ్యుడు అని మేము గుర్తించాము, అవి ఎలా పంచుకున్నాయో మనం చూసిన రెండు వస్తువుల ద్వారా భాగస్వామ్యం చేయబడతాయి.
 మరియు ఈ తదుపరి పాయింట్ చాలా ముఖ్యం, ఈ విషయాన్ని వివరిస్తాను.
 మీరు ఇక్కడ స్టాటిక్ కీవర్డ్ కాకుండా రెండు ప్రోగ్రామ్‌లను పోల్చినట్లయితే, అదనపు లైన్ ఉంది.
 డేటా సభ్యుడు స్టాటిక్ అని చెప్పినప్పుడు, ఇది దాదాపు డిక్లరేషన్ అని, అంటే ఈ వేరియబుల్ పేరు x ఈజ్ అని చెప్తున్నట్లు అది నిర్వచించిందని, ఇది క్లాస్ వేరియబుల్ అని మేము అంటున్నాము.
 దీనికి ఉదాహరణ తరగతికి ఉంటుంది, ఈ రకం పూర్ణాంకానికి చెందినది, కానీ ఇది ఈ వేరియబుల్‌తో ఏ మెమరీని అనుబంధించదు.
 ఇది నాన్-స్టాటిక్ అయినప్పుడు, నేను దాని గురించి పట్టించుకోను, ఎందుకంటే ఇది స్టాటిక్ కానిది అయితే, ఆబ్జెక్ట్ 1 లాగా ఏదో ఒక సమయంలో ఏదో ఒక వస్తువు వెంటనే కనుగొనబడుతుందని నాకు తెలుసు; మరియు ఆబ్జెక్ట్ 1 యొక్క శీఘ్ర మూల్యాంకనం ఉన్నచోట, x దానిలో ఒక భాగం అవుతుంది.
 కాబట్టి, ఆబ్జెక్ట్ 1 యొక్క ఆవశ్యకత ద్వారా x దాని జ్ఞాపకశక్తిని పొందుతుంది, కాని స్టాటిక్ విషయంలో ఇది కేవలం డిక్లరేషన్ మాత్రమే, ఎందుకంటే ఆబ్జెక్ట్ 1 వెంటనే కనుగొనబడినప్పుడు క్లాస్ (క్లాస్) వేరియబుల్ x ఈ వస్తువులో భాగం కాదు.
 కాబట్టి, నేను ఒక మెమరీని సృష్టించాలి లేదా ఈ డేటా సభ్యునికి మెమరీని బంధించాలి - స్టాటిక్ డేటా సభ్యుడు విడిగా మరియు ఇది ఒక నిర్వచనం అని పిలుస్తారు, దీని ద్వారా నేను దానిని తయారు చేస్తాను.
 కాబట్టి, ఈ నిర్వచనం ఇది గ్లోబల్ స్కోప్‌లో జరిగిందని చెప్తుంది, ఇది వేరియబుల్ మైక్లాస్ :: x, క్లాస్ (క్లాస్) పేరు :: వేరియబుల్ పేరు అని చెప్పాను.
 రకం పూర్ణాంకానికి ఉంది.
 కాబట్టి, ఒక రకం వ్యత్యాసం ఉందని నేను చెప్తున్నాను మరియు నేను ఇక్కడ ఉంచిన ప్రారంభాన్ని 0 గా ఉంచాను.
 ఇది స్టాటిక్ డేటా సభ్యుడిని నిర్వచించడం.
 అందువల్ల, మీరు స్టాటిక్ డేటా సభ్యుడిని కలిగి ఉన్న ప్రోగ్రామ్‌ను వ్రాస్తే, మరియు మీరు అలా చేయకపోతే, దాన్ని చొప్పించవద్దు, కంపైలర్ ఇది ఒక ప్రత్యేక స్టాటిక్ డేటా సభ్యుడు అని ఏడుపు ప్రారంభిస్తుంది. సభ్యుడు) మైక్లాస్: x నిర్వచించబడలేదు , అందువలన జ్ఞాపకశక్తి లభించదు.
 కాబట్టి, స్టాటిక్ డేటా సభ్యుడి కోసం మీరు గుర్తుంచుకోవలసిన ప్రత్యేకత ఏమిటంటే వారికి ప్రత్యేక నిర్వచనం అవసరం మరియు ప్రోగ్రామ్ పనిచేయడం ప్రారంభించినప్పుడు ప్రారంభించాలి.
 కాబట్టి, అది ఎప్పుడు అమలు చేస్తుంది, x విలువ 0 ను ఎప్పుడు పొందుతుంది, అది ప్రధాన ప్రారంభంలో ప్రారంభమయ్యే ముందు విలువ 0 ను పొందుతుంది.
 కాబట్టి, మేము ప్రోగ్రామ్‌ను అమలు చేయడం ప్రారంభించినప్పుడు, మొదట అన్ని తరగతుల స్టాటిక్ డేటా సభ్యులు (స్టాటిక్ డేటా సభ్యులు) సృష్టించబడతారు మరియు ప్రారంభించబడతారు మరియు అప్పుడు మాత్రమే కోర్ పనిచేయడం ప్రారంభిస్తుంది.
 అదేవిధంగా, ఆ తర్వాత మాత్రమే ప్రధాన ముగుస్తున్నప్పుడు, అన్ని తరగతుల స్టాటిక్ డేటా సభ్యులు వారు సృష్టించిన రివర్స్ క్రమంలో నాశనం అవుతారు.
 వాస్తవానికి, ఈ ప్రత్యేక ఉదాహరణలో, మీరు ఆ సృష్టి, విధ్వంసం ప్రక్రియను చూడలేరు, ఎందుకంటే ఈ సందర్భంలో స్టాటిక్ డేటా సభ్యుడు అంతర్నిర్మిత రకం, ఇక్కడ స్పష్టమైన కన్స్ట్రక్టర్ (కన్స్ట్రక్టర్) లేదా డిస్ట్రక్టర్ అందుబాటులో లేదని మాకు తెలుసు .
 కాబట్టి, మేము దీనితో ముందుకు వెళ్తాము మరియు కొంచెం పెద్ద ఉదాహరణను చూడండి, స్టాటిక్ డేటా సభ్యుడిని ఉపయోగించటానికి మరింత వాస్తవిక ఉదాహరణ.
 కాబట్టి, మేము ఇక్కడ ఏమి చేయటానికి ప్రయత్నిస్తున్నాము, మేము ప్రతి ప్రింటింగ్ ఉద్యోగంలో ముద్రించడానికి చాలా పేజీలను కలిగి ఉన్న క్లాస్ ప్రింట్ జాబ్‌ను సృష్టిస్తున్నాము.
 నేను ప్రింట్ జాబ్ ఆబ్జెక్ట్‌ని సృష్టించినప్పుడు, ఈ ఉద్యోగంలో ఎన్ని పేజీలు ఉండాలో నాకు తెలుసు.
 ఇప్పుడు నేను దీని ద్వారా ఏమి ట్రాక్ చేయాలనుకుంటున్నాను? ఈ ప్రింట్ ఉద్యోగాలన్నీ వాస్తవానికి ప్రింటర్ అని నేను am హిస్తున్నాను, కాని ప్రింటింగ్‌ను నిప్పు పెడుతుంది.
 అందువల్ల, ప్రింట్ ఉద్యోగాలు వాస్తవానికి అక్కడకు వెళ్తాయి.
 అందువల్ల, నేను రెండు నోటిఫికేషన్‌లను ట్రాక్ చేయాలనుకుంటున్నాను; ప్రస్తుతం, ఎన్ని వేర్వేరు ప్రింట్ ఉద్యోగాలు ఉన్నాయి, కాబట్టి నేను ఆ n ఉద్యోగం అని పిలుస్తాను.
 ఇప్పుడు సహజంగానే ఎన్ని ఉద్యోగాలు ప్రింటింగ్ కోసం సిద్ధంగా ఉన్నాయి, ఇది నిర్దిష్ట ఉద్యోగంపై ఆధారపడదు, ఇది పైన ఉన్న మొత్తం ప్రింట్ జాబ్ వస్తువుల సంఖ్యపై ఆధారపడి ఉంటుంది. ఇవి నిర్మించబడ్డాయి.
 కాబట్టి, ఇది తరగతి స్థాయిలో ఉన్న ఆస్తి, ఇది స్టాటిక్ ఆస్తి మరియు అందువల్ల నేను దీనిని స్టాటిక్ ఇంట్ జాబ్స్ అని పిలుస్తాను.
 అదేవిధంగా, నా ప్రింటర్‌లో నిర్దిష్ట సంఖ్యలో పేజీలు లోడ్ చేయబడిన ప్రింటింగ్ ట్రే ఉన్నందున, ఆ ట్రేలో ఎన్ని పేజీలు మిగిలి ఉన్నాయో నేను ట్రాక్ చేయాలనుకుంటున్నాను.
 కాబట్టి, నేను ఒక n ట్రే పేజ్ డేటా సభ్యుడిని సృష్టిస్తాను, నేను కూడా స్టాటిక్ చేస్తాను, ఎందుకంటే ఇది ఒక నిర్దిష్ట ఉద్యోగానికి ప్రత్యేకమైనది కాదు, కానీ ఇది మొత్తం ప్రింట్ జాబ్ క్లాస్ కోసం. 
 ట్రేలో ఎన్ని పేజీలు మిగిలి ఉన్నాయో ప్రత్యేకంగా చెప్పండి.
 దీనితో, ఇప్పుడు సహజంగా ఇక్కడ కాబట్టి ఈ ఇద్దరు స్టాటిక్ డేటా సభ్యులు ఈ సమయంలో సృష్టించబడ్డారు మరియు ప్రారంభించబడ్డారు మరియు తరువాత నేను చాలా పని చేస్తాను.
 నేను మొదట n ఉద్యోగాల విలువను ప్రింట్ చేస్తాను, అది ఇక్కడ 0 అవుట్‌పుట్‌గా ఉండాలి, ఆపై ట్రేలో ఉన్న పేజీల సంఖ్యను ప్రింట్ చేస్తాను. ప్రారంభంలో 500 తో.
 అందువల్ల, అవుట్పుట్ 500 ఉండాలి, ఆపై నేను ఉద్యోగం యొక్క ముద్రణ వస్తువును సృష్టిస్తాను.
 అందువల్ల, నా ఉద్యోగాల సంఖ్యను 1 పెంచాలి మరియు ఈ ఉద్యోగాన్ని ముద్రించడానికి నా మిగిలిన పేజీల సంఖ్యను పేజీల సంఖ్య నుండి తీసివేయాలి.
 కాబట్టి, దీనిని 10 నుండి తీసివేయాలి.
 కాబట్టి, ఈ వస్తువును సృష్టించిన తరువాత, నేను ఉద్యోగాలు మరియు ప్రస్తుతం అందుబాటులో ఉన్న పేజీలను ముద్రించినప్పుడు, నాకు ఉద్యోగం లభిస్తుంది, ఇప్పుడు 0 నుండి 1 ఇంక్రిమెంట్ జరుగుతుంది, మరియు మిగిలిన పేజీల సంఖ్య 490 వరకు ఉంది, ఇది 500 విలువ నుండి 10 కి తగ్గించబడింది .
 అప్పుడు నేను ఈ ప్రత్యేక పరిధికి వచ్చాను, అక్కడ నేను మరో రెండు వస్తువులను సృష్టించి, ఆపై ఉద్యోగాల విలువ ఏమిటో చూస్తాను, మరియు పేజీల సంఖ్య 3 అవుతుంది, ఎందుకంటే రెండు మరియు ముద్రణ కార్యకలాపాలు కొనసాగుతున్నాయి మరియు పేజీల సంఖ్య మరింత తగ్గుతుంది 30 మరియు 20 వరకు.
 కాబట్టి, ఇది 30 నుండి 460 వరకు, 20 నుండి తక్కువ, 440 వరకు వెళుతుంది, కాబట్టి మిగిలిన పేజీల సంఖ్య అది.
 ఆపై నేను 100 పేజీలను లోడ్ చేస్తున్నట్లుగా, ట్రేలోని పేజీల సంఖ్యను 100 పెంచుతాను, కాబట్టి నా పేజీల సంఖ్య 440 ఉండాలి.
 ఆపై నేను ఈ దశకు వచ్చాను మరియు స్కోప్ బయటకు వెళ్తున్నందున, ఈ ఆబ్జెక్ట్ జాబ్ 1 మరియు స్కోప్ చేసిన ఈ ఆబ్జెక్ట్ జాబ్ 2 నాశనం అవుతాయని మీరు బాగా అర్థం చేసుకోవచ్చు.
 అందువల్ల, అవి నాశనమైతే, ఉద్యోగాల సంఖ్య 3 నుండి 1 కి తగ్గుతుంది.
 కాబట్టి, నేను ఇక్కడ ప్రింట్ చేసినప్పుడు నాకు ఉద్యోగం ఉంది, మరియు మిగిలిన పేజీల సంఖ్యను ప్రింట్ చేసినప్పుడు, నేను మరో 100 పేజీలను లోడ్ చేసాను, కాబట్టి ఇది 540 లో సంఖ్య అవుతుంది, ఇది ఈ విధంగా ప్రవర్తిస్తుంది.
 అందువల్ల, స్టాటిక్ డేటా సభ్యులను ఉపయోగించి, ఈ ప్రోగ్రామ్‌లో నేను ప్రతి ఉద్యోగానికి ప్రత్యేకమైన కొన్ని సమాచారాన్ని ట్రాక్ చేయగలను, కాని ఇది మొత్తం ప్రింట్ ఉద్యోగాల సేకరణ. దీనికి ప్రత్యేకమైనది, ప్రస్తుతం పనిచేస్తున్న ప్రింట్ ఉద్యోగాల సంఖ్య; ఇది ప్రాథమికంగా వ్యవస్థలో ప్రస్తుతం ఉన్న తరగతి యొక్క వస్తువు (ల) సంఖ్యను మరియు నేను తారుమారు చేస్తున్న ట్రేలోని పేజీల సంఖ్యను లెక్కించే ప్రపంచ వనరు.
 కాబట్టి, ఇది స్టాటిక్ డేటా సభ్యుని యొక్క సాధారణ ఉపయోగం.
 ఇప్పుడు సహజంగా మీరు ఇక్కడ చూడగలిగినట్లుగా స్టాటిక్ డేటా సభ్యులు పబ్లిక్ దృశ్యమానత స్థలంలో ఉన్నారు, కాబట్టి నా అప్లికేషన్ మారుతున్న వెంటనే, ఎవరైనా వాస్తవానికి వచ్చి ఈ విలువలను మార్చవచ్చు ఇంక్రిమెంట్ లేదా క్షీణత పరంగా కొత్త విలువను లేదా మార్పును మాత్రమే అందించగలదు.
 కాబట్టి, నేను తదుపరి చేయడానికి ప్రయత్నించాలి, వాటిని ప్రైవేట్‌గా చేయడానికి ప్రయత్నించండి, తద్వారా వాటిని నేరుగా మార్చలేరు.
 ఇప్పుడు నేను వాటిని ప్రైవేట్‌గా చేస్తే ఒక ప్రశ్న వస్తుంది, నేను దానిని ఎలా మార్చగలను? నేను దీన్ని ఇకపై మార్చలేను, ఎందుకంటే నేను దీన్ని ప్రైవేట్‌గా చేస్తే, సహజంగానే నేను ట్రేల సంఖ్య లేదా ట్రేలోని పేజీల సంఖ్యను మార్చలేను.
 కాబట్టి, నాకు కొన్ని విధులు అవసరం, నాకు సభ్యుల విధులు ఉన్నాయి, ఇవి డేటా సభ్యులను మార్చగలవు, నాకు స్టాటిక్ డేటా సభ్యుల విలువలు ఉన్న ఫంక్షన్లు కావాలి. మార్చవచ్చు
మరియు ఇది స్టాటిక్ మెంబర్ ఫంక్షన్ల భావనకు మనలను తీసుకువస్తుంది.
 ఇప్పుడు, స్టాటిక్ మెంబర్ ఫంక్షన్ల గురించి ముఖ్యమైన విషయం ఫంక్షన్ల మాదిరిగానే ఉంటుంది.
 అవి ముందు స్టాటిక్ కీవర్డ్‌తో వ్రాయబడ్డాయి, కాని ఈ పాయింటర్‌లో కాకుండా స్టాటిక్ మెంబర్ మెంబర్ ఫంక్షన్ లేని ఇతర సభ్యుల ఫంక్షన్లతో తేడా ముఖ్యమైనది.
 ఎందుకంటే, స్టాటిక్ డేటా మెంబర్ వలె, స్టాటిక్ మెంబర్ మెంబర్ ఫంక్షన్ కూడా ఏ వస్తువుతోనూ సంబంధం కలిగి ఉండదు, ఇది క్లాస్‌తో మాత్రమే సంబంధం కలిగి ఉంటుంది ఎందుకంటే ఇది ఆబ్జెక్ట్‌తో సంబంధం కలిగి ఉండదు, ఇది ఈ పాయింటర్ యొక్క ఆబ్జెక్ట్ చిరునామాను కలిగి ఉండదు.
 అందువల్ల, ఫలితం తదుపరి వివరణ ఎందుకంటే ఇది ఈ పాయింటర్‌లో లేదు, ఇది వస్తువు యొక్క డేటా సభ్యుల చిరునామాను తెలుసుకోదు, ఎందుకంటే ఇది ఏ వస్తువును సూచించదు.
 కాబట్టి, ఇది తరగతి యొక్క నాన్-స్టాటిక్ డేటా సభ్యులను యాక్సెస్ చేయలేము.
 ఇది తరగతి యొక్క నాన్-స్టాటిక్ మెంబర్ ఫంక్షన్లను ప్రారంభించదు ఎందుకంటే వారందరికీ ఈ పాయింటర్ అవసరం.
 కాబట్టి, ఈ పాయింటర్‌లో లేకపోవటం యొక్క ఒక పరిణామం ఏమిటంటే, స్టాటిక్ మెంబర్ ఫంక్షన్ వాటిలో దేనినీ యాక్సెస్ చేయదు.
 కాబట్టి, మీరు స్టాటిక్ మెంబర్ ఫంక్షన్‌ను ఎలా ఉపయోగిస్తున్నారు, మీరు స్టాటిక్ డేటా సభ్యుడిలా ఉన్నారు, మీరు స్టాటిక్ మెంబర్ ఫంక్షన్ అని పిలువబడే క్లాస్ పేరును ఉపయోగిస్తారు. (ఫంక్షన్), ఇది క్లాస్ పేరు: స్కోప్ రిజల్యూషన్ ఆపరేటర్ క్లాస్ పేరు కొలోన్-కోలన్, సభ్యుల ఫంక్షన్ పేరు.
 ఇప్పుడు, మనకు అవి ఎందుకు అవసరమో నేను ఇప్పటికే చెప్పడం మొదలుపెట్టాను, ఎందుకంటే నేను స్టాటిక్ డేటా సభ్యులను చదవడం మరియు వ్రాయడం కోరుకున్నాను.
 అయితే, మొదటి ఉదాహరణలో, స్టాటిక్ డేటా సభ్యులు ఎన్‌క్యాప్సులేషన్ సమస్యలను కలిగి ఉన్న పబ్లిక్ అని మేము చూపించాము? కాబట్టి, నేను స్టాటిక్ డేటా సభ్యులను (డేటా మెంబర్స్) ప్రైవేట్‌గా గుప్తీకరిస్తే, స్టాటిక్ మెంబర్ ఫంక్షన్లు మరియు స్టాటిక్ మెంబర్ ఫంక్షన్లను ఉపయోగించి నేను వాటిని మార్చగలను, చదవగలను మరియు వ్రాయగలను. 
 అవి క్లాస్ స్పెసిఫిక్ అయినందున, వారు క్లాస్ నిర్దిష్ట స్టాటిక్ డేటా సభ్యులను యాక్సెస్ చేయవచ్చు ( డేటా సభ్యులు) మరియు వాటిని కలిసి మార్చండి.
 కాబట్టి దీని అర్థం స్టాటిక్ డేటా సభ్యులు మరియు స్టాటిక్ మెంబర్ ఫంక్షన్లు మళ్ళీ ఇదే రకమైన ఎన్‌క్యాప్సులేషన్‌ను అమలు చేయడానికి నన్ను అనుమతిస్తాయి, అయినప్పటికీ క్లాస్ లెవెల్ నంబర్ వద్ద ఆబ్జెక్ట్ స్థాయిలో.
 నేను స్టాటిక్ డేటా సభ్యుడు స్టాటిక్ డేటా సభ్యుడు స్టాటిక్ మెంబర్ సభ్యుడు మరియు మన వద్ద ఉన్న స్టాటిక్ డేటా సభ్యులతో ఇలాంటి ఇడియమ్ సెట్‌ను సృష్టించగలను.
 స్టాటిక్ డేటా సభ్యుడు నాన్-స్టాటిక్ మెంబర్ మెంబర్ ఫంక్షన్‌తో ఉండలేరని ఏదో ఒక సమయంలో గమనించవచ్చు. స్టాటిక్ మెంబర్ ఫంక్షన్ (మెంబర్ ఫంక్షన్) అదే పేరు యొక్క నాన్-స్టాటిక్ మెంబర్ ఫంక్షన్ తో ఉండకూడదు, అది మీకు క్లాస్ యొక్క సభ్యుల ఫంక్షన్ (మెంబర్ ఫంక్షన్) ఉండకూడదు, అది స్టాటిక్, మరియు మరొకటి అదే పేరుతో స్టాటిక్ కానిది అనుమతించబడదు.
 మరియు స్టాటిక్ డేటా సభ్యులను ప్రసారం చేయలేము, ఇది ఈ పాయింటర్‌ను కలిగి ఉండకపోవటం యొక్క పరిణామం, ఎందుకంటే సభ్యుల ఫంక్షన్ ఒక కాన్స్టాంట్ కాదా అని మాకు తెలుసు, ఆపై ప్రాథమికంగా ఈ పాయింటర్ రకం మారుతుంది.
 ఈ పాయింటర్ స్టాటిక్ ఆబ్జెక్ట్‌కు పాయింటర్‌గా మారుతుంది, స్టాటిక్ మెంబర్ మెంబర్ ఫంక్షన్‌ను సూచించడానికి ఏ వస్తువు లేదు.అది స్థిరంగా పిలవడంలో అర్థం లేదు.
 దీనితో, మనం తిరిగి వెళ్లి, మన ప్రింట్ జాబ్ ఉదాహరణను మెరుగుపరుద్దాం.
 అందువల్ల, మేము ఇక్కడ ఏమి చేసాము, మేము స్టాటిక్ సభ్యులను తరగతి ప్రకటన యొక్క ప్రైవేట్ భాగానికి తరలించాము. 
 అందువల్ల, ఇప్పుడు ప్రధానంగా, మీరు వాటిని నేరుగా మార్చలేరు. వాటిని నేరుగా మార్చడం సాధ్యం కాదు, ఎందుకంటే అవి ఇప్పుడు ప్రైవేట్‌గా ఉన్నాయి.
 అందువల్ల, మేము వాటిని చదవడానికి లేదా వ్రాయడానికి ఉపయోగపడే స్టాటిక్ మెంబర్ ఫంక్షన్ల సమితిని ప్రవేశపెట్టాము, ఉదాహరణకు, GetJobs చదువుతుంది, ప్రస్తుతం ఎన్ని ఉద్యోగాలు ఉన్నాయి; చెక్‌పేజీలు చదివి, ట్రేలో ఎన్ని పేజీలు మిగిలి ఉన్నాయి; loadPages, దానిపై క్రొత్త పేజీలను లోడ్ చేస్తుంది మరియు మొదలైనవి.
 కాబట్టి, అదే ఉత్పత్తిని ఉత్పత్తి చేసే అదే అనువర్తనం అని మేము తిరిగి వ్రాసాము, కాని ఈ స్టాటిక్ డేటా సభ్యులను నేరుగా యాక్సెస్ చేయడానికి బదులుగా, మనం ఇప్పుడు స్టాటిక్ (స్టాటిక్) సభ్యులను కలిగి ఉండవచ్చు.) సభ్యుల ఫంక్షన్లను ఉపయోగిస్తుంది, ఎన్ని ఉద్యోగాలు ఉన్నాయో తెలుసుకోవాలనుకుంటున్నాను , నేను printJobs :: getJobs చేస్తాను. ఇది తరగతి పేరు :: స్టాటిక్ (స్టాటిక్) సభ్యుల ఫంక్షన్ పేరు అని మళ్ళీ గమనించండి.
 నేను ప్రింట్‌జాబ్స్: చెక్‌పేజీలు చేస్తున్న పేజీల సంఖ్యను తనిఖీ చేయాలనుకున్నప్పుడు మరియు అది నాకు మిగిలిన పేజీల సంఖ్యను ఇస్తుంది, ఈ ఫంక్షన్‌ను అమలు చేయడం ద్వారా ఇక్కడ నుండి మిగిలిన పేజీల సంఖ్యను నాకు ఇస్తానని క్షమించండి.
 వాస్తవానికి, ఈ స్టాటిక్ మెంబర్ ఫంక్షన్లలో ఏదీ ఈ సూచికను కలిగి లేదని దయచేసి గమనించండి.
 అందువల్ల, వారు నాన్-స్టాటిక్ డేటాను (స్టాటిక్ డేటా) యాక్సెస్ చేయలేరు, వాటిలో ఏవీ ఇప్పటికే ఉన్న nPages డేటా (డేటా) ను యాక్సెస్ చేయలేవు.
 వారు తరగతి కోసం ఉన్న స్టాటిక్ డేటాతో మాత్రమే పని చేయాలి.
 మీరు ఈ ఉదాహరణను మీరు ఈ ఉదాహరణ ద్వారా వెళ్ళగలిగే స్థాయికి తరలించవచ్చు మరియు మునుపటి సందర్భంలో మాదిరిగానే మాకు అదే కార్యాచరణ ఉందని మీరే వివరించండి, కాని మేము ఎన్‌క్యాప్సులేషన్ మెరుగుపరచగలుగుతాము.
 ఇప్పుడు మేము మూసివేసే ముందు, స్టాటిక్ సభ్యుల యొక్క నిర్దిష్ట ఉపయోగాన్ని గ్రహించే పరంగా మీకు త్వరగా చూపించాలనుకుంటున్నాను, దీనిని మేము సింగిల్టన్ క్లాస్ అని పిలుస్తాము.
 సింగిల్టన్ క్లాస్ అనేది ఒక రకమైన డిజైన్ నమూనా, ఇది ఒక తరగతిని సింగిల్టన్ అని పిలుస్తారు, ఆ సమయంలో మీకు ఒకే తరగతి మాత్రమే ఉంటే - ఒక సమయంలో ఒకే ఉదాహరణ.
 మొదట్లో, నాకు అలాంటి తరగతులు ఎందుకు అవసరమో కాస్త వింతగా అనిపిస్తుంది.
 మీరు ఆలోచించి, చుట్టూ చూస్తే, చాలా తరగతులు భారత రాష్ట్రపతిలా ప్రవర్తిస్తాయని మీరు కనుగొంటారు, భారతదేశంలో ఒక రాష్ట్రపతి మాత్రమే ఉన్నారు, భారతదేశానికి ఒక ప్రధానమంత్రి మాత్రమే ఉన్నారు, ఐఐటి ఖరగ్పూర్ యొక్క ఒక డైరెక్టర్ మాత్రమే సంభవిస్తారు. అనేక విభాగాలలో ఉదాహరణ.
 ఇప్పుడు నేను ఒక తరగతి ఇలా ఉండాలని కోరుకుంటే, అలాంటి తరగతిని ఎలా అమలు చేయాలి? ఒక ఉదాహరణగా ఉండలేని తరగతిని రూపొందించడం సహజంగానే సులభం.
 కన్స్ట్రక్టర్‌ను ప్రైవేట్‌గా చేయడానికి మీరు చేయాల్సిందల్లా.
 మీరు కన్స్ట్రక్టర్‌ను ప్రైవేట్‌గా చేస్తే, దాన్ని ఎవరూ పిలవలేరు మరియు అందువల్ల, మీకు ఆ తరగతి యొక్క ఏదైనా ఉదాహరణ ఉండకూడదు.
 కానీ మీరు ఒక వస్తువును మాత్రమే సృష్టించగలరని ఎలా నిర్ధారిస్తారు, కానీ ఒకటి కంటే ఎక్కువ వస్తువులు కాదు, కాబట్టి ఇది స్టాటిక్ డేటా సభ్యుడు మరియు స్టాటిక్ సభ్యుడు ఇది స్టాటిక్ మెంబర్ ఫంక్షన్‌ను ఉపయోగించి చాలా సులభంగా చేయవచ్చు.
 అందువల్ల, మీరు చేస్తున్నది ఒక తరగతి.
 కాబట్టి, ప్రింటర్‌ను సింగిల్‌టన్‌గా ఎలా తయారు చేయవచ్చో చూపించడానికి నేను ప్రయత్నిస్తున్నాను, అదే పరిస్థితి సంస్థలో ఉంది, నాకు బహుశా ఒక ప్రింటర్ మాత్రమే ఉంది.
 అందువల్ల, ఒకటి కంటే ఎక్కువ ప్రింటర్లను తక్షణం చూడకుండా చూసుకోవాలి.
 కాబట్టి, ప్రింటర్ తరగతిలో, ఇవి స్టాటిక్ కాని లక్షణాలు, అవి పరిపూర్ణత కోసం మాత్రమే; దాని గురించి చింతించకండి, కాని ఇక్కడ కన్స్ట్రక్టర్ ప్రైవేట్‌గా చేశారు.
 ఇది ప్రైవేట్ భాగంలో ఉందని చూడండి.
 కాబట్టి, ప్రింటర్ క్లాస్ యొక్క ఏదైనా వస్తువును నేరుగా సృష్టించలేరు.
 ఇది నిస్సందేహంగా, బహిరంగంగా ఉంచబడుతుంది; ఎందుకంటే కన్స్ట్రక్టర్ ప్రైవేట్ అయిన తర్వాత మీరు దానిని నిర్మించలేరు.
 కాబట్టి, డిస్ట్రాయర్ ఇంకా లోపల ఉండగలదు.
 ఇప్పుడు మీరు సృష్టించినది, మీరు స్టాటిక్ డేటా సభ్యుడిని పరిచయం చేస్తారు, ఇది ప్రింటర్‌కు సూచిక, మరియు ప్రైవేటులో కూడా ఉంచబడుతుంది, తద్వారా ఎవరూ దీన్ని నేరుగా చేయలేరు.
 కాబట్టి, మీ ఆలోచన ఏమిటంటే, ప్రింటర్ అయిన ఈ స్టాటిక్ డేటా సభ్యుడు :: myprinter ఇది నేను కలిగి ఉన్న అదే ప్రింటర్ వస్తువును సూచిస్తుంది.
 ఇప్పుడు, వాస్తవానికి, నేను ఈ ఏకైక ప్రింటర్ వస్తువును ఎలా సృష్టించాను.
 కాబట్టి, దాని కోసం, బహిరంగంగా, మీరు స్టాటిక్ మెంబర్ ఫంక్షన్‌ను పరిచయం చేస్తారు.
 ఈ సభ్యుల ఫంక్షన్‌ను ప్రింటర్ అంటారు.
 ఇప్పుడు అది ఏమిటంటే, మీకు ప్రింటర్ అవసరమైనప్పుడు, మీకు ప్రింటర్ ఆబ్జెక్ట్ అవసరమైనప్పుడు, మీరు నేరుగా వస్తువును యాక్సెస్ చేయడానికి ప్రయత్నించరు, ఎందుకంటే ఆ వస్తువు ఎక్కడ ఉందో మీకు తెలియదు.
 మీరు చేసే దానికి బదులుగా, మీరు ఈ నిర్దిష్ట స్టాటిక్ మెంబర్ ఫంక్షన్‌ను అమలు చేస్తారు, స్టాటిక్ మెంబర్ ఫంక్షన్ ఏమి చేస్తుంది, ప్రింటర్ పాయింటర్ శూన్యంగా ఉందా లేదా శూన్యంగా ఉందా అని మొదట్లో తనిఖీ చేస్తుంది
 ఇక్కడ, ప్రారంభంలో ఏమి జరుగుతుందో నేను నిర్వచించాను మరియు ప్రారంభించాను.
 కాబట్టి, ప్రారంభంలో ఈ సూచిక సున్నా అవుతుంది, ప్రింటర్ లేదు.
 ఇది సున్నా అయితే, మీరు ప్రింటర్‌ను సృష్టించి, పాయింటర్‌ను ఇక్కడ ఉంచండి.
 కాబట్టి, మీరు ప్రింటర్‌ను సృష్టించి ఇక్కడ ఉంచండి.
 ఈ ప్రత్యేకమైన స్టాటిక్ మెంబర్ ఫంక్షన్ ప్రింటర్‌ను సృష్టించగలదని ఇప్పుడు మీరు అనుకుంటున్నారు, ఎందుకంటే ఇది సభ్యుల ఫంక్షన్.
 అందువల్ల, ఇది ప్రైవేట్ సభ్యులను చేరుతుంది.
 అందువల్ల, ఇది క్రొత్త ప్రింటర్‌ను అందుకుంటుంది మరియు ఆ ప్రింటర్‌ను మీకు తిరిగి ఇస్తుంది.
 దీని తరువాత, మీరు ఈ నిర్దిష్ట స్టాటిక్ మెంబర్ ఫంక్షన్ అని పిలిచినప్పుడల్లా, మీరు దానిని సున్నా కానిదిగా కనుగొంటారు.
 అందువల్ల, మీరు ఈ ఉత్పాదక విధానాన్ని దాటవేస్తారు మరియు మీరు ఇంతకు ముందు సృష్టించిన ప్రింటర్‌ను ఎల్లప్పుడూ తిరిగి ఇస్తారు.
 ఈ ప్రక్రియలో, మొదటి కాల్ మాత్రమే ఈ ప్రింటర్ ఆబ్జెక్ట్‌లో కొత్త పని చేస్తుంది మరియు నేను మీకు ప్రింటర్ వస్తువును ఇస్తాను; ఆ సమయం నుండి, ప్రతిసారీ మనకు అదే వస్తువు తిరిగి వస్తుంది.
 కాబట్టి, మీరు దీనిని ఉపయోగంలో చూస్తే మీరు ప్రింట్ ఫంక్షన్ చేయాలనుకుంటున్నారు, కాబట్టి ప్రింటర్ కోలన్ కోలన్ ప్రింటర్ (ప్రింటర్) ఈ భాగం అంటే ఈ సభ్యుల ఫంక్షన్ అని మీరు అంటున్నారు.
 కాబట్టి, ఈ సభ్యుల ఫంక్షన్ అప్పుడు ప్రింట్ అవుతుంది, కాబట్టి ఇది ప్రింటర్ మనస్సును మీకు తిరిగి ఇస్తుంది. ఇది రిఫరెన్స్ ద్వారా తిరిగి వస్తుంది.
 కాబట్టి, ఈ వస్తువు ప్రింటర్‌ను తిరిగి ఇస్తుంది, కాబట్టి ఆ వస్తువు (ప్రింటర్) పై మీరు ప్రింట్ (ప్రింట్) ఇది స్టాటిక్ కాని సభ్యుల ఫంక్షన్.) మరియు ప్రింటింగ్ అవుతుంది.
 అదేవిధంగా, మీరు మళ్ళీ 20 ను ప్రింట్ చేయవచ్చు.
 కాబట్టి, ఈ ప్రింటర్ నిర్మించబడిందని, 10 పేజీలు ముద్రించబడిందని, 20 పేజీలు ముద్రించబడిందని మీరు చూడవచ్చు.
 మరియు మీరు సహజంగా జరిగినప్పుడు మీరు ఈ వస్తువును సృష్టించారు, కాబట్టి ఆ వస్తువును నాశనం చేయాల్సిన బాధ్యత మీపై ఉంది మరియు అందువల్ల, మీరు డిస్ట్రాయర్ అని పిలుస్తారు మరియు ఆ వస్తువు నాశనం చేయగలదు.
 కాబట్టి, ఇది ఒక సాధారణ మార్గం, మీరు స్టాటిక్ డేటా సభ్యులు మరియు స్టాటిక్ మెంబర్ ఫంక్షన్లను ఉపయోగిస్తే, సింగిల్టన్ చాలా సురక్షితంగా అమలు చేయవచ్చు.
 నేను దీన్ని ప్రింటర్ క్లాస్‌తో చూపించాను, కాని సింగిల్టన్ అవసరమయ్యే ఏ ఇతర క్లాస్‌తోనైనా చేయవచ్చు.
 కాబట్టి, సారాంశంలో, మేము స్టాటిక్ డేటా సభ్యులను మరియు స్టాటిక్ మెంబర్ సభ్యులను పరిచయం చేసాము మరియు తరగతి స్థాయిలో మరియు ప్రత్యేకించి ఏదైనా డేటాను నిర్వహించడానికి అవి ఉపయోగించబడుతున్నాయని మేము చూపించాము. సింగిల్టన్ వస్తువులను నిష్పాక్షికంగా సృష్టించడానికి, వస్తువులను లెక్కించడం వేర్వేరు కోసం చేయవచ్చు ప్రయోజనాల కోసం.