Recap of C (Lecture -03)-M9ArEaQIGpw

 మనము C.++ ప్రొగ్రామ్మింగ్ 01 లో కొనసాగుతున్నాము,
 సి యొక్క పునశ్చరణ. ఇది మూడవ భాగం..
 మొదటి రెండు భాగాలలో మనము డేటా రకాలు, వేరియబుల్స్, expression, ఆదేశాలు(Statements) గురించి మాట్లాడాము.
 మరియు, రెండవ భాగంలో మనం వివిధ ఉత్పన్న రకాలు, శ్రేణులు, structures, union మరియు pointer గురించి మాట్లాడాం.
 స్పాట్‌లో, మేము సి యొక్క ప్రాథమిక మాడ్యులర్ కాన్సెప్ట్‌తో ప్రారంభిస్తాము, ఇది ఒక ఫంక్షన్.
 అందువల్ల, ఒక ఫంక్షన్ గణన యొక్క నిర్దిష్ట ఫంక్షన్‌ను చేస్తుందని మీ అందరికీ తెలుసు.
 ఒక ఫంక్షన్ బ్లాక్ బాక్స్‌గా భావించబడే విషయం, ఇది చాలా పారామితులను తీసుకొని మీకు ఫలితాన్ని ఇస్తుంది.
 ఇప్పుడు, ఒక ఫంక్షన్ ఒకటి లేదా అంతకంటే ఎక్కువ పారామితులను తీసుకుంటుందని మేము సాధారణంగా ఆశిస్తున్నప్పుడు, మీరు ఏ పరామితిని తీసుకోని ఫంక్షన్‌ను వ్రాసే అవకాశం ఉంది.
 మరియు, ఇది గణన చివరిలో మీకు విలువను ఇస్తుంది. ఇది ఫలితాన్ని ఇస్తుందని మేము చెప్తాము.
 కానీ, ఫలితం లేదని కూడా చెప్పవచ్చు.
 ఫంక్షన్ యొక్క పారామితుల సంఖ్య; ప్రతి పరామితిని ఆర్గ్యుమెంట్ అని కూడా పిలుస్తారు, మనకు ఒక రకం ఉంటుంది.
 మరియు, మేము రకాన్ని పేర్కొనకూడదనుకుంటే, మేము శూన్యతను ఉపయోగించవచ్చు.
 రిటర్న్లలో టైప్ శూన్యత కూడా ఉపయోగించబడుతుంది.
 మరియు, తిరిగి రావడానికి ఏమీ లేకపోతే మేము శూన్యతను ఉపయోగిస్తాము.
 ఒక నిర్దిష్ట ప్రకటన ఇలా ఉంటుంది; ఫంక్షన్ అంటే ఫంక్షన్ పేరు.
 ఈ జత కుండలీకరణాల్లో, ఎడమ వైపున, తిరిగి వచ్చే రకం మరియు కుడి వైపున, మనకు పారామితులు ఉన్నాయి.
 ఒకటి కంటే ఎక్కువ పరామితులు ఉంటే, అవి కామాలతో వేరు చేయబడతాయి.
 మరియు, మీరు ఈ బ్రాకెట్ చివరలో సెమికోలన్ ఉంచినట్లయితే, ఫంక్షన్ ఏమి తీసుకుంటుందో మరియు అది ఎలాంటి విలువను ఇస్తుంది అనే దాని గురించి మాట్లాడటానికి మాత్రమే మీకు ఆసక్తి ఉందని మాకు తెలుసు.
 అయినప్పటికీ, ఈ ఫంక్షనల్ ఫంక్షన్ వాస్తవానికి x మరియు y పారామితుల నుండి ఫలిత పూర్ణాంకాన్ని ఎలా లెక్కిస్తుందో పేర్కొనడానికి మీకు ఆసక్తి లేదు.
 అలాంటి సందర్భాల్లో, మీరు సెమికోలన్‌తో వాదనల జాబితాలో ఆధిపత్యం చెలాయిస్తే, అది ఫంక్షన్ హెడర్ లేదా ఫంక్షన్ ప్రోటోటైప్ లేదా ఫంక్షన్ సిగ్నేచర్ అని మేము చెబుతాము.
 ఇంకా ఎక్కువ, సి ++ లో సంతకం లేదా ప్రోటోటైప్ రకం నిబంధనలు కొనసాగుతూనే ఉంటాయి.
 మరియు ఈ సందర్భంలో, సంతకాల విషయంలో, ఫలితాన్ని లెక్కించడానికి x మరియు y ఎలా ఉపయోగించబడుతుందో మేము నిజంగా పేర్కొనలేదు.
 మీరు x లేదా y లేదా రెండింటినీ పేర్కొన్నా ఇది ఐచ్ఛికం.
 మీరు దీన్ని int funct (int, int) మాత్రమే చేయవచ్చు; ఇలా వ్రాయవచ్చు; ఇది చెల్లుబాటు అయ్యే శీర్షిక కూడా అవుతుంది.
 కాబట్టి ఇది మనకు ఏమి చెబుతుంది? ఇది రెండు పారామితులు ఉన్నాయని మాకు చెబుతుంది.
 మొదటి పరామితి పూర్ణాంకం; రెండవ పరామితి మరొక పూర్ణాంకం.
 ఇది ఫంక్షన్ పేరు ఫంక్షనల్ అని మాకు చెబుతుంది, ఇది ఏ రకమైన విలువను తిరిగి ఇస్తుందో మాకు చెబుతుంది, అదే తేడా.
 ఇది ఫంక్షన్ డిక్లరేషన్ లేదా హెడర్ యొక్క ఉద్దేశ్యం.
 ఇప్పుడు, ఈ ఫంక్షన్ (ఫంక్షన్) ఏమి లెక్కిస్తుందో లేదా ఫంక్షన్ (ఫంక్షన్) పారామితుల నుండి ఫలితాన్ని ఎలా లెక్కిస్తుందో పేర్కొనడానికి మేము సిద్ధంగా ఉన్నప్పుడు, మేము ఫంక్షన్ (ఫంక్షన్) శరీరాన్ని అందిస్తాము; ఇది మొత్తం ఫంక్షన్లుగా సమ్మేళనం స్టేట్మెంట్.
 కాబట్టి, ఇది ఒక జత బ్రాకెట్లు, వంకర కలుపులు, దీనిలో ఫంక్షన్ బాడీ తిరిగి రావాలి.
 అందువల్ల, ఇది ఫంక్షన్ బాడీని పేర్కొనే అనేక ప్రకటనలు మరియు ప్రకటనలను కలిగి ఉండవచ్చు.
 ఒక ఫంక్షన్‌కు రిటర్న్ స్టేట్‌మెంట్ ఉంటుంది, ఇది రిటర్న్ టైప్ ఎక్స్‌ప్రెషన్‌ను తుది ఫలితం వలె అందిస్తుంది.
 ఫంక్షన్ ఏదైనా తిరిగి ఇవ్వకపోతే, ఫంక్షన్ టైప్ రిటర్న్ (శూన్యమైనది) అయితే, రిటర్న్ స్టేట్మెంట్ అనుబంధ వ్యక్తీకరణను కలిగి ఉండదు.
 సి 89 లో, ఒక ఫంక్షన్ (ఫంక్షన్) ఏదైనా తిరిగి ఇవ్వకపోతే, రిటర్న్ స్టేట్మెంట్ పేర్కొనడం అవసరం లేదని దయచేసి గమనించండి.
 ఆ ప్రోటోకాల్ ఇప్పటికీ కొనసాగుతోంది.
 కానీ, చాలా కారణాల వల్ల మనం సి ++ ఎక్కువ చేసినప్పుడు స్పష్టంగా తెలుస్తుంది.
 మీరు ఒక ఫంక్షన్ రాయడం మరియు రాబడిని ఉంచడం ఖచ్చితంగా నివారించదగినది.
 అందువల్ల, మీరు రిటర్న్ రకం, శూన్యమైన (శూన్యమైన) ఫంక్షన్ నుండి ఏదైనా తిరిగి ఇవ్వలేనప్పటికీ, దయచేసి రిటర్న్ స్టేట్మెంట్ ఇవ్వండి.
 ఇప్పుడు, ఫంక్షన్లు వాటి పారామితులను ఒక యంత్రాంగం ద్వారా తీసుకుంటాయి, దీనిని విలువ ద్వారా కాల్ అంటారు.
 కాల్ సైట్లో, ఉదాహరణ ఇక్కడ ఉందని మీ అందరికీ తెలుసు అని నేను అనుకుంటున్నాను.
 ఎగువన, మీరు ఫంక్షన్ బాడీ యొక్క పూర్తి నిర్వచనాన్ని చూడవచ్చు.
 మరియు, ఇక్కడ మీరు ఫంక్షన్ ఇన్వొకేషన్ లేదా ఫంక్షన్ కాల్ చూస్తారు, ఇక్కడ మేము స్థానికంగా ఉన్న రెండు పారామితులను ఉపయోగిస్తున్నాము.
 ఈ ఫంక్షన్‌ను పిలవడానికి ప్రధానంగా వాటి వేరియబుల్స్ స్థానికంగా ఉంటాయి.
 కాబట్టి ఫలితంగా, మొదటి పరామితి 'a' మొదటి అధికారిక పారామితి x కు కాపీ చేయబడుతుంది.
 కాబట్టి, 'a' 'b' కాల్‌ను అసలు పరామితి అంటారు; 'X', 'y' ను నిర్వచన సైట్ వద్ద అధికారిక పారామితి అంటారు.
 మరియు, శ్రేణి యొక్క విభిన్న భాగాలను యాక్సెస్ చేయడం మరియు ఒక నిర్మాణం యొక్క విభిన్న భాగాలను యాక్సెస్ చేయడం పరంగా నేను చెప్పినట్లుగా, విభిన్న సమావేశాలు ఉన్నాయి.
 ఇక్కడ సి ఒక ఫంక్షన్‌ను పిలవడానికి పారామితి సమావేశాన్ని అనుసరిస్తుంది.
 కాబట్టి, మొదటి వాస్తవ పరామితి మొదటి అధికారిక పరామితికి సరిపోతుంది; రెండవ నిజమైన పరామితి రెండవ వాస్తవ (అధికారిక) పరామితికి సరిపోతుంది.
 కాబట్టి, మీరు అధికారిక పరామితి పేరును అస్సలు పట్టించుకోరు.
 వాస్తవ పరామితి విలువ ఒక పరామితి నుండి మరొకదానికి కాపీ చేయబడి, ఆపై ఫంక్షన్‌లో ఉపయోగించబడుతుంది.
 ఇవి కాపీలు కాబట్టి, వాటికి వేర్వేరు మెమరీ స్థానాలు ఉన్నాయి.
 అందువల్ల, ఫంక్షన్ () అమలు ప్రారంభమైనప్పుడు, x యొక్క స్థానం 'a' కి భిన్నంగా ఉంటుంది.
 కానీ, విలువ కాపీ చేయబడినందున, `a 'విలువ 5. x మరియు x విలువతో ప్రారంభించడం కూడా 5 అవుతుంది. అయితే, ఫంక్షనల్ బాడీలో, మేము x మరియు y హుహ్లలో మార్పులు చేసాము.
 మాకు ఇంక్రిమెంట్ x, ఇంక్రిమెంట్ వై ఉన్నాయి.
 మేము తిరిగి విలువను లెక్కించాము.
 అందువల్ల, ఫంక్షన్ తిరిగి వచ్చినప్పుడు, అంటే, అది విలువ అయినప్పుడు, తిరిగి వచ్చే విలువ x + y లెక్కించి, కాలర్ మెయిన్ () కు తిరిగి వస్తుంది మరియు ఆ విలువ z కు కాపీ చేయబడుతుంది.
 ఇది జరిగినప్పుడు, మేము అధికారిక పరామితి x మరియు y విలువలను కోల్పోతాము.
 ఆసక్తికరంగా, x మరియు y మారినప్పటికీ, a మరియు b యొక్క అసలు పారామితులు మారవు.
 మరియు, చూడటం చాలా సులభం.
 విలువ ద్వారా కాల్‌లో, మీరు వేరే స్థానాన్ని ఉపయోగిస్తున్నారు.
 మీరు, ప్రారంభంలో మీరు విలువలను కాపీ చేసారు.
 కాబట్టి, మీరు మొదట్లో విలువలు, వేర్వేరు ప్రదేశాలు, మీరు x మరియు y లను కోల్పోయినప్పుడు, మేము x లేదా y లేదా రెండింటికి చేసిన అన్ని మార్పులు మాత్రమే పోతాయి.
 వాస్తవ పారామితులు ప్రభావితం కావు.
 అందువల్ల, దానిని స్పష్టం చేయడానికి, మేము ఇక్కడ 'A' మరియు 'B' విలువలను ముద్రించాము.
 మరియు, అవి అసలైనవి అని మేము కనుగొన్నాము.
 అవి ఇప్పటికీ 5 మరియు 10, x మరియు y అయినప్పటికీ, కాపీ చేసిన విలువలు మార్చబడ్డాయి.
 ముఖ్యంగా సి ప్రోగ్రామర్‌లకు ఇది చాలా సాధారణం కాదు.
 లేదా, మీరు విలువను తిరిగి ఇచ్చే యంత్రాంగాన్ని ధర యంత్రాంగం ద్వారా రిటర్న్ అంటారు.
 మరియు, ఇది సి లో స్పష్టంగా ప్రస్తావించబడలేదు ఎందుకంటే దానిని తిరిగి తీసుకురావడానికి వేరే మార్గం లేదు.
 నా ఉద్దేశ్యం, విలువను తిరిగి కాపీ చేయడం ద్వారా తిరిగి రావడానికి ఏకైక మార్గం; ఈ సమయంలో, అమలు చేస్తున్న 'ఫంక్షనల్' ఫంక్షన్ పూర్తయింది; మీరు ధర ఇచ్చిన తర్వాత ముగుస్తుంది.
 అందువల్ల, ఆ విలువను తిరిగి పొందడానికి మేము z కి కేటాయించిన విలువ యొక్క కాపీని ఇక్కడ ఉంచడం తప్ప వేరే మార్గం లేదు.
 మీరు C ++ కి మారిన వెంటనే, కాల్ కోసం విలువకు వేరే యంత్రాంగాన్ని మేము చూస్తాము, అలాగే విలువ ద్వారా తిరిగి వస్తుంది, ఇది చాలా శక్తివంతమైనది.
 విధులు పునరావృతమవుతాయి.
 మీరందరూ తప్పక చూశారని నాకు తెలుసు.
 మీరందరూ ఈ లేదా చాలా ప్రసిద్ధమైన ఫైబొనాక్సీ ఫంక్షన్ (ఫంక్షన్) ను కారకమైన ఫంక్షన్‌గా చూశారు, ఇందులో రెండు పునరావృత కాల్‌లు ఉపయోగించబడతాయి.
 మేము విలీన క్రమాన్ని చూశాము, శీఘ్ర క్రమబద్ధీకరణను చూశాము; ఇవన్నీ పునరావృత ఫంక్షన్లకు చాలా నిర్దిష్ట ఉదాహరణలు.
 ఏదైనా పునరావృత ఫంక్షన్లకు పునరావృత దశ మరియు పునరావృత ఫంక్షన్‌ను ముగించడానికి ఒకటి లేదా అంతకంటే ఎక్కువ నిష్క్రమణ పరిస్థితులు ఉంటాయి.
 ఇక్కడ మరొక ఉదాహరణ ఉంది, ఇది తక్కువ సాధారణంగా ఉపయోగించబడుతుంది.
 కాబట్టి, ఇలస్ట్రేషన్ కోసం ఇక్కడ ఉంచాను.
 మీరు సంతకం చేయని పూర్ణాంకం n ఇచ్చారు.
 ఇది పునరావృత ఫంక్షన్ n యొక్క బైనరీ ప్రాతినిధ్యంలో 1 ల సంఖ్యను లెక్కిస్తుంది.
 మీరు దానిని జాగ్రత్తగా పాస్ చేయండి మరియు పునరావృత విధానంతో సుపరిచితులు.
 విధులు మరియు పాయింటర్లను చాలా ఆసక్తికరమైన మార్గాల్లో కలపవచ్చు.
 మరియు, ఇది మళ్ళీ సి యొక్క చాలా శక్తివంతమైన లక్షణాలలో ఒకటి.
 సి భాషల కోసం మనం ఏమి పేర్కొనాలనుకుంటున్నారో హైలైట్ చేయడానికి ముందు, ఈ ఉదాహరణను క్లుప్తంగా అర్థం చేసుకుందాం; ఎందుకంటే ఇది ఉదాహరణ ద్వారా వివరణ.
 అందువల్ల, మేము ఎగువన చూపిస్తున్నది, పరిస్థితి అలాంటిది; మనకు రేఖాగణిత వస్తువుల సమాహారం ఉందని.
 రేఖాగణిత వస్తువులు వృత్తాలు, దీర్ఘచతురస్రాలు లేదా త్రిభుజాలు కావచ్చు.
 త్రిభుజాలు లంబ కోణ త్రిభుజాలు అని మేము అనుకుంటాము, ఇవి అక్షంతో సమలేఖనం అవుతాయి.
 అందువల్ల, వాటిలో ప్రతిదానికీ మనకు ఒక నిర్మాణం ఉంది.
 కాబట్టి, ఒక వృత్తం x, y ఉంది, ఇది కేంద్రం మరియు వ్యాసార్థం, దీర్ఘచతురస్రం x, y అంటే ఎడమ మూలను ఎత్తుతో చెబుతుంది మరియు త్రిభుజం x, y, ఇది లంబ కోణం, బేస్ మరియు బేస్ ఎత్తు.
 మరియు, ఇక్కడ మేము ఒక నిర్మాణాన్ని గీస్తాము.
 మళ్ళీ, ఇది సి లో వ్రాసే విలక్షణమైన మార్గం.
 రేఖాగణిత వస్తువు వాటిలో ఏవైనా ఉన్నందున మేము వీటన్నిటి యొక్క యూనియన్‌ను ఏర్పరుస్తాము.
 మరియు ఒక నిర్దిష్ట జియో ఆబ్జెక్ట్ చూస్తే, అది వృత్తం లేదా దీర్ఘచతురస్రం లేదా త్రిభుజం కావచ్చు.
 ఇప్పుడు, పని ఏమిటో నాకు ఎలా తెలుసు? అందువల్ల, ఈ నిర్మాణంలో మేము సిర్, రెక్ లేదా ట్రగ్ యొక్క సంకేతాలలో ఒకదాన్ని కలిగి ఉన్న మరొక లెక్కించిన విలువను ఉపయోగిస్తున్నాము.
 కాబట్టి, ఆలోచన ఏమిటంటే, మీరు ఈ యూనియన్‌లో, మీరు ఒక వృత్తం కోసం ఒక నిర్మాణాన్ని ఉంచితే, మీరు GCR ను సిర్‌కు సెట్ చేస్తారు, ఇది 0; ఈ యూనియన్‌లో మీకు దీర్ఘచతురస్రం కోసం ఒక నిర్మాణం ఉంటే, అప్పుడు మీరు Rec మరియు మొదలైన వాటిని gCode లో ఉంచండి.
 కాబట్టి, ఇది ఒక నిర్దిష్ట ఉపయోగం.
 కాబట్టి, మాకు నిర్మాణాల యూనియన్ ఉందని మీరు చూడవచ్చు.
 ఆపై, యూనియన్ అంటే ఏమిటో అర్థం చేసుకోవడానికి మాకు ఆ అసోసియేషన్ మరియు ఇండెక్సింగ్ కోడ్ ఉన్న నిర్మాణం ఉంది.
 మరియు, మీరు అలా చేస్తే, సి ప్రోగ్రామింగ్‌లో దీన్ని చేయడానికి చాలా సాధారణ ఉదాహరణ ఉంది.
 మరియు, మేము ఈ ఉదాహరణను తరువాత C ++ లో ఉపయోగిస్తాము, నేను వారసత్వ సందర్భంలో చెప్పినట్లు.
 మరియు, C ++ లో దీన్ని మరింత సమర్థవంతంగా ఎలా చేయవచ్చో చూపించు.
 ఇప్పుడు, పరిస్థితి ఏమిటంటే ఇవి మూడు వేర్వేరు రకాల రేఖాగణిత వస్తువులు మరియు వాటిని తెరపై గీయడం నా పని.
 కాబట్టి నేను కలిగి ఉన్నాను, ఇప్పుడు మీరు ఒక వృత్తాన్ని గీసే విధానం మరియు మీరు దీర్ఘచతురస్రాన్ని గీసే విధానం మరియు మీరు కుడి త్రిభుజాన్ని గీసే విధానం అన్నీ భిన్నంగా ఉంటాయి.
 కాబట్టి, ప్రో కోడ్ సహజంగా వ్రాయబడదు.
 ఒక ఫంక్షన్ వ్రాయబడదు, ఇది ముగ్గురినీ ఆకర్షించగలదు.
 కాబట్టి, సి 3 వేర్వేరు విధులను కలిగి ఉందని మీరు నమ్ముతారు.
 అవన్నీ వాస్తవానికి డ్రాయింగ్.
 కానీ సి లో, మేము ఒకే పేరుతో రెండు విధులు చేయలేము.
 కాబట్టి, నేను వాటిని డ్రాకల్స్ అని పిలుస్తాను, దీర్ఘచతురస్రాన్ని గీయండి, త్రిభుజం గీయండి.
 ఇప్పుడు, వాటిలో ప్రతి ఒక్కటి జియోఆబ్జెక్ట్ యొక్క ఒకే నిర్మాణాన్ని తీసుకుంటుంది.
 ఉదాహరణకు, నేను డ్రా సర్కిల్‌లో చూస్తే, అది జియోఆబ్జెక్ట్‌ను తీసుకుంటుంది.
 మరియు, జియోఆబ్జెక్ట్ జియోకోడ్ కోసం తనిఖీ చేస్తే అది వాస్తవానికి ఒక వృత్తం అని గుర్తించగలుగుతారు.
 మరియు, ఇది ఈ విలువలను ముద్రిస్తుంది.
 వాస్తవానికి ఇక్కడ ఇది, వాస్తవ డ్రాఫంసియన్‌లో, ముద్రించబడదు.
 వాస్తవానికి సర్కిల్‌ను గీయడానికి గ్రాఫిక్స్ ఫంక్షన్ కాల్‌లు ఉంటాయి.
 కానీ దీన్ని స్పష్టం చేయడానికి, నేను మీకు ఇక్కడ ప్రింట్ ద్వారా చూపిస్తున్నాను.
 కాబట్టి, ఇవి మూడు వేర్వేరు విధులు, ఇవి మూడు రకాలైన రేఖాగణిత వస్తువులను ఆకర్షించగలవు.
 ఇప్పుడు, ఈ వస్తువులలో దేనినైనా జికోడ్ ఇచ్చిన రెగ్యులర్ మెయిన్ ఫంక్షన్లను రాయాలనుకుంటున్నాము.
 మరియు, ఆ వస్తువు యొక్క నిర్మాణ పారామితులు దానిని గీయగలగాలి.
 అందువల్ల, ఆలోచన, నేను డ్రాఫునియన్ అని పిలవాలనుకుంటున్నాను.
 డ్రాఫాన్లలో ఎవరూ వారి పేర్లను ఉపయోగించడం లేదు.
 కానీ, నా జికోడ్ సిర్ మరియు నేను డ్రా అని పిలవాలనుకుంటే, ఈ డ్రాను పిలవాలి.+
 కానీ, నా జికోడ్ రెక్ అయితే నేను కాల్ చేయాలనుకుంటే, డ్రా రెక్ మొదలైన వాటికి కాల్ చేయాలి.
 కాబట్టి, మేము కాల్‌ను ఒకేలా చేయాలనుకుంటున్నాము, తద్వారా ప్రస్తుతానికి నా దగ్గర ఉన్న ప్రత్యేక అంశం ఏమిటో నాకు తెలియదు.
 నా వద్ద ఉన్న వస్తువు ఇప్పటికే వస్తువు నిర్మాణంలో ఒక భాగం; ఎందుకంటే నాకు జికోడ్ ఉంది.
 ఆపై, సంబంధిత ఫంక్షన్ అని పిలువబడే అవకాశం ఉంది.
 ఇక్కడ చేయబడిన విధానం ఏమిటంటే, నేను డ్రాఫ్యూజన్ అనే శ్రేణిని సృష్టిస్తాను మరియు ఇవన్నీ ఫంక్షన్ పేరును ఉంచుతాయి.
 మీరు ఈ ఫంక్షన్‌కు పేరు పెడుతున్నప్పుడు, వీటిని ఫంక్షన్ పాయింటర్లు అంటారు.
 ఒక జత కుండలీకరణాలు లేకుండా స్వయంగా ఉపయోగించే ఫంక్షన్ పేరు; కుండలీకరణాల జత, మనం చూసే విధంగా, ఫంక్షన్ ఆపరేటర్ అని పిలుస్తారు, ఇది ఫంక్షన్ ఎక్కడ అమలు చేయబడుతుందో మీకు తెలియజేస్తుంది.
 ఆ ఆపరేటర్లు ఇక్కడ ఉపయోగించబడరు.
 కాబట్టి, ఇవి కేవలం ఫంక్షన్ పేర్లు.
 అవి ఫంక్షన్ పాయింటర్లు.
 లేదా, మరో మాటలో చెప్పాలంటే, ఇవి సంబంధిత ఫంక్షన్ ప్రారంభమయ్యే చిరునామాలు.
 కాబట్టి, ఇది శ్రేణి.
 DrawArrr అనేది పాయింటర్ల శ్రేణి.
 మరియు, మీరు ఏమి చేస్తారు? ఇందులో విన్న ఎంట్రీ డ్రాసిర్, ఇది సర్కిల్‌ను గీస్తోంది.
 కాబట్టి, జికోడ్ శూన్యమైతే, అంటే సిర్.
 ఆపై, నేను ఈ శ్రేణిని ఆ జికోడ్‌తో యాక్సెస్ చేస్తే, గో డాట్ జికోడ్ సిర్, ఇది శూన్యమైనది (శూన్యమైనది); అంటే జీరోత్ ఫంక్షన్ పాయింటర్లు.
 కాబట్టి, డ్రాఅర్ర్ గో డాట్ జికోడ్ యొక్క విలువ డ్రాసిర్ అని తేలుతుంది, అయితే నేను గో డాట్ జికోడ్‌ను రెక్‌గా వర్తింపజేస్తే, అది దీర్ఘచతురస్ర నిర్మాణం అయితే, గో డాట్ జికోడ్ 1.
 శూన్యమైన తరువాత, ఇది 1: 1; అంటే నేను చేరుతున్న స్థలం 1 వ స్థానంలో ఉంది.
 కాబట్టి, ఇది ఒక ప్రత్యేక ఫంక్షన్ డ్రారెక్ మరియు మొదలైనవి.
 అందువల్ల, సంజ్ఞామానం కొద్దిగా సాధారణం కాదు.
 కాబట్టి, మీరు పేరు వంటి నిర్దిష్ట విధులను చూడలేరు.
 కానీ మీరు, ప్రాథమికంగా ఇది పాయింటర్ అయిన శ్రేణి మూలకం వలె కనిపిస్తుంది.
 మరియు, కానీ మీరు ఒక జత కుండలీకరణాలను పొందినప్పుడు, ఈ శ్రేణికి మీకు ప్రాప్యత ఉన్న ఫంక్షన్‌ను ప్రారంభించే ఫంక్షన్ ఆపరేటర్ ఉందని మీకు తెలుసు.
 ఇప్పుడు, ఒక ఫంక్షన్ పాయింటర్ లేదా ఫంక్షన్ పాయింటర్ (పాయింటర్లు) యొక్క శ్రేణిని సృష్టించగల శ్రేణి, శ్రేణి యొక్క అవసరం ఏమిటి? శ్రేణికి అన్ని అంశాలు ఒకే సమయంలో ఉండాలి.
 కాబట్టి, ఈ ఫంక్షన్ పాయింటర్లన్నీ ఒకే రకంగా ఉండాలి; అంటే వారు ఒకే రకమైన పరామితిని తీసుకొని ఒకే రకమైన పరామితిని తిరిగి ఇవ్వాలి.
 కాబట్టి, ఒక రకాన్ని సృష్టించడం ద్వారా లేదా టైప్ డెఫ్ ద్వారా డ్రాఫంక్ ఇక్కడ టైప్ చేయబడిందని మేము నిర్ధారించుకుంటాము; ఇది జియో ఆబ్జెక్ట్ యొక్క నిర్మాణాన్ని తీసుకుంటుంది మరియు శూన్యతను అందిస్తుంది.
 ఇది పాయింటర్ రకం అని మేము చెప్పాలనుకుంటున్నాము.
 అందుకే పేరు డ్రాఫంక్ కాదు.
 దీనికి స్టార్ డ్రాఫంక్ అని పేరు పెట్టారు.
 మార్గం ద్వారా, మనం పూర్ణాంక పాయింటర్‌ను నిర్వచించవలసి వస్తే మనం int * p అని పిలుస్తాము.
 కాబట్టి, పేరు ప్రాథమికంగా p కాదు.
 * P ఒక పూర్ణాంకం అని మీరు చెబుతున్నట్లుగా పేరు ఉంది.
 అందువల్ల, మీరు ఇక్కడ చెబుతున్నది `డ్రాఫంక్ 'అనేది జియో ఆబ్జెక్ట్ తీసుకునే ఫంక్షన్, శూన్యతను అందిస్తుంది.
 మరియు, ఇప్పుడు మీరు ఈ ముగ్గురు అభ్యర్థుల విధులను పరిశీలిస్తే, వారందరికీ ఒకే సంతకం ఉంది.
 అందువల్ల, వారికి ఇలాంటి సంతకం ఉంది.
 కాబట్టి, అవన్నీ ఈ డ్రాఫంక్ రకం, ఇది స్ట్రక్చర్ జియో, స్ట్రక్చర్ జియో ఆబ్జెక్ట్ మరియు ఏమీ తీసుకోని ఫంక్షన్ కోసం సూచిక.
 కాబట్టి, ఇది ఒక నిర్దిష్ట ఉపయోగం; ఫంక్షన్ సి యొక్క పాయింటర్లు చాలా శక్తివంతమైన యంత్రాంగాన్ని కలిగి ఉంటాయి.+
 ఒకవేళ నువ్వు; అన్ని గ్రాఫిక్ సిస్టమ్స్, మెనూలు, మీరు ఏది ఉపయోగించినా, ఫంక్షన్ పాయింటర్ల భావన.
 మరియు, మేము C ++ కి వెళ్ళినప్పుడు, C ++ ఎలా బాగా మెరుగుపరచబడిందో మరియు ఉపయోగించడానికి సులభతరం చేయబడిందని మరియు వర్చువల్ ఫంక్షన్ టేబుల్స్ అని పిలువబడే మరింత దృ ust మైనదిగా చూపిస్తాము.
 మేము చర్చించినప్పుడు అది వస్తుంది.
 చివరగా, సి ప్రోగ్రామింగ్ భాషపై కోర్సును మూసివేయడానికి, stdio.h లో ఇన్పుట్, అవుట్పుట్ ఫంక్షన్లు అందుబాటులో ఉన్నాయని మీకు తెలుసు.
 ఇవి సాధారణం; సర్వసాధారణం printf మరియు scanf, ఇవి ఫార్మాట్ తీగలను ఉపయోగిస్తాయి.
 ఇది ఉపయోగిస్తుంది; సి ప్రోగ్రామింగ్ యొక్క మరొక ఆసక్తికరమైన భాగం, ఎలిప్సిస్ లేదా ఫంక్షనల్ ఫంక్షన్స్ అని పిలుస్తారు, మీరు ప్రింట్ ఎఫ్ లో ఎన్ని పారామితులను పెడతారో మీకు తెలియదు.
 అందువల్ల, మేము ఎప్పుడూ printf యొక్క కోడ్‌ను వ్రాయలేదు, మీరు 5 విలువలు లేదా 10 విలువలు లేదా 1 విలువను ముద్రించాలనుకుంటున్నారో తెలియదు.
 కాబట్టి, ఒక నిర్దిష్ట ఫార్మాట్ బిట్ నిర్మాణం సృష్టించబడుతుంది.
 నేను అతని లోతుల్లోకి వెళ్ళను.
 మేము C ++ లో I / O ల గురించి చర్చించినప్పుడు, మేము దానిని అధిగమిస్తాము.
 దీనికి విరుద్ధంగా, C ++ వైవిధ్యాలు ఎలా ఇన్పుట్ అవుట్పుట్ ఫంక్షన్లను నివారించాయి.
 కానీ, ఇవి సి లో ఇన్‌పుట్‌ను అవుట్పుట్ చేసే నిర్దిష్ట మార్గాలు, మీ అందరికీ బాగా తెలుసు అని నేను ఖచ్చితంగా అనుకుంటున్నాను.
 ఫైళ్ళతో శ్రేణికి ఇన్‌పుట్‌ను ఎలా అవుట్పుట్ చేయాలో ఈ ఉదాహరణలు మీకు చూపుతున్నాయి.
 కాబట్టి, ఫైల్ పాయింటర్‌ను ఉపయోగించండి, దీన్ని మీరు ఓపెన్‌గా తెరిచి ఉంచండి.
 ఇప్పుడు, మేము ముందుకు వెళ్తాము.
 మీకు సి భాష మాత్రమే ఉంటే, మీరు ఏ ప్రోగ్రామ్‌ను వ్రాయలేరు ఎందుకంటే మీరు మొదటి ప్రోగ్రామ్‌ను చూశారు, ఈ మాడ్యూల్ యొక్క మొదటి భాగంలో మేము చర్చించాము; "హలో వరల్డ్" ప్రోగ్రామ్, మాకు ప్రింట్ ఎఫ్ అవసరం.
 మరియు, printf రాయడం అంత సులభం కాదు.
 అందువల్ల, ప్రోగ్రామింగ్ భాషను సమర్థవంతంగా ఉపయోగించుకోవటానికి, మీకు అందుబాటులో ఉండటానికి ప్రాథమిక లైబ్రరీ అవసరం.
 మరియు, ఏ భాష అయినా ప్రతి కంపైలర్‌కు లైబ్రరీ ఏమి అందించాలో తెలుపుతుంది మరియు ఆ లైబ్రరీని ప్రామాణిక లైబ్రరీ అంటారు.
 ఆ లైబ్రరీలో అన్ని ఫంక్షన్ నిర్వచనాలు, ఫంక్షన్ పేర్లు, దాచిన పేర్లు మరియు భాషా రూపకల్పన ద్వారా నిర్వచించబడినవి ఉన్నాయి.
 సికి ప్రామాణిక లైబ్రరీ ఉంది.
 మేము C ++ కి వెళ్ళేటప్పుడు, C ++ మరింత బలమైన ప్రామాణిక లైబ్రరీని కలిగి ఉన్నట్లు చూస్తాము.
 అయితే, సి స్టాండర్డ్ లైబ్రరీ కూడా చాలా శక్తివంతమైనది మరియు ఆసక్తికరంగా ఉంది.
 మొత్తం సి స్టాండర్డ్ లైబ్రరీ కూడా సి ++ లో లభిస్తుంది.
 కాబట్టి, C ++ లో విషయాలు భర్తీ చేయబడతాయి; క్రొత్త విషయాలు మాత్రమే జోడించబడతాయి.
 ఇప్పుడు, సి స్టాండర్డ్ లైబ్రరీలో చాలా భాగాలు ఉన్నాయి.
 ప్రతి భాగం హెడర్ ఫైల్‌కు చెందినది.
 మరియు ఉన్నాయి, మీరు మొత్తం జాబితాను చూడవచ్చు.
 కానీ, నేను 5 లో ఉంచాను, ఇవి ఎక్కువగా ఉపయోగించబడుతున్నాయి.
 ఇన్పుట్ అవుట్పుట్ హెడర్; ప్రామాణిక లైబ్రరీ హెడర్, దీనిలో మెమరీ కేటాయింపు, మార్పిడి, శోధన, సార్టింగ్ మొదలైన వాటి మిశ్రమాన్ని కలిగి ఉంటుంది.
 అన్ని రకాల సాధారణ గణిత ఫంక్షన్ల కోసం సి స్ట్రింగ్, మ్యాథమెటిక్స్ లైబ్రరీ మరియు ఎర్రర్ హెడర్‌ను మార్చటానికి స్ట్రింగ్, ఇది లోపాలు, విభిన్న దోష సంఖ్యలు మరియు దోష శ్రేణులను కలిగిస్తుంది మరియు దీనికి సంబంధించినది.
 కాబట్టి, ప్రామాణిక లైబ్రరీతో మిమ్మల్ని మరింత పరిచయం చేసుకోండి.
 మరియు, మీరు కొన్ని ప్రామాణిక లైబ్రరీ భాగాన్ని ఉపయోగిస్తున్నప్పుడల్లా, దయచేసి అన్ని ఇతర ఫంక్షన్లలో ఆ భాగం ఏమిటో చూడటానికి మాన్యువల్‌ను చూడండి.
 మరియు, వాస్తవానికి, చాలా చోట్ల, మీరు ఒక ఫంక్షన్ చేయడానికి కొన్ని ఫంక్షన్లను వ్రాస్తున్నారు, ఇది ఇప్పటికే ప్రామాణిక లైబ్రరీలో అందుబాటులో ఉంది.
 చివరగా, సి ప్రోగ్రామ్‌ను సరిగ్గా నిర్వహించాల్సిన అవసరం ఉందని కూడా నేను చెప్పాలి.
 మరియు, లైబ్రరీలు నిర్వహించబడుతున్నందున, హెడర్ ఫైల్స్ మరియు సోర్స్ ఫైల్స్ మధ్య వేరు చేయడం మంచిది.
 మీరు stdio ని చేర్చినప్పుడు.
 H, మీరు వాస్తవానికి ఫంక్షన్ ప్రోటోటైప్ లేదా ఫంక్షన్ హెడర్‌తో సహా ఉన్నారు.
 అమలు మరెక్కడా ఇవ్వబడుతుంది.
 అందువల్ల, మీరు మీ స్వంత కొన్ని ఫంక్షన్లను ఉపయోగించినప్పుడు, మీరు వాటిని హెడర్ మరియు ఆ ఫంక్షన్లను అమలు చేసే ఫైళ్ళ పరంగా కూడా వేరు చేయాలి.
 అందువల్ల, మీ ప్రోగ్రామ్‌లో మీరు సాధారణంగా రెండు రకాల హెడర్ ఫైల్‌లను కలిగి ఉంటారు; మీరు వ్రాసిన హెడర్ ఫైల్స్ మరియు స్టాండ్ స్టాండర్డ్ లైబ్రరీ నుండి వచ్చిన హెడర్ ఫైల్స్.
 అందువల్ల, ప్రామాణిక లైబ్రరీ లేదా సిస్టమ్ హెడర్ ఫైళ్ళ నుండి వచ్చే హెడర్ ఫైల్స్ ఈ రకమైన కోణీయ బ్రాకెట్లతో పేర్కొనబడాలి.
 మరియు, మీరు వ్రాసిన హెడర్ ఫైల్స్ డబుల్ కొటేషన్ మార్కులలో ఉండాలి.
 మేము C ++ లోకి లోతుగా పరిశోధించినప్పుడు దీనికి గల కారణాన్ని వివరిస్తాము.
 ఇది ప్రాథమికంగా ఈ ఫైల్ కోసం ఎక్కడ చూడాలో సిస్టమ్‌కు చెబుతుంది; వాటిని సిస్టమ్ డైరెక్టరీలలో చూడాలా లేదా మీ ప్రస్తుత (రిఫరెన్స్ సమయం: 22:52) డైరెక్టరీలో చూడాలనుకుంటే.
 కాబట్టి, ఇది ఒక సాధారణ ఉదాహరణ.
 నేను పరిష్కరించడానికి వర్గ సమీకరణాలు అవసరమయ్యే అనువర్తనంతో వ్యవహరించడానికి ప్రయత్నిస్తున్నాను.
 అందువల్ల, మీరు చతురస్రాకార సమీకరణాన్ని పరిష్కరించాల్సిన అనేక సూచనలు ఉంటాయి.
 ఇది కంప్యూటింగ్ ఆసక్తి కావచ్చు; ఇది కొన్ని వంతెన సమీకరణాలను ఏమైనా పరిష్కరించగలదు.
 కాబట్టి, ఇది అప్లికేషన్ ప్రోగ్రామ్, ఇది మీకు చతురస్రాకార సమీకరణ పరిష్కర్త ఉందని umes హిస్తుంది.
 కాబట్టి, మీరు దానిని అమలు చేస్తున్నారు.
 కాబట్టి, మీకు హెడర్ ఫైల్ పరిష్కరిణి డాట్ హెచ్ ఉంది, ఇది ఆ ఫంక్షన్ (ఫంక్షన్) లేదా ఫంక్షన్ (ఫంక్షన్) యొక్క ప్రోటోటైప్‌ను అన్ని వివిధ పారామితులతో ఇస్తుంది.
 మీకు మరొకటి ఉంది, ఇక్కడ మీరు ఈ ఫంక్షన్ లేదా ఫంక్షన్ బాడీ యొక్క కోడ్‌ను అమలు చేస్తారు.
 కాబట్టి, మీరు దీనిని సోల్వర్ డాట్ హెచ్ అని పిలుస్తారు; మీరు దీనిని పరిష్కరిణి డాట్ అని పిలుస్తారు.
 పరిష్కరిణి డాట్ హెచ్ అన్ని వివరాలను కలిగి ఉంది.
 కాబట్టి, ఇక్కడ అధికారిక పారామితుల పేరు ఉంది; అధికారిక పారామితులు ఇక్కడ పేరు పెట్టబడలేదు.
 వారికి రకాలు మాత్రమే ఇస్తారు.
 మరియు, అనువర్తనంలో మీరు శీర్షికను తెలుసుకోవాలి.
 వర్గ సమీకరణం ఎలా పరిష్కరించబడుతుందో మీరు తెలుసుకోవలసిన అవసరం లేదు.
 మీరు తెలుసుకోవలసిన ప్రతిదీ సంతకంలో ఉంది, దీనికి ఐదు పారామితులు ఉన్నాయి; వాటిలో మొదటి మూడు చతురస్రాకార సమీకరణం యొక్క మూడు గుణకాలు మరియు తరువాతి రెండు రెండు పాయింట్లు లేదా రెండు చిరునామా ఖాళీలు, ఇక్కడ సంక్లిష్ట విలువ ఫలితంతో ఉన్న చతురస్రాకార సమీకరణం పరిష్కరించబడితే ఫలితం యొక్క రెండు భాగాలను నిల్వ చేయాల్సిన అవసరం ఉంది.
 కాబట్టి, నిల్వ చేయడానికి మీకు వాస్తవమైన మరియు inary హాత్మక భాగం అవసరం.
 కాబట్టి, మీరు అప్లికేషన్ రాయడానికి ఈ సమాచారాన్ని తెలుసుకోవాలి.
 కాబట్టి, మీ అప్లికేషన్ ఫైల్‌లో శీర్షిక డాట్ h ఉంది, కేవలం శీర్షిక.
 క్వాడ్రాటిక్ ఈక్వేషన్ పరిష్కర్త యొక్క మీ అమలులో పరిష్కరిణి డాట్ హెచ్ కూడా ఉంటుంది, ఇది ఈ పరిష్కర్త మరియు మీ అనువర్తనం మధ్య, అదే శీర్షిక చేర్చబడిందని నిర్ధారిస్తుంది.
 కాబట్టి, పొరపాటుకు అవకాశం లేదు.
 కాబట్టి, మీరు ఎల్లప్పుడూ సాధారణ ఫంక్షన్లు, మాక్రోలు, స్థిరాంకాలు, మానిఫెస్ట్ స్థిరాంకాలు అనే శీర్షికలను వేర్వేరు సోర్స్ ఫైళ్ళ మధ్య పంచుకోవాలి.
 ప్రతి ఫంక్షన్ లేదా ఫంక్షన్ల సమూహం కోసం, మీకు ప్రత్యేక అమలు ఫైళ్లు ఉన్నాయి, ఇందులో ఒకే హెడర్ ఉంటుంది.
 మరియు, ఈ అప్లికేషన్ ఫైల్స్ హెడర్ మాత్రమే కలిగి ఉంటాయి.
 మరియు, సూచించడానికి మాకు అమలు ఫైళ్లు అవసరం లేదు.
 కాబట్టి, దయచేసి ఈ సంస్థను అనుసరించండి.
 మరియు, మేము C ++ కి వెళ్ళేటప్పుడు మరింత చూస్తాము.
 ఒక సాధారణ పరిస్థితిలో, మీరు అమలు కోసం మీ కోడ్‌ను ఈ విధంగా సిద్ధం చేస్తారు.
 మీరు సోర్స్ కోడ్‌తో ప్రారంభించండి, ఇది సి లేదా సి ++ కావచ్చు.
 మీరు కంపైల్ చేస్తున్నప్పుడు, మీరు IDE ద్వారా కంపైల్ చేయవచ్చు.
 అలాంటిదే చెప్పండి లేదా కంపైల్ చేయండి లేదా మీరు G ప్లస్ లేదా ఏదో C ++ అని చెప్పే టెక్స్ట్ బేస్డ్ ఇంటర్ఫేస్ ద్వారా చేయవచ్చు, ఆ తర్వాత ఏదో.
 ఈ ప్రక్రియ దశల్లో జరుగుతుంది.
 మరియు, ఇది కేవలం రూపురేఖలు.
 మేము C ++ దశల్లోకి వెళ్ళేటప్పుడు మరింత చర్చిస్తాము.
 మీ ఫైల్, మీ సోర్స్ ఫైల్ మొదట సి ప్రిప్రాసెసర్ ద్వారా వెళుతుంది, ఇందులో హాష్, హాష్ నిర్వచిస్తుంది, అటువంటి ప్రిప్రాసెసర్ ఆదేశాన్ని జాగ్రత్తగా చూసుకుంటుంది, తరువాత దానిని అసెంబ్లీ లాంగ్వేజ్ అని పిలుస్తారు.
 ఆ ఫైళ్ళలో డాట్ లు ఉన్నాయని మీరు చూడవచ్చు లేదా కొన్ని ఇతర సిస్టమ్స్ వివిధ రకాల ఫైల్ పేరు పొడిగింపులను కలిగి ఉండవచ్చు.
 డాట్ ఓ లేదా డాట్ ఆబ్జ్ అని పిలువబడే ఆబ్జెక్ట్ ఫైళ్ళను రూపొందించడానికి మీరు వాటిని సమీకరించండి.
 మరియు, మీ లైబ్రరీల నుండి మీరు stdio.h లో చేర్చిన అనేక ఇతర ఆబ్జెక్ట్ ఫైల్స్ ఉండవచ్చు.
 అప్పుడు, ఈ దశలో ఆ stdio.h కలుస్తుంది, కానీ అసలు అమలు అందుబాటులో లేదు.
 కాబట్టి, ఈ ప్రక్రియ ద్వారా ఇప్పటికే విడిగా సంకలనం చేయబడింది మరియు డాట్ ఓ ఫైల్ సృష్టించబడుతుంది.
 మరియు ఆ డాట్ ఓ ఫైల్ మీరు చెప్పినట్లుగా, మీ ప్రోగ్రామ్‌తో ముడిపడి ఉంది.
 మీరు IDE ని ఉపయోగిస్తుంటే, మీరు దానిని స్పష్టంగా చూడలేరు ఎందుకంటే IDE మీ కోసం సెట్ చేస్తుంది.
 మీరు దీన్ని కమాండ్ లైన్ నుండి చేస్తుంటే, మీరు నిజంగా మైనస్ L ను ఉపయోగించాలి మరియు ఆ ప్రామాణిక లైబ్రరీని చేర్చాలి.
 మరియు, ఇవన్నీ కలిసి మీకు ఎక్జిక్యూటబుల్ కోడ్ ఇస్తుంది.
 మరియు, మీరు C ++ లోకి మరింత కదిలేటప్పుడు, అంతర్నిర్మిత ప్రక్రియ C ++ ప్రోగ్రామింగ్ మరియు వివిధ ప్రోగ్రామింగ్ లక్షణాలను ఎలా ప్రభావితం చేస్తుందో మేము చూస్తాము.
 సాధనాల పరంగా, కోడ్ :: బ్లాక్ వంటి అనేక IDE లు అందుబాటులో ఉన్నాయి.
 విజువల్ స్టూడియో ఉంది.
 గ్రహణం.
 అందువల్ల, ఓపెన్ సోర్స్ అయిన కొన్ని IDE ని ఉపయోగించమని మేము మీకు సలహా ఇస్తాము.
 సాధారణంగా, కోడ్ బ్లాక్ లేదా ఎక్లిప్స్.
 మరియు, మీరు ఉపయోగిస్తున్న IDE ఏమైనా, ఇవి ప్రమాణాలు అని మీరు పేర్కొంటారు; C99 లాగా మీరు ఉపయోగిస్తున్న ప్రమాణం.
 లేకపోతే, మేము చూపించిన ప్రోగ్రామ్‌ల ప్రవర్తన మరియు వాటిని IDE లో అనుభవించినప్పుడు ప్రోగ్రామ్‌ల ప్రవర్తన భిన్నంగా ఉంటాయి.
 కాబట్టి ఎల్లప్పుడూ వాడండి, C కోసం మీరు C99 ను ఉపయోగిస్తారు; C ++ కోసం మేము C ++ 98 ను ఉపయోగిస్తాము.
 లేదా, మనం చూస్తాము, కొన్ని సందర్భాల్లో మనం C ++ 03 ని ఉపయోగిస్తాము.
 మేము దానికి వస్తాము.
 ఇవి రిఫరెన్స్ పుస్తకాలు; మీరు ప్రస్తావించాలనుకుంటే.
 కాబట్టి, మేము ఈ మొత్తం మాడ్యూల్‌లో క్లుప్తంగా దీనిని సాధించాము.
 సి లోని ప్రాథమిక భావనల భావనలను మేము సవరించాము; వేరియబుల్స్, డేటా రకాలు, అక్షరాస్యులు, నియంత్రణ నిర్మాణాలు.
 మరియు, మేము ఫంక్షన్ మరియు పాయింటర్లు మరియు సంస్థ మరియు నిర్మాణ ప్రక్రియ ద్వారా మళ్ళించాము.
 అందువల్ల, సి లోని మీ ఫండమెంటల్స్‌పై మీరు శీఘ్ర రీక్యాప్ ఇస్తారని నేను ఆశిస్తున్నాను.
 మీకు బాగా అర్థం కాని లేదా ఉదాహరణలు బాగా గ్రహించబడని కొన్ని పాయింట్లను మీరు కనుగొంటే, దయచేసి వాటిని మళ్లీ సందర్శించండి లేదా బ్లాగులో మాకు ప్రశ్నలు అడగండి.
 కానీ, ఈ మాడ్యూల్‌తో ఇది సి స్థాయి అని మేము ఆశించాము, మీరు సి ++ భాషా శిక్షణతో ముందుకు సాగడానికి సిద్ధంగా ఉన్నారు.
 మేము ఇక్కడ మాడ్యూల్ను మూసివేస్తాము.
 మాడ్యూల్ రెండు తరువాత, C ++ లో మనం ఇక్కడ చూసిన కొన్ని సాధారణ ఉదాహరణలు లేదా C లోని కొన్ని ఇతర సాధారణ ఉదాహరణలు C ++ లో మరింత సమర్థవంతంగా, సమర్థవంతంగా మరియు మరింత బలమైన పద్ధతులను ఎలా చేయవచ్చో మీకు చూపించడం ప్రారంభిస్తాము.