Classes and Objects (Lecture 19)-1puaGnJ9pyA

 మాడ్యూల్ 11 కు ప్రోగ్రామింగ్ C ++ లో స్వాగతం.
 మేము ఇప్పటికే C ++ యొక్క ప్రొసీజరల్ ఎక్స్టెన్షన్స్(procedural extensions) లూప్ను(loop) తీసుకున్నాము, మాడ్యూల్ 5, 6 నుండి 10 వరకు. మరియు మేము విభిన్న ఉత్తమ సి ఫీచర్లను(features) చూసాం.
 ఇప్పుడు ఈ మాడ్యూల్ నుండి, మేము C ++, క్లాస్ మరియు ఆబ్జెక్ట్(objects) ల భావన యొక్క ప్రధాన ఆబ్జెక్ట్ ఓరియంటెడ్ ఫీచర్లను(object-oriented features) చర్చించడాన్ని ప్రారంభిస్తాము.
 కాబట్టి, ఈ మాడ్యూల్ యొక్క ఉద్దేశ్యం C ++ లో క్లాస్ మరియు ఆబ్జెక్ట్ల ఫీచర్లను అర్థం చేసుకోవడం.
 కాబట్టి, ఇవి మనము చూసే అంశాలు.
 ఇప్పుడు, ముందుగా మీరు ఒక క్లాస్, మరియు ఒక ఆబ్జెక్ట్ ఏమిటో మౌలిక వివరణను ఇస్తాను.
 మేము నెమ్మదిగా ప్రదర్శిస్తాము, ఉదాహరణ ద్వారా ఈ ఉదాహరణను ఉదహరించండి, తద్వారా ప్రతి పాయింట్ స్పష్టంగా మారుతుంది.
 మేము చెప్పినట్లుగా, ఒక క్లాస్ ఒక రకమైన అమలు.
 ఇప్పటివరకు ఎందుకంటే మీరు పూర్తిగా క్రొత్తగా కనిపించే లేదా ధ్వనించే ఒక ప్రకటన; C కు సంబంధించినంతవరకు, మేము బిల్ట్ ఇన్ టైప్స్(built in types) లేదా డిరైవ్డ్ టైప్స్ (derived types) బట్టి స్ట్రక్చర్(structure) లేదా పాయింటర్ వంటి అర్రే(array) వంటి టైప్స్.
 కానీ, మనము ఇప్పుడు మనము యుజర్ డిఫైన్డ్ (user defined ) డాటా టైపును అమలు చేయగల స్థితిలో ఉండి, ప్రస్తుత మాడ్యూల్ మరియు మాడ్యూల్స్ యొక్క తదుపరి జంట నుండి తీసుకోబోయే ప్రధాన పాఠాల్లో ఒకటిగా ఉంటుంది.
 ఒక క్లాస్ డేటా మెంబర్లను లేదా గుణాలను(attributes) కలిగి ఉంటుందని మేము గమనిస్తే, క్లాస్(class) కి ఆపరేషన్స్(operations), మెంబర్ ఫంక్షన్స్ (member functions) లేదా మెతడ్స్(methods) ఉంటాయి; ఇవి ఇదే ప్రత్యామ్నాయ పేర్లు.
 ఒక క్లాస్ నేమ్ను నేను నిర్వచించిన ఒక నేమ్ స్పేస్(name space) నిర్వచించే క్లాస్ ని మేము చూస్తాము, ఇది అన్ని డేటా మెంబర్లకు మరియు దాని యొక్క మెతడ్ల నేమ్స్(methods names) కు పరిసర ప్రొపర్టీ(property) అవుతుంది.
 ఆ విధంగా, ఒక క్లాస్ డేటా అబ్స్టాక్షన్(data abstraction) లేదా ఆబ్జెక్ట్ ఓరియంటెడ్ ప్రోగ్రామింగ్(object-oriented programming) యొక్క అని పిలవబడే అని పిలుస్తారు.
 C ప్రోగ్రామింగ్తో సమాంతరంగా, క్లాస్ తార్కికంగా డేటాను సమీకరించే స్ట్రక్చర్(structures) మాదిరిగానే ఉంటుందని మీరు చెప్పవచ్చు, కానీ క్లాస్ లు ఎలా విభిన్నంగా ఉంటుందో మేము చూపిస్తాము.
 క్లాస్ డిఫైన్ చేయటానికి, C ++ నేమ్ క్లాస్(name class) ద్వారా కొత్త కీవర్డ్ ను ప్రవేశపెట్టింది, మరియు క్లాస్ లకు ప్రత్యేకమైన ప్రాప్తి ఉంది; చివరకు, ఒక క్లాస్ blue print మరియు ఆబ్జెక్ట్ ల కోసం తక్షణం చేయవచ్చు.
 కాబట్టి, ఆబ్జెక్ట్ ప్రాథమికంగా క్లాస్ యొక్క ఉదాహరణలు; కాబట్టి, ఒక క్లాస్ ఇచ్చినప్పుడు, నేను ఆ క్లాస్ కి చెందిన అనేక చోట్ల ఉండవచ్చు, ఒక క్లాస్ మాకు blue print చెబుతుంది, డేటాను మరియు మెతడ్ ని ఒక ఆబ్జెక్ట్ కోసం నిర్వహించాల్సిన ఫార్మాట్ మాకు చెబుతుంది.
 మరియు ప్రతి ఆబ్జెక్ట్ ప్రత్యేక గుర్తింపును కలిగి ఉంటుంది; అది దాని స్వంత విలువలను కలిగి ఉంటుంది, ఇది ఆ ఆబ్జెక్ట్ ను కలిగి ఉన్న స్తితి ని నిర్దేశిస్తుంది.
 మెంబర్ ఫంక్షన్స్(member functions) మద్దతు ఇస్తుంది, ఇది అందించే ప్రవర్తనను నిర్వచించే; ఒక ఆబ్జెక్ట్ ఇచ్చిన మేము డాట్ ఆపరేటర్ను ఉపయోగించగలము, స్ట్రక్చర్(structures) యొక్క భాగాలను యాక్సెస్ చేసేటప్పుడు మేము చూసినట్లుగా, అదే ఆపరేటర్ను డేటా మెంబర్ లను అలాగే ఆబ్జెక్ట్ యొక్క మెతడ్లను ప్రాప్తి చేయడానికి ఉపయోగించవచ్చు.
 అంతేకాకుండా, ఒక వస్తువు ఒక నిర్దిష్ట పాయింటర్ ను ఈ పాయింటర్ గా తెలుసుకుంటుంది; ఈ సూచిక ప్రతి విధానాన్ని స్పష్టంగా పాస్ చేస్తుంది.
 ఇది ఏ తరగతి (తరగతి) మరియు ఆబ్జెక్ట్ యొక్క క్లుప్త వివరణ.
 నేను ప్రారంభంలో ఖచ్చితంగా ఖచ్చితంగా వద్ద అది మీ అందరికీ పెద్దగా పట్టింపు లేదు.
 అందువల్ల, మనం ఒక ఉదాహరణతో ప్రారంభిస్తాం, మరియు తరువాత స్లైడ్ ల్లో ఈ ప్రతి పాయింట్ ని క్రమేపీ చిత్రిస్తాం.
 కాబట్టి, ఒక సంక్లిష్ట సంఖ్య యొక్క సరళమైన నిర్వచనాన్ని మనం ఇప్పుడు చూద్దాం.
 మేము ఈ ఉదాహరణను కూడా ఇంతకు ముందు తీసుకున్నాము, ఇక్కడ మేము వాస్తవానికి రెండు డేటా సభ్యులను కలిగి ఉన్న ఒక నిర్మాణాన్ని ఉపయోగించవచ్చు, రెండు సభ్యులు ఒక సంక్లిష్ట సంఖ్య యొక్క రెండు భాగాలను తిరిగి అమలు చేయవచ్చు మరియు ఇది ఒక నిర్మాణం గా నిర్వచించబడుతుంది మరియు మేము దానిని టైప్ చేస్తాము, ఇది పేరు సముదాయం.
 అందువల్ల, మనం ఆ విధంగా చేసిన తరువాత, ఆ నిర్మాణం యొక్క వేరియబుల్స్ ని మనం నిర్వచించవచ్చు మరియు స్ట్రక్చర్ యొక్క ఈ కాంపోనెంట్ కొరకు కొన్ని ప్రారంభ విలువలను ఉంచవచ్చు.
 కాబట్టి, మళ్ళీ అది 4.2 అవుతుంది, మరియు 5.3.
 కాబట్టి, ఈ సంక్లిష్ట సంఖ్య యొక్క రెండు భాగాలను మనం ఇప్పుడు ఒకదానిలో ప్రింట్ చేసినట్లయితే, అది 4.2 మరియు 5.3గా ప్రింట్ చేయబడుతుంది.
 ఇది మీకు ఇప్పటికే తెలిసినవిషయం; ఇది సిలో లభ్యమవుతుంది.
 నేను సి++లో సమానంగా రాయాలనుకుంటే దాన్ని క్లాస్ గా మార్చి రాస్తాను.
 సో, మేము ఒక స్ట్రక్ట్ కాంప్లెక్స్ మరియు తరువాత మేము టైప్డెఫ్ తో aliasing, ఇప్పుడు నేను ఒక తరగతి కాంప్లెక్స్ వ్రాస్తాను మరియు దాని లోపల సభ్యుడి నిర్వచనాలు చాలు.
 మరియు మిగిలిన కోడ్ చాలా ఒకే విధంగా రాయవచ్చు, ఇక్కడ తేడా ఉన్నప్పుడు మాత్రమే, మేము printf ఉపయోగిస్తున్నాము మరియు ఇక్కడ మేము C++ విషయంలో చూసిన విధంగా మేము cout ను ఉపయోగిస్తున్నాము, మేము స్ట్రీమింగ్ ఆపరేటర్లను ఆ విధంగా చేయడానికి ఉపయోగిస్తాము.
 ఇప్పుడు, ఖచ్చితంగా ఏమి చేయాలో చూద్దాం.
 అందువల్ల, స్ట్రక్చర్ సిలో కీవర్డ్ ఉంది, సి++ లో క్లాస్ అనేది కొత్త కీవర్డ్.
 మనం చేసిన మిగిలిన భాగం, వాస్తవ అనుఘటకం యొక్క రెండు భాగాలను నిర్వచించడం మరియు సేకరించడం, Cలో ఒక నిర్మాణం ద్వారా లేదా C++ లోని ఒక తరగతి ద్వారా సంక్లిష్ట సంఖ్య యొక్క ఊహాజనిత భాగం రెండింటిమధ్య చాలా సారూప్యంగా ఉంటుంది.
 అందువల్ల, ఇప్పుడు మనం క్రమేపీ బయటకు తీసుకొచ్చే ఒకే ఒక్క వ్యత్యాసాన్ని, నిర్మాణం మాత్రమే సేకరించడానికి అనుమతిస్తుంది, రెండు భాగాలను కలిపి ఉంచు, మనం N1ను రెండు డబుల్ నెంబర్లు 4.2 మరియు 5.3 గా పేర్కొందాం.
 ఒక సంక్లిష్ట తరగతిని డిజైన్ చేయడం కూడా అదే పని.
 కానీ మనం చూసే క్లాస్ లో స్ట్రక్చర్ ఇంకా చాలా పనులు చేస్తుంది.
 కాబట్టి మనం కొన్ని భిన్నమైన మరియు పెద్ద ఉదాహరణ తీసుకుందాం. 
 ఇక్కడ మనం ఒక దీర్ఘచతురస్రాన్ని నిర్వచించటానికి ప్రయత్నిస్తున్నాము మరియు ఇది ఒక ప్రత్యేక రకం దీర్ఘచతురస్రం, ఈ దీర్ఘచతురస్రంలోని దీర్ఘచతురస్రం ఈ దీర్ఘచతురస్రం దీర్ఘచతురస్రం అని చెబుతుంది. దీని అక్షం x మరియు y- అక్షానికి సమాంతరంగా ఉంటుంది. 
 కాబట్టి, నేను కేవలం రెండు మూలలతో, వికర్ణంగా వ్యతిరేక మూలలో, ఎగువ ఎడమ మరియు దీర్ఘచతురస్రం యొక్క కుడి దిగువ మూలలో పేర్కొంటే, అప్పుడు దీర్ఘచతురస్రం పూర్తిగా పేర్కొనబడింది. 
 ఇది చేయుటకు, మొదట x మరియు y అనే రెండు కోఆర్డినేట్ల అగ్రిగేషన్ రూపంలో పాయింట్లను ఇచ్చే ఒక నిర్మాణాన్ని మేము నిర్వచించాము మరియు తరువాత మేము రెండు పాయింట్లను తీసుకొని వాటిని దీర్ఘచతురస్రానికి వికర్ణంగా రెండు వ్యతిరేక బిందువులుగా పేర్కొంటాము. ఇవ్వండి. 
 ఇది పూర్తయిన తర్వాత, నేను ఇక్కడ ఒక దీర్ఘచతురస్రాన్ని నిర్వచించగలను, దీర్ఘచతురస్రం r. 
 మీరు ఇక్కడ మొదటి {0, 2} సంజ్ఞామానాన్ని చూడవచ్చు, మొదటి జత వంకర కలుపులలో ఎడమ ఎగువ పాయింట్, {5, 7} అంటే పాయింట్ దిగువ కుడి. 
 మరియు రెండూ కలిసి మొత్తం దీర్ఘచతురస్రం అని అర్థం. 
 కాబట్టి, వ్యాఖ్యలలో, నేను 0, 2 ను మొదటి బిందువుగా పేర్కొంటే, నేను నిజంగా R ని దీర్ఘచతురస్రం (దీర్ఘచతురస్రం) యొక్క పేరు అని సూచిస్తున్నాను r. TL ఒక ఎగువ ఎడమ బిందువు, డాట్ x ( .x) అనేది 0 కోఆర్డినేట్. 
 అదేవిధంగా, ఎగువ ఎడమ బిందువు యొక్క భాగం అయిన r.TL.y విలువ 2 ను పొందుతుంది. 
 కాబట్టి, ఈ ప్రారంభించడం ద్వారా ఈ విలువలు అన్నీ సెట్ చేయబడుతున్నాయి, ఆపై నేను వాటిని ప్రింట్ చేయగలను. 
 బయట. 
 అదేవిధంగా, నేను క్లాస్ ఉపయోగించి మొత్తం విషయం వ్రాయగలను. 
 మునుపటిలాగే తేడా జరుగుతోంది. 
 నేను దీన్ని ఈ విధంగా ప్రారంభించగలను మరియు నేను కౌట్ ఉపయోగించి ప్రింట్ చేయగలను. 
 కాబట్టి, ఇది తరగతిని ఉపయోగించటానికి మరొక ఉదాహరణను చూపుతోంది. 
 ఇక్కడ దీర్ఘచతురస్రం - దీర్ఘచతురస్రంలోని డేటా సభ్యులు వాస్తవానికి ఏ మూల రకానికి చెందినవారు కాదు, కానీ అవి వినియోగదారు నిర్వచించిన డేటా రకాలు, అవి తరగతి వస్తువు, అవి ఆ దశను సూచిస్తాయి. నేను ఇప్పటికే నిర్వచించిన తరగతుల ఉదాహరణలు ఉన్నాయి. 
 మనం ఇంతకుముందు చర్చించిన స్టాక్ యొక్క మూడవ ఉదాహరణ తీసుకుందాం. 
 కాబట్టి, స్టాక్‌లో, మనకు మిశ్రమ డేటా రకాల కలయిక ఉంది, స్టాక్ యొక్క మూలకాలను పట్టుకోవటానికి మనకు అక్షర శ్రేణి ఉంది, ఇది అక్షరాల స్టాక్, మనకు హెడర్ మార్కర్ ఉంది, ఇది స్టాక్‌లోని సూచిక, ఇది శీర్షం ఎక్కడ ఉందో చూపిస్తుంది వాస్తవానికి ఉనికిలో ఉంది. 
 కాబట్టి, నేను ఇక్కడ లేదా ఇక్కడ స్టాక్ వేరియబుల్‌ను నిర్వచించగలను; మరియు స్పష్టంగా, నేను స్టాక్‌ను ఉపయోగించడం ప్రారంభించే ముందు, స్టాక్ (స్టాక్) ఖాళీగా ఉందని నిర్ధారించుకోవాలి, ఇది టాప్ ఇండెక్స్ మైనస్ 1 (-1) ద్వారా పేర్కొనబడింది. 
 కాబట్టి, నేను టాప్ ఇండెక్స్ -1 ను ప్రారంభిస్తాను, ఆపై నేను దానిని స్టాక్ ద్వారా ఉపయోగించగలను, అది నిర్మాణం ద్వారా నిర్వచించబడినా లేదా వేర్వేరు అల్గోరిథంలను వేర్వేరు సమస్యలను పరిష్కరించడానికి ఉపయోగిస్తున్నా. తరగతి ద్వారా నిర్వచించండి. 
 కాబట్టి, ఇవి మీరు చూడగలిగే విభిన్న ఉదాహరణలు, ఒక తరగతి యొక్క మూల భాగం ఒక కీవర్డ్ వలె ఒక తరగతి అని మేము చూపిస్తాము, దానికి ఒక పేరు. ఒక పేరు మరియు ఐడెంటిఫైయర్, దీనికి చాలా మంది డేటా సభ్యులు ఉన్నారు. 
 ప్రతి డేటా సభ్యుడు నిర్మాణంలో వేరియబుల్ డిక్లరేషన్ స్టైల్‌గా నిర్వచించబడతాడు మరియు క్లాస్ పేరును ఉపయోగించి, ఉదా. గోస్ అని పిలువబడే క్లాస్ రకాలను వేరియబుల్స్‌గా ప్రకటించవచ్చు. 
 కాబట్టి, ఇది ఒక ఉదాహరణ లేదా దానిని ఒక వస్తువు అంటారు. 
 కాబట్టి, s తరగతి అనేది స్టాక్ యొక్క వస్తువు. 
 మరియు మనకు ఆ వస్తువు ఉన్న తర్వాత, మేము డేటా సభ్యుడిని ఉపయోగించవచ్చు, ఇక్కడ డేటా సభ్యుడు డాట్ సభ్యుల సంజ్ఞామానాన్ని ఉపయోగించి పైభాగంలో ఉంటుంది. 
 కాబట్టి, తరగతి అనేది ఒకటి లేదా అంతకంటే ఎక్కువ డేటా సభ్యులను కలిసి ఉంచగల సమితి అని మేము మొదట చూపిస్తాము మరియు ఆ తరగతి యొక్క వస్తువు (ల) ను వెంటనే నింపండి లేదా సి ++ ఆ రకమైన వేరియబుల్స్ ను యంత్రాంగాలను ఉపయోగించి నిర్వచించటానికి అనుమతిస్తుంది. 
 కాబట్టి, మళ్ళించడానికి, తరగతి అనేది ఒక రకమైన అమలు అని మేము చూశాము, దానిలో ఎక్కువ భాగం చూస్తాము. 
 మూడు రకాలను సంక్లిష్ట రకం, దీర్ఘచతురస్రం మరియు పాయింట్ రకం మరియు స్టాక్ రకంగా చేయడానికి మూడు ప్రయత్నాలు చూశాము. 
 తరగతి డేటా సభ్యులను కలిగి ఉంటుందని మేము చూపించాము, ఇది నేమ్‌స్పేస్‌ను నిర్వచిస్తుంది, నేను ఒక కాంప్లెక్స్‌ను నిర్వచిస్తున్నానని చెప్పినప్పుడు, నా ప్రాంగణంలోని డేటా సభ్యులందరికీ వాస్తవానికి ఒక పేరు ఉంది, ఇది సంక్లిష్టమైన, తరగతి పేరు ద్వారా అర్హత పొందింది. 
 మరియు ఇది తార్కికంగా డేటాను సేకరిస్తోంది. 
 వస్తువుల ఉదాహరణల పరంగా, ప్రతి రకం తరగతికి, మేము నిర్వచించిన ప్రతి మూడు తరగతులకు, మేము ఆ వస్తువులను లేదా వస్తువులను వేర్వేరు సందర్భాల్లో నిర్వచించాము మరియు డేటా సభ్యులకు ప్రాప్యత "." డాట్ ఆపరేషన్ ద్వారా జరుగుతుంది. 
 ఇప్పటివరకు, మనం చూసినవి మనం నిర్మాణాలుగా చేయగల విషయం. 
 ఇప్పుడు మనం క్లాస్ డెఫినిషన్ ద్వారా నిర్మాణంలో ఏమి చేయగలమో దాని నుండి దూరంగా వెళ్ళడానికి మొదటి పెద్ద తేడా లేదా మొదటి పెద్ద అడుగు చేయబోతున్నాం. 
 కాబట్టి, దయచేసి దీన్ని చాలా జాగ్రత్తగా అనుసరించండి. 
 మేము సంక్లిష్టమైన ఉదాహరణలకు తిరిగి వస్తున్నాము. 
 కాబట్టి, ఈ భాగం సాధారణం, నిర్మాణం యొక్క నిర్వచనం ప్రకారం మీకు ఇక్కడ డేటా సభ్యులు ఉన్నారు, డేటా సభ్యుల తరగతి యొక్క నిర్వచనం వలె మాకు అదే డేటా ఉంది. 
 ఇప్పుడు, నేను సి లో ఇంత క్లిష్టమైన సంఖ్యను కలిగి ఉంటే, నేను స్లైడ్ యొక్క ఎడమ వైపు చూస్తున్నాను, అప్పుడు నేను చాలా రకాల ఫంక్షన్లను నిర్వచించగలను, నేను ఒక ఫంక్షన్ (ఫంక్షన్) అని చెప్తాను) ప్రమాణాన్ని నిర్వచిస్తుంది, ఇది మరింత నిర్వచించగలదు అటువంటి సంక్లిష్ట సంఖ్య ఇక్కడ సి. 
 దాని ఆదర్శం 
 తరగతి యొక్క నిజమైన మరియు inary హాత్మక భాగాల యొక్క ఈ మొత్తాన్ని ఆదర్శం ఎలా లెక్కిస్తుందో మీ అందరికీ తెలుసు. 
 ఆపై వారు ఆ మొత్తంలో ఒక వర్గమూలాన్ని తీసుకుంటారు, మీరు సంక్లిష్ట సంఖ్య యొక్క విలువను పొందుతారు లేదా మేము సంక్లిష్ట సంఖ్యను నిజమైన ప్లస్ j imag హాత్మక భాగం రకం సంజ్ఞామానం ముద్రణలో ముద్రించవచ్చు.ఈ విలువకు మరొక ఫంక్షన్ వ్రాయగల విలువ మరియు మొదలైనవి. 
 కాబట్టి, ఈ ఫంక్షన్లను నేను ఇప్పటికే సి లో నిర్వచించిన నిర్మాణాత్మక సంక్లిష్ట రకములతో వ్రాయవచ్చు మరియు ఇవన్నీ సి ఫంక్షన్లు సాధారణంగా గ్లోబల్ ఫంక్షన్లు అని మనకు తెలుసు., ఆపై నేను దానిని ప్రింట్ చేయడానికి ఉపయోగించవచ్చు మరియు నేను దీన్ని చేస్తే కాంప్లెక్స్ సంఖ్య ముద్రించబడుతుంది. 
 కాబట్టి, ఇది ఎలా ముద్రించబడుతుందో మీరు చూడాలనుకుంటే, ఇది ప్రింట్ చేస్తుంది. కాబట్టి, సంక్లిష్ట సంఖ్య 4.2, 5.3, ఇది 4.2+ j 5.3 యొక్క ప్రమాణం 6.7624 అని ముద్రిస్తుంది. 
 ఇప్పుడు, సి ++ ని జాగ్రత్తగా చూద్దాం. 
 ఇక్కడ నేను ప్రామాణిక ఫంక్షన్‌ను కూడా నిర్వచిస్తున్నాను, కానీ తేడాతో. 
 నిర్మాణంలో, నిర్మాణం పరంగా, నిర్మాణం యొక్క నిర్వచనం భిన్నంగా ఉంటుంది, నా ఫంక్షన్ నిర్వచనం భిన్నంగా ఉంటుంది, కానీ ఇక్కడ తరగతి యొక్క నా నిర్వచనం, ఇది సంక్లిష్టతకు నా మొత్తం తరగతి నిర్వచనం, మరియు నా ఫంక్షన్ తరగతి. యొక్క నిర్వచనంలో ఒక భాగం ( తరగతి). 
 అటువంటి ఫంక్షన్లను పిలుస్తారు, చాలా సహజంగా సభ్యుల ఫంక్షన్లు క్లాస్ క్లాస్ కాంప్లెక్స్‌లో సభ్యురాలిగా పిలువబడతాయి, ఇది డేటా సభ్యుడు అని మేము చెప్తాము, అదేవిధంగా "డబుల్ కట్టుబాటు ()" ఈ ఫంక్షన్ కూడా ఒక సభ్యుడు తరగతి పరిధి. 
 మరియు దీనిని సభ్యుల ఫంక్షన్ లేదా పద్ధతి అంటారు. 
 క్లాస్ యొక్క నిర్వచనంలో ఇతర ఫంక్షన్ ప్రింట్ కూడా ఉందని మీరు చూడవచ్చు మరియు ప్రింట్ మరొక సభ్యుల ఫంక్షన్. 
 కాబట్టి, ఇది కొన్ని సభ్యుల ఫంక్షన్ సి ++ కోసం పూర్తిగా క్రొత్త భావన, దీనికి సి లో సమాంతరంగా లేదు. 
 మరియు ఈ సభ్యుల ఫంక్షన్‌తో, క్లాస్ కాంప్లెక్స్ ఇచ్చిన నా ఆబ్జెక్ట్ ఉదాహరణ ఈ తరగతికి ఒక ఉదాహరణ, ఇప్పుడు నా ఆబ్జెక్ట్ ఉదాహరణ, చెప్పండి ఈ ఉదాహరణ సి ఈ సంజ్ఞామానం లోని పద్ధతిని ఉపయోగించవచ్చు. 
 ఇంతకుముందు, మీరు డేటా సభ్యుని సూచనతో మాత్రమే సంజ్ఞామానాన్ని చూశారు, ఇది మేము చూసిన "c.re" విషయం, అంటే సంక్లిష్ట సంఖ్య మళ్ళీ సి యొక్క డేటా అని అర్ధం. సభ్యుడిని సూచిస్తూ ఇప్పుడు నేను "సి ". 
 ప్రింట్ "" అంటే ఆబ్జెక్ట్ సి కోసం, ఉదాహరణకు సి, నేను ఉపయోగిస్తున్నాను లేదా నేను పద్ధతి ప్రింట్ () ను ప్రారంభిస్తున్నాను. 
 ఈ పద్దతి దీన్ని చేయాల్సిన ముద్రణ, ఈ డేటా సభ్యులకు సి ఆబ్జెక్ట్‌లో విలువలు ఉన్నాయని మరియు తదనుగుణంగా పని చేస్తాయని ఊహిస్తూ, ఈ ముద్రణ అయిపోతుంది. 
 అదేవిధంగా, నేను c.norm () ను వ్రాసి, ఇన్వోక్ చేస్తే, అది ఇతర సభ్యుల ఫంక్షన్ (ఫంక్షన్) కట్టుబాటు () ను అమలు చేస్తుంది, మరియు విలువ సి విలువ నుండి వచ్చే నిజమైన మరియు ఊహాత్మక భాగాలతో కూడా వ్యవహరిస్తుంది. 
 ఇది పూర్తిగా కొత్త కాన్సెప్ట్ మరియు ఈ సభ్యులు పని చేస్తారు. 
 అందువల్ల, సి వలె మనం ఏదో ఒక నిర్మాణంగా నిర్వచించినట్లయితే, దానితో మనం చేయవలసిన ప్రతి ఆపరేషన్, కొన్ని గ్లోబల్ ఫంక్షన్ల ద్వారా చేయవలసి ఉంటుంది. 
 ఎవరైనా మరియు ప్రతి ఒక్కరూ చూడవచ్చు మరియు ఉపయోగించవచ్చు. 
 C ++ లో, తరగతి స్వయంగా, అనేక సభ్యుల విధులు లేదా పద్ధతులను నిర్వచించగలదు, ఇది కొన్ని విధులను నిర్వహించడానికి వస్తువును అవసరమైన విధంగా అమలు చేయగలదు మరియు ఇది క్రమంగా మనం చూసేటప్పుడు వస్తువు యొక్క ప్రవర్తన అని పిలుస్తారు. 
 
 కాబట్టి, మరికొన్ని ఉదాహరణలు చూద్దాం. 
 దీర్ఘచతురస్ర పాయింట్ భాగాన్ని తిరిగి తీసుకుందాం, మీరు ఇప్పటికే ఈ భాగాన్ని చూశారు. 
 ఇక్కడ మనం నిర్మాణాన్ని ఉపయోగించి సి కొరకు ఒక ఫంక్షన్ వ్రాస్తున్నాము, ఇది ఒక దీర్ఘచతురస్రం యొక్క వైశాల్యాన్ని లెక్కించే గ్లోబల్ ఫంక్షన్. 
 ప్రాంతాన్ని లెక్కించడానికి సూత్రం సూటిగా ఉంటుంది, నేను దానిలోకి లోతుగా వెళ్ళను, కానీ ఇది గ్లోబల్ ఫంక్షన్ కౌంట్ (), ఇది ఒక దీర్ఘచతురస్రాన్ని పరామితిగా తీసుకొని ఆ ప్రాంతాన్ని లెక్కిస్తుంది మరియు ఇది ఎలా పనిచేస్తుంది. 
 దీనికి విరుద్ధంగా, సి ++ తరగతిలో, ఇది నా దీర్ఘచతురస్ర తరగతి, ఇదే నా పద్ధతి, నా కంప్యూట్ ఏరియా () పద్ధతి సభ్యుల ఫంక్షన్. ఇది తరగతిలో ఒక భాగం. 
 కాబట్టి, నాకు దీర్ఘచతురస్రం R ఆబ్జెక్ట్ ఉన్నప్పుడు, నేను అదే డాట్ సంజ్ఞామానాన్ని ఉపయోగించి పద్ధతి లేదా సభ్యుల పనితీరును అమలు చేస్తాను, మరియు దీని అర్థం లెక్కించిన ఫీల్డ్ పని చేస్తుంది, ఇక్కడ R తక్షణం పనిచేస్తుందని అనుకుంటాను. 
 ఇది పనిచేస్తోంది. 
 కాబట్టి, ఇది TL.x ను సూచించినప్పుడు, ఇది వాస్తవానికి r వస్తువు యొక్క TL.x ను సూచిస్తుంది, ఇది ఈ ప్రత్యేక పద్ధతిని అమలు చేసింది. 
 ఇది సి లో ఎక్కువ, ఇది ఫంక్షన్ కాల్ అని మేము చెప్తున్నాము, ఇది సి ++ లో కూడా ఫంక్షన్ కాల్ అని మేము చెబుతూనే ఉన్నాము, కాని మీరు వేర్వేరు వస్తువుల (ఫంక్షన్) సభ్యుల ఫంక్షన్ అని పిలిచినప్పుడు, మీరు తరచూ మీరు అని చెబుతారు ఒక వస్తువు యొక్క పద్ధతిని ప్రారంభిస్తున్నారు. 
 ఒక తరగతి నిర్వచనంలో భాగంగా లభించే ఒక పద్ధతి లేదా సభ్యుల ఫంక్షన్, కాబట్టి C ++ లోని పద్ధతుల యొక్క ప్రాథమిక ఆలోచన. 
 మీరు చూడగలరు. 
 మీరు మరింత అధ్యయనం చేసినప్పుడు మీ సమయాన్ని, ఈ ప్రెజెంటేషన్‌ను ఎక్కువగా తీసుకోవచ్చని మేము చాలా వివరంగా చెప్పలేము. 
 ఇది డేటాను కలిగి ఉన్న స్టాక్‌కు పూర్తి ఉదాహరణ అని మీరు చూడవచ్చు. 
 ఇవి స్టాక్ యొక్క నాలుగు ఆపరేషన్లు: ఖాళీ, టాప్, పుష్ మరియు పాప్, సి లో గ్లోబల్ ఫంక్షన్లుగా ఇవ్వబడ్డాయి. 
 మేము ఇక్కడ ఒక స్టాక్ యొక్క ఉదాహరణను ఉపయోగిస్తాము, దానిని టాప్ మార్కర్‌గా ప్రారంభించండి, దాన్ని వాడండి మరియు ఇచ్చిన స్ట్రింగ్ కోసం, మేము ఆ స్ట్రింగ్ యొక్క ప్రతి అక్షరాన్ని ప్రతిదానికి కేటాయించవచ్చు, అప్పుడు మేము వాటిని స్టాక్‌లోకి నెట్టివేసి, ఆపై వాటిని పాపింగ్ చేస్తూనే ఉంటాము స్టాక్ ఖాళీ అవుతుంది. 
 మీకు తెలిసినట్లుగా ఇది స్ట్రింగ్‌ను రివర్స్ చేసే ప్రామాణిక అల్గోరిథం. 
 కాబట్టి, ఈ కోడ్ ఈ గ్లోబల్ ఫంక్షన్‌ను ఉపయోగించి స్ట్రింగ్‌ను రివర్స్ చేస్తుంది. 
 ఇప్పుడు మేము క్లాస్ కాంప్లెక్స్ ఉపయోగించి చూపిన విధంగా చేయగలమని చూపిస్తాము, క్లాస్ దీర్ఘచతురస్రాన్ని ఉపయోగించి మేము చూపించినట్లు. 
 క్లాస్ స్టాక్ విషయంలో, నేను డేటాను కలిగి ఉంటాను, మరియు నేను ఈ స్టాక్ ఆపరేషన్లన్నింటినీ సృష్టించగలను ఎందుకంటే మేము వాటిని సభ్యుల ఫంక్షన్లలో చేయవలసి ఉంటుంది మరియు పద్ధతి (క్లాస్)) పద్ధతిలో కొంత భాగాన్ని నిర్వహించడానికి అవసరం. 
 మరియు మేము వారిని తరగతిలో భాగమైన వెంటనే, తేడాను చూడటానికి వాటిని ఉపయోగిస్తాము. 
 మీరు ఇక్కడ నెట్టివేస్తే, స్టాక్ అంటే ఏమిటో మీరు చెప్పాలి, ఆపై మీరు ఇక్కడ ఏమి నెట్టివేస్తున్నారో, మీరు స్టాక్ s అని చెప్తారు. 
 కాబట్టి, మీరు స్టాక్ ఆబ్జెక్ట్ కోసం పుష్ పద్ధతిని అమలు చేస్తున్నారు మరియు మీరు ఇక్కడ ఏమి నెట్టివేస్తున్నారో చెబుతున్నారు. 
 అదేవిధంగా, ఖాళీగా తనిఖీ చేయడానికి, మీరు స్టాక్ ఫంక్షన్లను గ్లోబల్ ఫంక్షన్‌కు పాస్ చేస్తారు, ఖాళీ సభ్యుల ఫంక్షన్ ఉంది. 
 కాబట్టి, మీరు స్టాక్ (స్టాక్) కి వెళతారు. మీరు ఈ పద్ధతిని ఖాళీగా తీసుకోండి, ఇది స్టాక్ (స్టాక్) S కు మైనస్ 1 కి సమానమైన శీర్షం ఉందో లేదో తెలుసుకోవడానికి మాకు పద్ధతి ఇస్తుంది. 
 అదేవిధంగా, ఇక్కడ టాప్ లు s.top (); అని ఆహ్వానించబడ్డారు. 
 పాప్ లు ఇక్కడ s.pop () గా చేర్చబడ్డాయి. 
 కాబట్టి, ఇది గ్లోబల్ ఫంక్షన్లను ఉపయోగించటానికి వ్యతిరేకం అని మీరు చూడవచ్చు, ఇప్పుడు ఈ పద్ధతి ఇన్వొకేషన్ లేదా సభ్యుల ఫంక్షన్ డేటా ఆపరేషన్లను ఏకకాలంలో చేయడానికి అనుమతిస్తుంది, అలాగే ఆ పద్ధతులు లేదా సభ్యులను అనుమతించండి నేను వాటిని ఇవ్వడానికి నేను ఏమి చేయాలో నన్ను అనుమతిస్తుంది కలిసి ఏకీకృత కట్టలో. 
 మరియు ఇది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ రూపంలో మరింత సరైన, మరింత ఖచ్చితమైన ఎన్కప్సులేషన్ లేదా అగ్రిగేషన్ ఇస్తుంది. 
 కాబట్టి, దీనితో, మేము సాధించేది ఆ తరగతిలో కార్యకలాపాలు మరియు సభ్యుల ఫంక్షన్ పద్ధతులు మరియు ఇది OOP రూపంలో డేటా సంగ్రహణ లేదా ఎన్కప్సులేషన్‌ను అందిస్తుంది, మనం దీన్ని స్పష్టంగా అర్థం చేసుకోవచ్చు. 
 మరియు వస్తువు యొక్క సందర్భంలో సభ్యుల విధులు దాని ప్రవర్తనను నిర్వచించాయని మనకు తెలుసు; మేము చూసినట్లుగా, స్టాక్‌లోని సభ్యుడు ఫంక్షన్లైన పుష్, పాప్, ఖాళీ, టాప్ స్టాక్ ప్రదర్శించాల్సిన అన్ని LIFO ప్రవర్తనను నిర్వచిస్తుంది. 
 ప్రయోజనం ఏమిటంటే, మేము సి ఉపయోగిస్తున్నప్పుడు మరియు గ్లోబల్ ఫంక్షన్లను ఉపయోగిస్తున్నప్పుడు, గ్లోబల్ ఫంక్షన్లకు స్టాక్ స్ట్రక్చర్ గురించి తెలియదు, స్టాక్ స్ట్రక్చర్ అంటారు గ్లోబల్ ఫంక్షన్లు ఏమిటో తెలియదు, నేను దీన్ని పాస్ చేయగలను. 
 కానీ నేను ఒక తరగతి చేసి, వాటిని డేటా సభ్యుడితో అనుబంధించినప్పుడు మరియు డేటా సభ్యుడితో పనిచేసే పద్ధతులు పూర్తిగా కలిసిపోయినప్పుడు, మీరు వాటిని అవసరమైన విధంగా పరిగణిస్తారు మరియు అవి పూర్తిగా ఎలా కట్టుబడి ఉన్నాయో చూడటానికి మేము యాక్సెస్ స్పెసిఫికేషన్ తర్వాత ప్రత్యేకంగా చూస్తాము C ++ లో మాకు మరింత పూర్తి డేటా రకాలను ఇవ్వడానికి. 
 ఇప్పుడు, మనం అర్థం చేసుకోవలసిన తదుపరి భావనలు, ఇక్కడ పరిచయం ఈ సంకేతం యొక్క భావన. 
 ఈ పాయింటర్, "ఇది" వాస్తవానికి C ++ లో ఒక కీవర్డ్, మరియు ఇది ఒక పేరు. 
 మరియు ఇది ఒక వస్తువు యొక్క చిరునామాను కలిగి ఉన్న అంతర్నిర్మిత పాయింటర్. 
 అందువల్ల, నేను ఒక వస్తువు గురించి మాట్లాడుతుంటే, ఆ వస్తువు దాని స్వంత గుర్తింపును, దాని స్వంత గుర్తింపును, వస్తువు యొక్క పద్ధతుల్లో దాని స్వంత చిరునామాను సూచించవచ్చు. 
 మరియు ఈ సూచికలో ఆసక్తికరమైన సంతకం ఉంది. 
 కాబట్టి, మీరు ఇప్పటికే const పాయింటర్‌ను చూశారు, కాబట్టి ఈ పాయింటర్ ఎలా నిర్వచించబడిందో చూడటానికి మీరు ఈ సిగ్నల్‌ను సులభంగా చదవవచ్చు. 
 కాబట్టి, పదవ తరగతి కోసం, దాని వస్తువు యొక్క "ఈ" పాయింటర్ "x * const" గా ఉంటుంది, ఇది "x *" ఇది ఒక తరగతి (రకం) వస్తువు (వస్తువు) అని సూచిస్తుంది మరియు ఇది ఒక పాయింటర్, ఈ నక్షత్రం తరువాత పాయింటర్ రకం ఈ పాయింటర్ యొక్క విలువను మీరు మార్చలేరని ఇది స్థిరమైన పాయింటర్ అని మాకు చెబుతుంది, ఇది అర్ధమే. ఎందుకంటే ఇది ఒక వస్తువు యొక్క చిరునామా అని మేము చెబుతున్నాము. 
 కాబట్టి, ఇది వివిధ మార్గాల పరంగా అందుబాటులో ఉంటుంది. 
 అందువల్ల, ఇక్కడ నేను కొన్ని ఉదాహరణలు మాత్రమే చూపిస్తాను. 
 ఇది నిష్పాక్షికంగా అర్ధవంతమైనది ఏమీ చేయదు, కానీ ఇది కేవలం ఉదాహరణ కోసం మాత్రమే; X ఒక తరగతి, దీనికి ఇద్దరు సభ్యులు ఉన్నారు. 
 మరియు f అనేది రెండు పారామితులను తీసుకొని వాటిని ఆబ్జెక్ట్ యొక్క రెండు డేటా సభ్యుల కోసం సెట్ చేస్తుంది. 
 మరియు మేము డేటా సభ్యుడిని నేరుగా M1 గా సూచించవచ్చు లేదా నేను ఈ పాయింటర్ M2 ద్వారా సూచించగలను, ఎందుకంటే ఇది ఒక వస్తువు గురించి మాట్లాడితే, ఈ వస్తువుకు పాయింటర్ అయిన పాయింటర్ నాకు ఉంది. 
 కాబట్టి, నేను F లో ఉన్నప్పుడు, నాకు అలాంటిది, ఈ పాయింటర్ యొక్క విలువ నాకు ఉంది, దీని ద్వారా నేను ఈ వస్తువులో M1 మరియు M2 ని సూచించగలను. 
 కాబట్టి, మీరు ఈ కోడ్ ద్వారా వెళితే, ఈ పాయింటర్ వాస్తవానికి చిరునామాను తీసుకుంటుందని మీరు చూడగలరు. 
 అందువల్ల, ప్రధాన కోడ్‌లో, మేము చిరునామాను ముద్రించాము; మరియు ఫంక్షన్ f లో, మేము ఈ పాయింటర్ యొక్క విలువను ముద్రించాము మరియు అవి ఒకేలా ఉన్నాయని మీరు చూడవచ్చు. 
 కాబట్టి, ఈ పాయింటర్ వాస్తవానికి వస్తువు యొక్క చిరునామాను కలిగి ఉంటుంది. 
 కాబట్టి, ఇక్కడ, నేను, మీరు వేర్వేరు డేటా సభ్యులను లేదా తరగతి యొక్క పద్ధతులను ఉపయోగిస్తున్నప్పుడు ఈ పాయింటర్‌ను ఉపయోగించడం సాధారణంగా ఐచ్ఛికం, కానీ మీరు డేటా సభ్యుని k1, k2 వంటి ఇతర వేరియబుల్స్ నుండి వేరు చేయడానికి వాటిని ఉపయోగించవచ్చు. 
 కానీ కొన్ని ఉదాహరణలు ఉన్నాయి, కొన్ని పరిస్థితులు చాలా అవసరం అయినప్పుడు మరియు మేము ఇక్కడ రెండు ఉదాహరణలు మాత్రమే ఉంచాము. 
 ఉదాహరణకు, మీరు డ్యూయల్ లింక్డ్ జాబితాను కలిగి ఉంటే మరియు మీరు ఇచ్చిన నోడ్ తర్వాత నోడ్‌ను చొప్పించే నోడ్‌లోకి చొప్పించాలనుకుంటే, అది లింక్‌ను తదుపరి నోడ్‌కు మరియు మునుపటి నోడ్‌కు వెనుకకు లింక్‌కు ఫార్వార్డ్ చేస్తుంది, మీరు తప్పక చిరునామాను ఉపయోగించాలి మీరు నోడ్లో ఉంచారు. 
 లేదా మీరు ఒక వస్తువును తిరిగి ఇస్తుంటే, మీరు మీరే తిరిగి వస్తున్న వస్తువును సూచించాలి, వీటికి మరిన్ని ఉదాహరణలు తరువాత చూస్తాము. 
 కాబట్టి, మీరు దీనిని ఒకసారి ప్రయత్నించాలని నేను కోరుకుంటున్నాను, కాని దీనిపై మేము మరిన్ని ఉదాహరణలు ఇచ్చినప్పుడు, మేము దానిని మరింత విస్తరిస్తాము. కాబట్టి, దీనితో తరగతి యొక్క భావన మరియు దాని సంబంధిత వస్తువు ఏమిటో నేర్చుకున్నాము. 
 మేము ఒక తరగతి యొక్క డేటా సభ్యుల గురించి మరియు అదే వస్తువు యొక్క వస్తువు గురించి కూడా నేర్చుకున్నాము. 
 తరగతి కోసం నిర్వచించబడే మరియు ఒక వస్తువుకు వర్తించే పద్ధతుల గురించి మేము నేర్చుకున్నాము. 
 మరియు ప్రతి వస్తువుకు ఒక గుర్తింపు ఉందని మేము చూశాము, అది "ఈ" పాయింటర్‌లో ఆ వస్తువు యొక్క పద్ధతులకు సంగ్రహించబడవచ్చు మరియు ఇది వస్తువుకు తెలిసిన చిరునామాను కనుగొంటుంది. 
 ఈ సమయంలో, C ++ లో, వస్తువు (ల) యొక్క ప్రత్యేక గుర్తింపు లేదని నేను కూడా చెప్పాలనుకుంటున్నాను. 
 కాబట్టి, ఈ పాయింటర్ లేదా ఆబ్జెక్ట్ చిరునామా ప్రతిచోటా చిరునామాగా తీసుకోబడుతుంది, ఇది కొన్ని ఇతర వస్తువు-ఆధారిత వాటికి భిన్నంగా ఉంటుంది.