మాడ్యూల్6  C ++ లో ప్రోగ్రామింగ్ కు స్వాగతం.
 ఈ మాడ్యూల్‌లోని కాన్స్టాంట్ - నెస్ అనే భావనను మేము ఇప్పటికే చర్చించాము, మానిఫెస్ట్ స్థిరాంకాలను ఉపయోగించటానికి బదులుగా మనం వేరియబుల్ డిక్లరేషన్‌కు అర్హత సాధించగలమని చర్చించాము. వేరియబుల్ ఒకసారి ప్రకటించబడింది మరియు ప్రారంభించబడింది.
 పాయింటర్లతో కాన్ - నెస్ ఎలా పనిచేస్తుందో కూడా చూపించాము మరియు పాయింటెడ్ డేటా యొక్క స్థిరమైన పాయింటర్ యాన్స్ కాన్స్ట్ (నెస్) గురించి మాట్లాడుతాము.
 మేము దానికి అంటుకుంటాము.
 తరువాత, మేము అస్థిరత అని పిలువబడే సంబంధిత భావన గురించి మాట్లాడుతాము.
 ఈ అస్థిరత అంతగా తెలియని భావన కాబట్టి దాన్ని కొద్దిగా అర్థం చేసుకోవడానికి ప్రయత్నిద్దాం.
 మనం వేరియబుల్ గురించి ఆలోచించినప్పుడు, వేరియబుల్ మొదట్లో నిర్వచించినట్లు ప్రకటించిన తరువాత, వేరియబుల్ తో మనం ఏమి చేయగలం, అప్పుడు మనం వేరియబుల్ యొక్క విలువను చదువుతాము లేదా మనం ఎప్పుడైనా క్రొత్త విలువను కేటాయించవచ్చు.
 మేము ఎల్లప్పుడూ ప్రోగ్రామ్ చేసే ప్రాథమిక ఆస్తి, నేను వేరియబుల్ యొక్క విలువను చదివితే, నేను మళ్ళీ విలువను చదివితే, ఈ మధ్య కొంత కొత్త విలువను కేటాయించే వరకు మాత్రమే నేను మునుపటి విలువను పొందుతాను అని ఆశిస్తున్నాను. పూర్తయింది.
 నేను ఒక విలువను కేటాయించి, పలుసార్లు చదువుతూ ఉంటే, నేను తదుపరి నియామకం చేసే వరకు ఒకే విలువను పొందుతాను, ఇది వేరియబుల్ రాయడం యొక్క ప్రాథమిక భావన.
 ఇప్పుడు, ఈ సందర్భంలో const-ness ని చూద్దాం.
 మేము const-ness లో ఏమి చెప్తున్నామో, మనకు కేటాయించడానికి అనుమతి ఉంది లేదా ఆ కోణంలో విలువను ఒక్కసారి మాత్రమే ప్రారంభించండి మరియు తరువాత మార్చడానికి ఇది అనుమతించబడదు.
 కాబట్టి, ప్రోగ్రామ్ యొక్క మొత్తం జీవితకాలం ఈ వేరియబుల్ గురించి నేను చదివిన విలువ కాస్ట్-నెస్ వలె ఉంటుంది.
 దీనికి విరుద్ధంగా అస్థిరత ఇది అస్థిర విలువ అని చెప్తుంది, అంటే నేను వేర్వేరు పాయింట్ల వద్ద వేరియబుల్ చదివితే అదే విలువను పొందుతానని ఎటువంటి హామీ లేదు, నేను వేర్వేరు విలువలను పొందగలను.
 అందువల్ల, నేను దీన్ని చేయటానికి ఒక నియామకం చేయకపోయినా, అస్థిరత అనేది ఆవిరైన ఏదో సూచిస్తుంది.
 వేరియబుల్ 5 విలువను కలిగి ఉందని అనుకుందాం, మీరు దాన్ని ఒకసారి చదవండి, అప్పుడు మీరు అసైన్‌మెంట్ చేయవలసిన అవసరం లేదు, కానీ మీరు దానిని పది స్టేట్‌మెంట్ల తర్వాత చదవవచ్చు లేదా కొంత సమయం తరువాత ఈ విలువ 7 అని కనుగొనవచ్చు.
 5 విలువ ఆవిరయ్యే ముందు కనుమరుగైంది.
 కాబట్టి ఇది అస్థిర వేరియబుల్ యొక్క is హ.
 ప్రోగ్రామ్‌లో ఈ రకమైన వేరియబుల్ ప్రవర్తనను కలిగి ఉండటం ఎందుకు ముఖ్యం ఎందుకంటే ఇది జరిగే కొన్ని సిస్టమ్ పరిస్థితులు ఉన్నాయి, ఉదాహరణకు, నేను నెట్‌వర్క్ ప్రోగ్రామింగ్ కోడ్ (కోడ్) వ్రాస్తున్నాను, దీని ఉద్దేశ్యం పోర్టును వినడం కొనసాగించడం, ఉంటే కొన్ని డేటా వచ్చింది.
 కాబట్టి మీరు చేస్తున్నది మీరు ఆ పోర్టులో ఏదైనా రాయాలని ఆశిస్తున్నారు ఎందుకంటే మీరు సిస్టమ్ వెలుపల నుండి డేటాను ఆశిస్తున్నారు, కాబట్టి మీరు చదువుతున్నారు, చదువుతున్నారు, చదువుతున్నారు.
 ఏమి జరుగుతుంది? కొంత డేటా వచ్చినప్పుడు, మీ విలువ మారుతుంది, కాని మొదట విలువ బహుశా సున్నా అని మీరు చదివినప్పుడు, అకస్మాత్తుగా మీరు దాన్ని చదవవచ్చు. 100 మిల్లీసెకన్ల తరువాత కొంత విలువ వచ్చిందని మీరు కనుగొన్నారు, మీరు దానిని ఇస్తారు మరియు తర్వాత చదవవచ్చు 100 మిల్లీసెకన్లు.
 మరొక విలువ ప్యాకెట్ వచ్చినందున అది వేరే విలువలో ఉంది.
 ఆపరేటింగ్ సిస్టమ్ యొక్క హార్డ్‌వేర్ కెర్నల్ ద్వారా వేరియబుల్‌ను మరొక థ్రెడ్ ద్వారా మార్చడం సాధ్యమవుతుంది, కాబట్టి ఆ ప్రవర్తనను మాడ్యులేట్ చేయడం అవసరం మరియు సి ++ లోని ఈ భావన కలయికతో కూడిన మాడ్యూల్ ఎందుకంటే ఒక దయ ఇస్తుంది మీరు సంపూర్ణ సత్యం మరియు వేరియబుల్ యొక్క విలువ ఏమిటో మీకు తెలియదని హామీ ఇచ్చే మరొకటి.
 కాబట్టి అవి కలిసి క్లబ్ చేయబడతాయి మరియు మేము సివి క్వాలిఫైయర్, సి కొరకు కానిస్టేబుల్ వి కోసం సివి క్వాలిఫైయర్ అని పిలుస్తాము మరియు సివి క్వాలిఫైయర్ కాస్ట్ లేదా అస్థిరతతో వేరియబుల్ యొక్క ఏదైనా డిక్లరేషన్ ప్రిఫిక్స్ ఉపయోగించవచ్చు.
 దీనికి ఉదాహరణ చూపిస్తాం.
 ఇక్కడ, అస్థిరత ఎలా ఉపయోగపడుతుందో చూపించడానికి ప్రయత్నిస్తున్నాము.
 ఇది చాలా సులభమైన కోడ్, ఇది 0 నుండి i వరకు విలువలను కేటాయిస్తుంది మరియు తరువాత 100 కు సమానం కాని పరిస్థితిని చూడటానికి ప్రయత్నిస్తుంది.
 ఇప్పుడు, మీరు ఈ కోడ్‌ను చూపించినట్లయితే, అది అనంతమైన లూప్ అని మీరు వెంటనే గుర్తిస్తారు.
 ఇది అనంతమైన లూప్ ఎందుకు? ఎందుకంటే నేను విలువ 0 అయితే, నేను 100 సంవత్సరాల వయస్సులో ఉన్నానో లేదో తనిఖీ చేస్తున్నాను మరియు నేను వంద వయస్సు వచ్చేవరకు అకస్మాత్తుగా 100 విలువను చేయను.
 అందువల్ల ఈ పరిస్థితి ఎల్లప్పుడూ నిజం అవుతుంది కాబట్టి ఖచ్చితంగా ఈ లూప్‌ను కొనసాగించండి, కాబట్టి కంపైలర్ ఏమి చేస్తుందో కంపైలర్ స్వీకరిస్తుంది మరియు ఇది నిజమని చెబుతుంది, ఇది (1) అయితే మొత్తం వ్యక్తీకరణ పోతుంది.
 ఇప్పుడు మీరు దానిని అస్థిరతగా అర్హత పొందారని మేము చెప్తాము.
 ఇది అస్థిర వేరియబుల్ అని మీరు అంటున్నారు మరియు మీరు ఇప్పుడు ఆప్టిమైజ్ చేయని అదే కోడ్‌ను చదివారు లేదా ఈ కోడ్ వాస్తవానికి పని చేస్తుందని మీరు do హించరు ఎందుకంటే అస్థిర వేరియబుల్ కావడం వల్ల మరికొన్ని ఏజెంట్లు, కొన్ని హార్డ్‌వేర్, కొన్ని పోర్ట్‌లు ఉన్నాయని మీరు ఆశించారు. , కొన్ని కెర్నల్ సిస్టమ్స్, కొన్ని థ్రెడ్ కొన్ని ఇతర మార్గాల ద్వారా మారవచ్చు.
 కాబట్టి, దాని విలువ 100 అయ్యే వరకు మీరు వేచి ఉండండి మరియు ఏదో ఒక సమయంలో అది 100 అవుతుంది మరియు తరువాత ఒక నిర్దిష్ట పరిస్థితి తప్పుడు అవుతుంది మరియు ఫంక్షన్ తిరిగి రావచ్చు.
 ఇది సి, సి ++ లో అస్థిర వేరియబుల్ వాడకం.
 ఇప్పుడు మనం వెళ్లి # నిర్వచించు కోసం వేరే రకమైన వాడకం గురించి మాట్లాడుదాం, దీనిని సిపి ప్రాసెసర్ చేత మళ్ళీ ప్రాసెస్ చేయబడుతుంది, దీనిని మనం మాక్రోస్ అని పిలుస్తాము.
 వ్యత్యాసం ఏమిటంటే, మనకు పేరు ఉన్న # పదంతో వాటిని ఇప్పటికీ నిర్వచించాము, కాని ప్రధాన విషయం ఏమిటంటే మనకు ఇప్పుడు దానిలో ఒక పరామితి ఉంది.
 నేను ఉపయోగించినప్పుడు ఏమి జరుగుతుంది, నేను దానిని పారామితులతో ఉపయోగిస్తాను, కాబట్టి మేము ఒక తరగతి నిర్వచించిన పేరు అని చెప్తున్నాము మరియు దానికి ఒక పరామితిని పెడుతున్నాను, అది ప్రభావం చూపుతుంది, సి ప్రిప్రాసెసర్ నేరుగా వెళ్తుంది, X తో సరిపోతుంది మరియు భర్తీ చేస్తుంది నిర్వచించిన వ్యక్తీకరణలో A తో అన్ని X.
 ఇది సాధారణ x బేస్ ప్రత్యామ్నాయం.
 అందువల్ల, ఆ వ్యక్తీకరణలో x ను ఎక్కడ కనుగొన్నా, అది దానిని పరామితి a తో భర్తీ చేస్తుంది.
 ఇప్పుడు, మాక్రోలు సాధారణంగా C లో వర్ణించబడతాయి మరియు C ++ లో కూడా ఉపయోగపడతాయి, కాని ఇది సంజ్ఞామానం వంటి ఫంక్షన్‌ను వ్రాయడానికి అనుమతిస్తుంది.
 కాబట్టి మీకు # పంక్తిని నిర్వచించకపోతే మరియు మీరు ప్రధానంగా చదువుతుంటే తరగతి ఎక్కడ స్థూలంగా ఉందో మీకు తెలియదు లేదా ఇది ఒక ఫంక్షన్.
 కంపైలర్ విషయానికి వస్తే, కంపైలర్ అది వేరియబుల్ అని చూడలేనట్లు తిరిగి కనిపించిన సందర్భంలో, అది మీరు వ్రాసిన లేదా మీ చేత స్థిరమైన విలువను మాత్రమే చూస్తుంది.ఇది స్థిరమైన వ్యక్తీకరణ, ఇక్కడ మళ్ళీ కంపైలర్ ఏ విధమైన ఫంక్షన్ సంజ్ఞామానాన్ని చూడలేరు, ఇది CPP స్థానంలో ఉన్న వ్యక్తీకరణను చూడగలదు.
 అందువల్ల సి ప్రోగ్రామింగ్‌లో మాక్రోలు చాలా విస్తృతంగా ఉపయోగించబడుతున్నాయి మరియు ముఖ్యంగా సి లో ప్రయోజనాలు ఉన్నాయి, అనేక కారణాల వల్ల మీరు మాక్రోలు లేకుండా చేయలేరు.
 ఇది మీకు సామర్థ్యాన్ని ఇస్తుంది ఎందుకంటే మాక్రోలకు దానిపై ఫంక్షన్ అవసరం లేదు, కానీ అవి కూడా చాలా తీవ్రమైన ప్రతికూలతను కలిగి ఉంటాయి.
 మేము ఒకే తరగతి ఉదాహరణలో ఇక్కడ కొన్ని నాలుగు రెట్లు చూపిస్తాము మరియు మేము ప్రయత్నిస్తున్నాము, ఇది స్థూలమైనది మరియు ఇక్కడ నేను దీన్ని +1 తో ఉపయోగించడానికి ప్రయత్నిస్తున్నాను.
 ముందు, నేను దాన్ని ఉపయోగిస్తున్నాను, నేను దాన్ని +1 ఉపయోగించటానికి ప్రయత్నిస్తున్నాను, ఎవరైనా చదివితే మానసిక అవగాహన ఉంటుంది, 1 జోడించబడుతుంది, కనుక ఇది 4 అవుతుంది మరియు అది చెల్లించబడుతుంది. వెళ్తుంది, కాబట్టి ఇది 16 అవుతుంది.
 కానీ, మీరు ఈ ప్రోగ్రామ్‌ను నడుపుతున్నప్పుడు మేము వాస్తవానికి అవుట్పుట్ 7 ను పొందుతాము మరియు మీరు స్థూలని విస్తరించాలని అర్థం చేసుకోవడానికి, ఇప్పుడు ఈ స్థూలతను ఈ రేఖకు విస్తరించండి.
 స్థూల x ను + 1 తో భర్తీ చేసినట్లు మీరు చూడవచ్చు, కాబట్టి మీరు కేవలం + 1 వ్రాస్తే, x కి బదులుగా అది + 1 * a +1 అవుతుంది మరియు అది ముందు వ్యక్తీకరణ అవుతుంది మరియు సానుభూతి వర్తిస్తుంది.
 కాబట్టి, 1 రెట్లు 1 మధ్యలో ఉన్న 'a' కి ప్రాధాన్యత లభిస్తుంది, తద్వారా మొదటిది పనిచేస్తుంది, కనుక ఇది ఆచరణాత్మకంగా 2a + 1 అవుతుంది.
 కనుక ఇది 7 అవుతుంది, కాబట్టి ఇది మొత్తం సమస్యను కలిగిస్తుంది.
 అదృష్టవశాత్తూ, మీరు మాక్రో నిర్వచనంలో ప్రతి X లేదా పారామితి యొక్క ప్రతి ఉదాహరణ చుట్టూ పరామితిని ఉంచినట్లయితే పరిష్కరించగల సమస్య, మీరు అలా చేస్తే, అది ఎలా సహాయపడుతుంది? విల్? మేము పొడిగింపును మాత్రమే చూడగలం, ఇది సహాయపడుతుంది, ఎందుకంటే బ్రాకెట్ చొప్పించబడింది, స్థూల విస్తరించిన తర్వాత, ఈ స్లైడ్ యొక్క చివరి వరుసలో + 1 చుట్టూ బ్రాకెట్ ఉందని మీరు చూడవచ్చు.
 కాబట్టి, ఇది (a + 1) * (a + 1) ఇప్పుడు BODMAS నియమం ఒక + 1 ను మనం ఇంతకు ముందు expected హించినట్లుగా ఉండాలి అని చెబుతుంది, కనుక ఇది ఇంకా పరిష్కరించబడుతుంది.
 మరింత ముందుకు వెళ్దాం.
 మీరు x వ్రాసే ప్రతిసారీ, మీరు దాని చుట్టూ బ్రాకెట్లను ఉంచవలసి ఉంటుందని మీరు గుర్తుంచుకోవలసి వస్తే ఇది నిజంగా బాధించేది, లేకపోతే మీరు ఆశ్చర్యపోవచ్చు.
 తరువాత, పరిస్థితి నిజంగా అధ్వాన్నంగా ఉన్న ఒక ఉదాహరణను చూద్దాం, ఎందుకంటే, ఇప్పుడు మేము స్థూల నిర్వచనాన్ని పరిష్కరించాము, ఇప్పుడు మనం దాన్ని మళ్ళీ ఉపయోగించటానికి ప్రయత్నిస్తున్నాము మరియు నేను దానిని ++ A తో ఉపయోగించాలనుకుంటున్నాను, A ప్లస్ ప్లస్ a ప్రీ-స్కేల్డ్.
 A 3 అయితే, ఇక్కడ ప్లస్ ప్లస్ I 4 అవుతుందని భావిస్తే, 4 తప్పనిసరిగా చదరపులోకి వెళ్ళాలి, అది స్క్వేర్ చేయాలి. ఇది 4 సార్లు ఉండాలి 4. ఫలితం 16 ఉండాలి.
 ఫలితం 25 అని మీరు ప్రయత్నించండి.
 ఎందుకు? ఈ స్థూల పొడిగింపును మళ్ళీ పరిగణించండి, అది విస్తరించినట్లయితే ఇది ఇలా కనిపిస్తుంది, ఎందుకంటే రెండు x లు ఉన్నాయి కాబట్టి వాటిలో ప్రతిదానికి ++ A వ్రాయబడుతుంది.
 కాబట్టి ఏమి జరుగుతుంది, ++ కు అత్యధిక ప్రాధాన్యత ఉంది, గుణకారం కంటే ఎక్కువ ప్రాధాన్యత ఉంది, కాబట్టి గుణకారం గుణకారం ముందు ప్లస్ మరియు ప్లస్ రెండింటినీ కలిగి ఉంటుంది, 3 మొదటిది 4, తరువాత అది 5 అవుతుంది మరియు తరువాత గుణకారం జరుగుతుంది.
 అందువల్ల ఫలితం 25 హించిన విధంగా 25.
 కథ యొక్క దురదృష్టకర భాగం సి లో తేలికైన స్థిరీకరణ కాదు.
 అందువల్ల, మీరు మాక్రోలలో ఈ రకమైన సంభావ్య ఆపదలతో జీవించాలి.
 కాబట్టి, సి ++ లో ఇన్లైన్ ఫంక్షన్ అనే కొత్త ఫీచర్ ఉంది.
 దీన్ని ఎలా చేయాలో నేను మొదట నిర్వచించాలి మరియు అది మాక్రోలకు ఎలా సంబంధం కలిగిస్తుందో వివరిస్తాము. ఇన్లైన్ ఫంక్షన్ మరొక ఫంక్షన్. ఒక నిర్దిష్ట రకం ఫంక్షన్ మాత్రమే తేడా కాదు, ఫంక్షన్ యొక్క ప్రోటోటైప్ (ఫంక్షన్) లోని హెడర్‌లో మీరు రిటర్న్ రకానికి ముందు తదుపరి ఇన్లైన్ వ్రాస్తారు. (ఇన్లైన్).
 ఫంక్షన్‌ను అసలు ఫంక్షన్ కాల్ అని పిలిచినప్పుడు మీరు ఈ కీవర్డ్‌ను ఇన్‌లైన్‌లో వ్రాస్తే ఏమి జరుగుతుంది, కానీ అది జరగదు, కానీ ఏ ఫంక్షన్ (ఫంక్షన్) ఫంక్షన్ (ఫంక్షన్) కంపైలర్ కాల్ సైట్‌లో ఉంచే కోడ్ రూట్.
 అందువల్ల, ఒక ఫంక్షన్ యొక్క ఓవర్ రేట్ కాల్ వాయిదా వేయబడింది, కాబట్టి, మేము ఫంక్షన్‌ను నిర్వచించాము, మేము ఫంక్షన్ హెడర్‌ను ఇన్‌లైన్‌తో ప్రిఫిక్స్ చేస్తాము, ఇది కుడి వైపు మాత్రమే. సి ++ కోడ్‌లో మిగిలి ఉన్న వాటిపై దృష్టి పెడదాం. ఆన్. కుడి వైపు మీ సూచన యొక్క అసలు సి కోడ్, ఇది మేము హాష్ మాక్రోను నిర్వచించలేదు. స్క్వేర్ అనేది x రిటర్న్ x ను పూర్ణాంకంగా తీసుకునే ఫంక్షన్ అని మేము చెప్తున్నాము మరియు మేము దానిని ముందు ఇన్లైన్ కీవర్డ్తో ప్రిఫిక్స్ చేస్తున్నాము.
 దీని కోసం ఉపయోగించిన కోడ్ మరియు ఇక్కడ అదే విధంగా ఉంది.
 ఇప్పుడు, ప్రయోజనం ఏమిటంటే C ++ లో, ఇది వాస్తవానికి ఒక ఫంక్షన్.
 కాబట్టి మేము ఇంతకుముందు చూపిస్తున్న ప్రతికూలతలను మీరు కలిగి ఉండకూడదు, ఇది మొదట పారామితిని అక్షరాలా అంచనా వేస్తుంది మరియు ఆ మూల్యాంకన విలువను తీసుకొని ఫంక్షన్‌ను పిలుస్తుంది.
 కాబట్టి మీరు ఇక్కడ + 1 ను పాస్ చేస్తే, అది మొదట 1 గా 4 గా చేసి, తరువాత పాస్ అవుతుంది, మీరు ++ a చేస్తే అది 3 నుండి 4 కి పెరుగుతుంది మరియు పాస్ అవుతుంది.
 అందువల్ల, మీకు హాని జరగదు
 కానీ మీరు హాష్ నిర్వచించిన మాక్రోలతో మాక్రోల యొక్క ప్రయోజనాన్ని పొందుతారు, మీరు ఫంక్షన్ యొక్క తలపై నివారించగలిగారు, అన్ని పారామితులను కోపింగ్ అని పిలుస్తారు, తరువాత బదిలీని నియంత్రించండి, తరువాత గణన చేసి ఆపై నియంత్రించండి మరియు తిరిగి బదిలీ చేయండి
 రిటర్న్ విలువ కారణంగా ఇవన్నీ వాయిదా వేయవచ్చు ఎందుకంటే కంపైలర్ వాస్తవానికి నేను ఇక్కడ చేస్తున్న సైట్‌లో ఫంక్షన్ అని పిలువబడే x సార్లు x ఉంచడానికి ప్రయత్నిస్తుంది.
 కాబట్టి, ఇన్లైన్ యొక్క ప్రాథమిక లక్షణం ఇది.
 కాబట్టి ప్రాధమిక లక్షణాలు మరియు విధుల రకాలను రక్షించేటప్పుడు స్థూల ప్రయోజనాన్ని పెద్ద ఎత్తున పొందడానికి ఇన్లైన్ సహాయపడుతుంది.
 మేము వాటిని పక్కపక్కనే పోల్చగలిగితే, అప్పుడు మాక్రోలు విస్తరించబడతాయి, ఇవి ఇన్లైన్ స్థానంలో విస్తరించబడతాయి, ఏదో ఒకవిధంగా కాల్ స్థలం విస్తరించబడుతుంది.
 మాక్రో టెక్స్ట్ రూపంలో విస్తరించినందున మీకు చూపించడం సాధ్యం కాదు, కాబట్టి నేను దానిని మీకు వివరించగలను, కాని అసెంబ్లీ కోడ్ (కోడ్) లేదా బైనరీ కోడ్ పరంగా ఇన్లైన్ (ఫంక్షన్) విస్తరించబడింది, కాబట్టి ఇది సాధ్యం కాదు దీన్ని చాలా తేలికగా అర్థం చేసుకోండి, కాని మేము చేయగలిగేది మీరు పిలిచిన సైట్ యొక్క విధిగా తీసుకోండి.
 రెండూ అమలులో సమర్థవంతంగా పనిచేస్తాయి మరియు రెండూ కోడ్‌ను ఉబ్బుతాయి.
 కోడ్ మొదట వస్తుంది, ఎందుకంటే ఏమి జరుగుతుందో మీకు ఒక ఫంక్షన్ నిర్వచించబడింది మరియు మీరు 10 ప్రదేశాలలో స్థూలతను అమలు చేయగల స్థూలతను చేస్తుంటే, మొత్తం స్థూల కోడ్ (కోడ్) పదిసార్లు కాపీ చేయబడుతుంది.
 అదేవిధంగా, నేను ఫంక్షన్ ఇన్లైన్ కలిగి ఉంటే మరియు పది ప్రదేశాలలో పిలిస్తే, ఫంక్షన్ బాడీ పది ప్రదేశాలలో ఉంటుంది కాబట్టి కోడ్ పెద్దదిగా ఉంటుంది.
 మేము కొన్ని మృదువైన సాధారణ సాఫ్ట్‌వేర్ సిస్టమ్‌ల గురించి చింతించకపోవచ్చు, కాని మనం మొబైల్ ఫోన్‌ల కోసం ప్రోగ్రామ్‌లను వ్రాసేటప్పుడు మరియు పరికరాలను నిర్వహించేటప్పుడు మెమరీ నిజంగా చిన్నది వంటి ఇతర సందర్భాల్లో మేము ఆందోళన చెందుతాము. ప్రోగ్రామ్ పెద్దదైతే ఆ అనువర్తనానికి సరిపోయేలా అవుతుంది, ఎందుకంటే మీరు అనువర్తనం పరిమాణంతో కూడా ఆందోళన చెందుతున్నారు.
 కానీ మేము దానిలో చాలా లోతుగా ఉండము.
 తరువాతి విషయం ఏమిటంటే, మాక్రోలకు వాక్యనిర్మాణ మరియు అర్థ నష్టం ఉంది, వాటిలో రెండు చూపించాము, ఒక + 1 వాక్యనిర్మాణ లోపం కాబట్టి వాటి చుట్టూ బ్రాకెట్లను ఉంచడం ద్వారా మేము దానిని నిర్వహించగలుగుతాము, ++ వాక్యనిర్మాణ లోపం. ఎందుకంటే ప్లస్ అమలు చేయబడిన విధానం, మేము దానిని వదిలివేయవలసి ఉంటుందని మేము నిర్వహించలేకపోయాము, కాని ఇన్లైన్ ఫంక్షన్లో అలాంటి తగ్గింపు ఉండదు.
 ఇన్లైన్ ఫంక్షన్ల వలె ఖచ్చితంగా మాక్రోలు పారామితుల కోసం రకాలను తనిఖీ చేయవు.
 అందువల్ల, వాటి పారామితులు దృ are ంగా ఉంటాయి, కాబట్టి పూర్ణాంక రకం విలువ కోసం ఉద్దేశపూర్వకంగా వ్రాయబడిన స్థూలతను అనుకోకుండా కొన్ని డబుల్ వేరియబుల్, కంపైలర్ అవగాహనతో పిలుస్తారు లేదా పిలవవచ్చు. దీన్ని చేయలేము, ఇన్లైన్ ఫంక్షన్ అయితే కాదు, అది సాధ్యమే ఎందుకంటే అది మన దగ్గర ఉన్న పని మాత్రమే.
 అయినప్పటికీ, నా మాక్రోలకు ప్రయోజనాలు ఉన్నాయి, ఇది రకం కోసం తనిఖీ చేయలేదనే వాస్తవం కొన్ని కోడ్ రాయడానికి మాకు సహాయపడుతుంది.
 ఉదాహరణకు, నేను రెండు వేరియబుల్స్ మార్చుకోవడానికి ఒక కోడ్ రాయాలనుకుంటున్నాను.
 ఇప్పుడు, రెండు వేరియబుల్స్ మార్పిడి చేయడానికి, కోడ్ పూర్ణాంక వేరియబుల్‌ను మార్చుకోవచ్చు, డబుల్ వేరియబుల్‌ను మార్చుకోవచ్చు, చార్ వేరియబుల్‌ను మార్చుకోవచ్చు.
 మీరు C ++ లో వ్రాయవలసి వస్తే, అప్పుడు స్వాప్ ఫంక్షన్, ఒక స్వాప్ ఫంక్షన్ ఇవన్నీ చేయలేవు ఎందుకంటే నేను రెండు పూర్ణాంక చరరాశులను మార్చుకోవలసి వస్తే నా పారామితులు టైప్ Int గా ఉంటాయి, నాకు రెండు డబుల్ వేరియబుల్స్ ఉంటే నేను కావాలనుకుంటే స్వాప్ (వేరియబుల్) అప్పుడు నా పారామితులు రెండు రకాలుగా ఉంటాయి, నేను రెండు పాయింట్లను మార్చుకోవాలనుకుంటే నా పారామితులు పాయింటర్ రకంగా ఉంటాయి.
 కాబట్టి నేను ఆ ఫంక్షన్‌ను సి ++, మరియు ఇన్‌లైన్‌లో సులభంగా వ్రాయలేను
 మాక్రో ఆ రకమైన చెకింగ్ చేయనందున నేను దానిని స్థూలంగా వ్రాసి స్వాప్ చేయగలను, అది కేవలం రెండు వేరియబుల్స్ ఉన్నాయని తనిఖీ చేస్తుంది మరియు మూడవ వేరియబుల్ మూడు అసైన్‌మెంట్‌లు మనకు తెలుసు, స్వాప్ ఎలా చేయాలో ఆ కోడ్‌ను మాత్రమే ఉంచుతుంది ఇక్కడ.
 కాబట్టి, మాక్రోలు కొన్ని ప్రయోజనాలను అందిస్తాయి మరియు కోర్సు చివరలో కదులుతున్నప్పుడు మీరు ఇన్లైన్ ఫంక్షన్లతో కూడా చేయగలరని మేము చూపిస్తాము, కాని C ++ యొక్క చాలా తరువాత లక్షణాలు టెంప్లేట్లు అని పిలుస్తారు; మీరు చర్చించినప్పుడు అది ఎలా జరుగుతుందో మేము చూపుతాము.
 చివరగా, మాక్రోల కోసం ఇన్లైన్ ఫంక్షన్‌ను కంపైల్ చేయడానికి లోపం తనిఖీ లేదు, లోపాలు తనిఖీ చేయబడతాయి మరియు వాస్తవానికి మానిఫెస్ట్ నిరంతర మాక్రోలు (మాక్రోలు) కూడా డీబగ్గర్కు కనిపిస్తాయి.అవి కావు.
 మీరు డీబగ్ చేయడానికి ప్రయత్నిస్తే మీరు క్లాస్ మాక్రోను చూడలేరు ఎందుకంటే వాస్తవానికి కంపైలర్ ఆ తరగతిని ఎప్పుడూ చూడలేదు ఎందుకంటే ఇది ముందు ప్రాసెసర్ ద్వారా భర్తీ చేయబడింది.
 అయితే, ఇన్లైన్ ఫంక్షన్ కోసం మీరు డీబగ్ బిల్డ్‌లో అన్నీ చూడగలరు.
 మీరు డీబగ్‌ను నిర్మిస్తే, మీరు దాన్ని చూస్తారు.
 నేను ఇక్కడ హైలైట్ చేయవలసిన వ్యత్యాసం ఏమిటంటే, మీరు డీబగ్ బిల్డ్ చేస్తే కంపైలర్ చేసే ఇన్లైన్ ఫంక్షన్ (ఫంక్షన్) 1 లక్షణంతో, మీరు విడుదలను నిర్మిస్తే ఇన్లైన్ చేయరు. ఇన్లైన్ చేయడం జరుగుతుంది.
 మీరు డీబగ్ బిల్డింగ్ అయితే, ఇన్లైన్ ఫంక్షన్ ఏ ఇతర ఫంక్షన్ లాగా ఉంటుంది, కాబట్టి మీరు ఆ ఫంక్షన్ లో డీబగ్ చేయవచ్చు.
 ఎందుకంటే డీబగ్ బిల్డ్‌లో నేను డీబగ్ చేయాలనుకుంటున్నాను అని చెప్తున్నాను. ఏమి జరుగుతుందో నేను చూడాలనుకుంటున్నాను. అయితే, విడుదల లేదా ప్రొడక్షన్ బిల్డ్‌లో మీకు నిజంగా సామర్థ్యం కావాలి, కోడ్ వేగంగా నడపాలని మీరు కోరుకుంటారు.
 కాబట్టి, మీరు ఇకపై డీబగ్ చేయడానికి మొగ్గు చూపరు. మీరు ఇప్పటికే డీబగ్ చేసారు. ఇది సరైనదని మీకు తెలుసు, వాస్తవానికి ఇన్లైన్ సంభవించినప్పుడు, ఇది కొంచెం సూక్ష్మమైన విషయం, కానీ దయచేసి గమనించండి. కాలక్రమేణా మీరు ఈ అంశాలను క్రమంగా అర్థం చేసుకుంటారు.
 I
 అందువల్ల, మీరు ఎల్లప్పుడూ ఇన్‌లైనింగ్ ఉపయోగించాలని మేము సూచిస్తున్నాము.
 అయితే మీరు తెలుసుకోవలసిన కొన్ని పరిమితులు ఉన్నాయి.
 ఇన్లైన్ చేయడాన్ని డైరెక్టివ్ అంటారు.
 ఒక భాషలోని సూచన కంపైలర్‌కు సూచన, మీరు కంపైలర్‌కు చెబుతున్నారు.ఈ ఫంక్షన్‌ను ఇన్లైన్ చేయడం ఉపయోగకరంగా ఉంటుందని నేను భావిస్తున్నాను, కానీ ఇది తప్పనిసరి కాదు, ఇది కంపైలర్‌పై కట్టుబడి లేదు., ఇది తప్పనిసరిగా ఇన్‌లైన్‌లో ఉండాలి.
 కాబట్టి మీరు ఇన్లైన్ అని చెప్పాలి, కాని కంపైలర్ ఫంక్షన్ ఇన్లైన్ చేయదు.
 కంపైలర్ ఇన్లైన్ చేయడంలో సమస్య ఉందని కనుగొంటే, లేదా ఇన్లైన్ చేయడం నిజంగా సామర్థ్యానికి సహాయపడదు.
 ఉదాహరణకు, చాలా సరళమైన ఉదాహరణలో, ఒక ఫంక్షన్ బాడీ చాలా పెద్దదిగా ఉంటే, రీ-ఇన్లైన్ చేయడం ద్వారా మీరు చేస్తున్నది ఏమిటంటే ఫంక్షన్ (ఫంక్షన్) కాల్ ఫంక్షన్‌ను పిలవడానికి అవసరం లేదు. వ్రాయవలసిన అవసరం లేదు, మిగిలినవి ఎలాగైనా లెక్కించాలి.
 ఫంక్షన్ బాడీ చాలా పెద్దది అయితే, అదనపు ఓవర్ కాల్స్ మరియు రిటర్న్స్ చాలా తక్కువగా ఉంటాయి, కాబట్టి మీరు ఇన్లైన్ ఇన్లైన్ చేయడంలో ఇబ్బంది పడకూడదనుకుంటున్నారు, కానీ ఫంక్షన్ బాడీ చాలా ఉంటే ఇన్లైన్ చిన్నది అయితే నిజమైనది .
 కంపైలర్ ఇన్లైన్ చేయాలనుకుంటున్నారా లేదా అనేది నిర్ణయిస్తుంది.
 చాలా సందర్భాల్లో, రివర్స్ C ++ లో కూడా నిజం, ఒక ఫంక్షన్ ఇన్లైన్ కావచ్చు అని మీరు చెప్పలేదు, కాని కంపైలర్ దానిని ఇన్లైన్ చేయగలదు మరియు ఇన్లైన్లో నైపుణ్యం ఉన్నట్లు కనుగొనవచ్చు.
 రెండవ విషయం ఏమిటంటే ఇన్లైన్ ఫంక్షన్లు పునరావృతం కావు.
 మనం ఏమి చెప్తున్నామో, ఇన్లైన్కు బదులుగా, ఫంక్షన్ కాల్ దశలో, ఫంక్షన్ యొక్క శరీరాన్ని ఇన్సర్ట్ చేస్తాము. ఒక ఫంక్షన్ పునరావృతమైతే, శరీరంలోనే మరొక కాల్ ఉంటుంది.
 కాబట్టి, ఆ కాల్‌లో, మీరు ఫంక్షన్ యొక్క బాడీని మళ్ళీ ఉంచాలి, దీనిలో రెండవ కాల్ జరుగుతుంది.
 ఇప్పుడు మీరు ఎన్నిసార్లు ఉంచారో పునరావృతం ఎంత లోతుగా ఉంటుందో దానిపై ఆధారపడి ఉంటుంది, మీకు విలువలు వచ్చేవరకు మీకు తెలియదు, మీరు కారకమైన 3 చేయటానికి ప్రయత్నిస్తున్నారా లేదా కారకమైన 77 చేయడానికి ప్రయత్నిస్తున్నారో మీకు తెలిసినంతవరకు.
 ఎన్నిసార్లు ఇన్లైన్ చేయవలసి ఉంది, కాబట్టి పునరావృత ఫంక్షన్ ఇన్లైన్లో ఉండకూడదు, అవి తప్పనిసరిగా ఒక సాధారణ ఫంక్షన్ అయి ఉండాలి.
 కాబట్టి, ఇన్లైన్ శరీరాన్ని భర్తీ చేస్తుంది.
 మూడవ పాయింట్‌లో మీరు ఫంక్షన్‌ను ఇన్లైన్ చేయాలనుకుంటే, ఫంక్షన్ బాడీ కూడా హెడర్ ఫైల్‌లో ఉండాలి.
 మొదటి మాడ్యూల్ 1 లో, మేము సోర్స్ ఆర్గనైజేషన్ గురించి మాట్లాడాము, అక్కడ వారు అన్ని ఫంక్షన్ హెడర్లు హెడర్ ఫైళ్ళలో ప్రోటోటైప్లుగా ఉండాలి, డాట్ హెచ్ ఫైల్స్ ఫంక్షన్ బాడీ ఫంక్షన్లు వేరుగా ఉంటాయి. డాట్ సిపిపి ఫైళ్ళలో ఉండాలి, కానీ ఇన్లైన్ ఫంక్షన్ కు ఇది సాధ్యం కాదు ఫంక్షన్ ఎందుకంటే ఒక అనువర్తనం ఫంక్షన్ ప్రోటోటైప్‌ను చూసినప్పుడు అది ఇన్లైన్ (ఇన్లైన్) అని చూసేవరకు, అది శరీరాన్ని ఎలా భర్తీ చేస్తుంది.
 కాబట్టి శరీరం ఇన్లైన్ ఫంక్షన్ కోసం హెడర్లో ఉండాలి.
 ఖచ్చితంగా ఇన్లైన్ ఫంక్షన్లకు రెండు వేర్వేరు నిర్వచనాలు ఉండకూడదు ఎందుకంటే దీనికి రెండు వేర్వేరు నిర్వచనాలు ఉన్నాయి, అప్పుడు రెండు ఆహ్వానాలు రెండు వేర్వేరు ప్రవర్తనలను కలిగి ఉంటాయి.
 కాబట్టి, ఇవి కొన్ని పరిమితులు లేదా ఇన్లైన్ యొక్క పరిమితులు గుర్తుంచుకోవాలి.
 సారాంశంలో, మేము సి కొరకు స్థిరమైన స్థిరాంకాన్ని తిరిగి సందర్శించాము; నేను మొత్తం మాడ్యూల్ 6 గురించి మాట్లాడుతున్నాను.
 అందువల్ల, మేము మానిఫెస్ట్ స్థిరాంకాన్ని పున ited సమీక్షించాము మరియు C ++ లో లభ్యమయ్యే కాస్ట్-నెస్ అనే భావనను మేము అర్థం చేసుకున్నాము మరియు మానిఫెస్ట్ స్థిరాంకం కంటే మలబద్ధకం యొక్క ప్రయోజనాలు ఏమిటో మనం చూశాము.
 తారాగణం మరియు పాయింటర్ ఇంటర్‌ప్లే ఎలా ఉంటుందో కూడా చూశాము.
 డేటా యొక్క అస్థిరత కోసం మేము పరిచయం చేసాము మరియు సి ++ ప్రోగ్రామ్‌లలో అస్థిర డేటాను ఎలా ఉపయోగించవచ్చో చూశాము.
 తరువాత, మేము మాక్రోలను సి పారామితి రూపంతో పునర్నిర్వచించాము మరియు మాక్రోలను మార్చడానికి ఇన్లైన్ (ఫంక్షన్) లేదా ఫంక్షన్ (ఫంక్షన్) ఇన్లైనింగ్ ఉపయోగించబడుతుందని చూపించాము.అయితే మాక్రోలు అందించే అనేక వాక్యనిర్మాణ మరియు అర్థ సమస్యల ప్రయోజనంతో ఇది చేయవచ్చు.
 చివరగా, మేము ఇన్లైన్పై పరిమితులను కూడా చూశాము.