Recap of C (Lecture 01)-KG4hjVDw-p8

 C ++ ప్రోగ్రామింగ్  కు స్వాగతం.
 ఇది 20-గంటల కోర్సు అవుతుంది, ఇక్కడ మేము C ++ ప్రోగ్రామింగ్ భాష యొక్క వివిధ అంశాల గురించి మాట్లాడుతాము మరియు ఇది సహజంగా 40 గుణకాలుగా విభజించబడుతుంది, మీరు ఒకదాని తరువాత ఒకటి అధ్యయనం చేస్తారు.
 సంక్లిష్ట సాఫ్ట్‌వేర్ వ్యవస్థల రూపకల్పన మరియు అమలులో C ++ ప్రోగ్రామింగ్ భాషను ఎలా ఉపయోగించాలో నేర్పడం ఈ కోర్సు యొక్క ప్రధాన ఒత్తిడి.
 సి ++ ఒక ఆబ్జెక్ట్ ఓరియెంటెడ్ లేదా ఆబ్జెక్ట్ బేస్డ్ ప్రోగ్రామింగ్ లాంగ్వేజ్ అని మీ అందరికీ తెలుస్తుంది మరియు మీకు సి లాంగ్వేజ్ తెలుసని నేను అంగీకరిస్తున్నాను, మీకు చాలా లోతుగా తెలియకపోవచ్చు, కాని మీకు సి లాంగ్వేజ్ గురించి సాధారణ జ్ఞానం ఉంది కాబట్టి, మేము అక్కడ నుండి ప్రారంభిస్తాము, మాడ్యూల్ 1 లో, సి ప్రోగ్రామింగ్ యొక్క విభిన్న నిర్దిష్ట అంశాలను ఉపయోగించడం గురించి మనం మళ్ళీ మాట్లాడుతాము.
 అవసరమైతే మీరు ఆ భావనలను పున it సమీక్షించగలరని మరియు మేము C ++ భాషలోకి లోతుగా వెళ్ళే ముందు, మీరు అన్ని C ప్రోగ్రామింగ్ అవసరాలను తెలుసుకోగలరని నిర్ధారించుకోవడానికి ఇది మాత్రమే. | ఎందుకంటే సి భాష సి ++ యొక్క స్థానిక భాష.
 కాబట్టి, మేము మొదట సి భాష యొక్క పునరావృతంతో ప్రారంభిస్తాము. అందువల్ల, సి భాష మరియు ప్రోగ్రామింగ్ అంశాలకు అదనంగా సి స్టాండర్డ్ లైబ్రరీని పరిశీలిస్తాము, ప్రత్యేకించి వివిధ అంశాలను తిరిగి నేర్చుకోవడం కోసం.
 సి ప్రోగ్రామ్ యొక్క నిర్మాణం, సి ప్రోగ్రామ్ను ఎలా సాధ్యం చేయాలో మేము క్లుప్తంగా చర్చిస్తాము.
 ఇప్పటివరకు, మీరు 1 లేదా 2 ఫంక్షన్‌ను ఉపయోగించి ఒకే ఫైల్‌కు సూచనగా కోడ్‌ను వ్రాశారు.
 వాటిలో ఒకటి ప్రధానంగా ఉండాలి (ఫంక్షన్). మీకు తెలిసినట్లుగా, ప్రోగ్రామ్‌లను ఎలా బాగా వ్రాయవచ్చో మేము చూస్తాము మరియు దీనితో మనకు C ++ ప్రోగ్రామింగ్ భాషకు పునాది ఉంటుంది.
 మాడ్యూల్ డిజైన్ సందర్భంలో చేయవలసిన వివిధ అంశాలు ఇవి.
 ప్రదర్శనగా, మేము మీ స్క్రీన్ యొక్క ఎడమ వైపుకు వెళ్తాము, మీరు ఈ రూపురేఖను చూస్తారు మరియు మేము ఏ ప్రత్యేక అంశం గురించి మాట్లాడుతున్నామో అది హైలైట్ అవుతుంది.
 కాబట్టి, ఇది మొదటి కార్యక్రమం "హలో వరల్డ్", మీరందరూ అధ్యయనం చేశారని నేను ఖచ్చితంగా అనుకుంటున్నాను.
 ఇది కెర్నింగ్ మరియు రిట్చీల ప్రసిద్ధ పుస్తకంలోని ప్రారంభ కార్యక్రమం.
 టెర్మినల్‌లో "హలో వరల్డ్" ను ప్రింట్ చేయడానికి మేము <stdio> లైబ్రరీ నుండి 'printf' ను ఉపయోగిస్తాము, ఇది అధికారికంగా <stdio> అవుట్ ఫైల్.
 ప్రధాన విధి ఏమిటంటే మీరు ఎక్కడ చూడగలరు, అక్కడ ఎక్సిక్యూషన్ మొదలవుతుంది. అప్పుడు మీరు ఈ స్ట్రింగ్‌ను ప్రింట్ చేసి '\ n' ను ప్రింట్ చేయండి, అంటే మీరు ప్రాథమికంగా, మేము తదుపరి పంక్తికి వెళ్తాము, అంటే కొత్త పంక్తి.
 సి లో అనేక రకాల డేటా రకాలు ఉన్నాయి; కెర్ (చార్), క్యారెక్టర్ అని పిలుస్తారు, మొత్తం సంఖ్యలకు పూర్ణాంకం (పూర్ణాంకానికి), ఫ్లోట్ మరియు డబుల్; ఫ్లోటింగ్ పాయింట్లు సంఖ్యల కోసం.
 ఇప్పుడు, ఇక్కడ మీరు సాధారణంగా ఉపయోగించే C ను C89 అని పిలుస్తారు, C89 C యొక్క మొదటి ప్రమాణం (స్టాండర్డ్) ANSI చే సృష్టించబడింది, ప్రామాణీకరణ సంస్థ మరియు తరువాత 99 లో, మరొక ప్రమాణం విడుదల చేయబడింది, దీనిని C99 అని పిలుస్తారు, కాబట్టి నేడు చాలా కంపైలర్లు C99 ప్రమాణాన్ని అనుసరిస్తున్నారు.
 C99 కూడా అనుసరిస్తుందని మేము ఆశిస్తున్నాము.
 కాబట్టి, మేము C గురించి మాట్లాడేటప్పుడు, C99 లో కొన్ని విషయాలు భిన్నంగా ఉంటే హైలైట్ చేయడానికి ప్రయత్నిస్తాము.
 కాబట్టి, మీరు చూడగలిగినట్లుగా, డేటా రకం పరంగా, క్రొత్త డేటా రకం బూల్ ఉంది, ఇది C99 కు జోడించబడింది.
 C89 లో, మీరు ఇప్పటికీ బూలియన్ విలువలను కలిగి ఉండవచ్చు, ఇది పూర్ణాంక విలువను బట్టి నిజం (నిజం) లేదా తప్పుడు (తప్పుడు) కావచ్చు.
 అది 0 అయితే అది అబద్ధం (తప్పుడు); లేకపోతే అది నిజం.
 కానీ C99 లో, వేరే రకం బూల్ ఉంది.
 మీకు తెలిసిన ప్రతి డేటా రకం (డేటాటైప్), ఈ అంతర్నిర్మిత డేటా రకాల పరిమాణం (పరిమాణం) బైట్‌లలో ఇవ్వబడుతుంది మరియు దాన్ని పొందడానికి మీరు `సైజ్‌ఆఫ్ 'ఆపరేటర్‌ను ఉపయోగిస్తారు. చేయవచ్చు.
 మీరు కొన్ని సింబాలిక్ పేర్లు ఇవ్వబడిన పూర్ణాంక విలువలు అయిన గణన రకాలను నిర్వచించవచ్చు.
 సి లోని ఇతర డేటా రకాలు శూన్యాలు.
 శూన్యమైన (శూన్యమైన డేటాటైప్) ఉపయోగం చాలా ఆసక్తికరంగా ఉంటుంది మరియు మేము C ++ కి వెళ్ళినప్పుడు, శూన్యత (శూన్యత) యొక్క వివిధ ఉపయోగాలను చూస్తాము.
 మీరు డేటాటైప్ ఉపయోగించాల్సిన అవసరం వచ్చినప్పుడు, మీరు శూన్యతను ఉపయోగించవచ్చు, కానీ ఇది నిజంగా డేటాటైప్ కాదు.
 ఇది ఇలా ఉంటుంది, మనం అంకగణితం చేసినప్పుడు మనకు 0 ఉంటుంది. నేను x కి 0 ని జోడించగలను మరియు అది x ని మార్చదు.
 అందువల్ల, ప్రతి వ్యవస్థకు 0 అవసరమని మేము చెప్పినట్లు. కాబట్టి, శూన్యత అనేది ఒక రకమైన వ్యవస్థ, ఎందుకంటే మనం C ++ లో ఎక్కువగా చూస్తాము.
 ఈ అంతర్నిర్మిత రకం ఆధారంగా, శ్రేణి, నిర్మాణం, యూనియన్ మరియు పాయింటర్‌కు మద్దతు ఇచ్చే వివిధ ఉత్పన్న రకాలు ఉన్నాయి. మేము సాధారణంగా పిలువబడే ఫంక్షన్లను కలిగి ఉండవచ్చు. సి లో స్ట్రింగ్ ఈ రోజుల్లో సి స్ట్రింగ్ అని పిలుస్తారు.
 నిజం స్ట్రింగ్ C లో డేటాటైప్ కాకపోతే, మీరు C ++ కి వెళ్ళినప్పుడు మీకు బాగా అర్థం అవుతుంది.
 సి స్ట్రింగ్ వాస్తవానికి ఫంక్షన్ యొక్క హెడర్ సేకరణ, ఇది సి లో తీగలను మార్చటానికి అనుమతిస్తుంది.
 చివరగా, డేటాటైప్‌లను వాటి పరిమాణం కోసం సవరించవచ్చు, అవి సంతకం చేయబడతాయి లేదా సంతకం చేయబడవు మరియు ఈ 4 రకాల మాడిఫైయర్‌లను సి లో ఉపయోగిస్తారు. ఇప్పుడు మనం సి వేరియబుల్‌కి వెళ్తాము, వాటి పేర్లు ఆల్ఫా (ఆల్ఫాబేట్స్) తో ప్రారంభమయ్యే కొన్ని మార్గాల్లో నిర్వచించబడతాయి లేదా అండర్ స్కోర్: '_') ఆపై ఆల్ఫా-న్యూమరిక్ విస్తరించబడతాయి.
 వేర్వేరు వేరియబుల్ పేర్లకు ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి, ఒకే అక్షరాలతో లేదా 1-2 అక్షరాలతో వేరియబుల్ పేరు పెట్టడం చాలా సౌకర్యంగా ఉన్నప్పుడు, కొంత అర్ధం ఉన్న వేరియబుల్ పేర్లను ఉపయోగించడం ఇంకా మంచిది. హుహ్.
 అందువల్ల, మేము పాత్రను 'ఎండ్ఆఫ్ సెషన్' అని పిలుస్తున్నాము, మీరు దానిని 'సి', లేదా 'డి' లేదా 'ఎ' అని పిలవవచ్చు, కాని వేరియబుల్ అంటే ఏమిటో అర్థం చేసుకోవడానికి దీనికి పేరు పెట్టడం మంచిది.
 ఇక్కడ ప్రకటించినట్లుగా, ధృవీకరించదగిన డిక్లరేషన్లు ప్రకటించినప్పుడు, వేరియబుల్ కూడా ప్రారంభించబడుతుంది.
 ఆ ప్రారంభ ఐచ్ఛికం.
 కాబట్టి, int i 10 తో ప్రారంభించబడిందని మేము చెప్పినప్పుడు ..
 దీని అర్థం `i 'అనేది పూర్ణాంక రకం వేరియబుల్, ఇది క్షీణతతో 10 ప్రారంభ విలువలను కలిగి ఉంటుంది.
 అందువల్ల, మీరు ప్రారంభించకపోతే, ఇది ప్రారంభించని వేరియబుల్, దీని ప్రారంభ విలువ తెలియదు.
 వాస్తవానికి, మేము ప్రకటించే మరియు నిర్వచించే అన్ని వేరియబుల్స్ను ప్రారంభించడం చాలా మంచిది.
 సి అనేక అక్షరాస్యతలను కలిగి ఉంది, ఇవి అంతర్నిర్మిత రకం యొక్క స్థిర విలువలు, మీరు ఒక నిర్దిష్ట లిట్రల్‌ను ఎలా వ్రాస్తారనే దానిపై ఆధారపడి, ఆ లిట్రల్ రకం పరిష్కరించబడుతుంది.
 ఉదాహరణకు, మీరు అంకెల శ్రేణిని మాత్రమే కలిగి ఉంటే అది దశాంశ రకం పూర్ణాంకం అవుతుంది, కానీ మీరు 0 తో ఉపసర్గ చేస్తే, అది అష్ట రకానికి చెందినదని భావించబడుతుంది, దీని ఆధారం 8.
 మీరు దీన్ని 0x తో ఉపసర్గ చేస్తే, అది హెక్సాడెసిమల్ లిట్రల్‌గా పరిగణించబడుతుంది.
 చార్ రకం లిట్రల్ "లోపల వ్రాయబడింది, స్ట్రింగ్ రకం లిట్రల్" "లోపల వ్రాయబడింది. C99 తో, const రకానికి ఒక పరిచయం ఉంది, అవి ఖరీదైనవి మరియు మేము C ++ చేసేటప్పుడు మరింత లోతుగా చర్చిస్తాము.
 అందువల్ల, C89 లో లిట్రల్ ఫిక్స్‌డ్ విలువలు ఉన్నాయి, కానీ C99 లో, అవి కాంటెంట్ టైప్ డేటాగా పరిగణించబడతాయి.
 కాబట్టి, C99 లోని '212' ను తారాగణం వలె పరిగణిస్తారు.
 సి లో చాలా మంది ఆపరేటర్లు ఉన్నారు, వారిలో చాలా మందికి మీకు పరిచయం ఉంటుంది.
 బైనరీ ఆపరేటర్ వంటివి; సంకలనం (+), వ్యవకలనం (-), గుణకారం (*).
 నిరాకరణ వలె, అనామక ఆప్టర్లు ఉన్నారు.
 ?:. వంటి టెర్నరీ ఆపరేషన్లు కూడా ఉన్నాయి.
 ప్రతి ఆపరేటర్‌కు 1, 2 లేదా 3 కావచ్చు ఓప్రాండ్‌పై ఆధారపడి ఉండే ఒక నిర్దిష్ట ధర్మం ఉంది. ఒక వ్యక్తీకరణలో, ఆపరేటర్లు వారి ప్రాధాన్యత క్రమం ప్రకారం మదింపు చేయబడతారు.
 కొంతమంది ఆపరేటర్లకు అధిక ప్రాధాన్యత ఉంది, కొన్ని తక్కువ ప్రాధాన్యత కలిగి ఉంటాయి.
 కాబట్టి, అదే వ్యక్తీకరణకు గుణకారం (*) అలాగే అదనంగా (+) ఉంటే గుణకారం (*) మొదట చేయవలసి ఉంటుందని మనకు తెలుసు.
 అదేవిధంగా, ఒక వ్యక్తీకరణకు ఒకటి కంటే ఎక్కువ ఆపరేటర్లు ఉంటే, వారి మూల్యాంకనం యొక్క క్రమం అసోసియేటివిటీపై ఆధారపడి ఉంటుంది మరియు కొన్ని ఆపరేటర్‌కు కుడి నుండి ఎడమకు, కొన్ని ఆపరేటర్‌కు ఎడమ నుండి కుడికి ఉంటాయి.
 అందువల్ల, ఇక్కడ నేను భిన్నమైన ఉదాహరణలు చూపించాను.
 ఇది మీ సూచన కోసం మాత్రమే, మీకు ఇది ఖచ్చితంగా తెలుసు.
 మీరు దీన్ని చేయకపోతే, దయచేసి దాన్ని బాగా అర్థం చేసుకోవడానికి వచనాన్ని చూడండి.
 ఇప్పుడు, సి లోని తదుపరి భావన వ్యక్తీకరణ.
 నాకు వేరియబుల్స్ ఉన్నాయి మరియు నాకు ఆపరేటర్ ఉంది.
 నేను అక్షరాలను కలిగి ఉన్నాను, దానితో నేను వ్యక్తీకరణలను సృష్టించగలను.
 కాబట్టి, వ్యక్తీకరణ ప్రతి లిట్రల్ ఒక వ్యక్తీకరణ అని పునరావృత రూపం చెప్పే విధంగా నిర్వచించబడింది.
 నేను 5 సంఖ్యను చెబితే, అది ఒక వ్యక్తీకరణ.
 ప్రతి వేరియబుల్ ఒక వ్యక్తీకరణ మరియు నాకు రెండు వ్యక్తీకరణలు ఉంటే మరియు వాటిని బైనరీ ఆపరేటర్‌కు కనెక్ట్ చేస్తే అది కొత్త వ్యక్తీకరణ అవుతుంది.
 అదేవిధంగా, నేను యూనిరీ ఆపరేటర్, టెర్నరీ ఆపరేటర్ మొదలైనవాటిని కలిగి ఉంటాను.
 ఏదైనా ఫంక్షన్ అని పిలువబడినప్పుడు అది ఒక వ్యక్తీకరణ.
 కాబట్టి, ప్రాథమిక విషయం ఏమిటంటే వ్యక్తీకరణకు విలువ ఉండాలి; సికి వ్యక్తీకరణ అని పిలువబడే దేనికైనా విలువ ఉంటుంది.అందువల్ల, ఇక్కడ ఇవ్వబడిన వేరియబుల్స్ కోసం వేర్వేరు ఉదాహరణలు ఇవ్వవచ్చు మరియు విభిన్న వ్యక్తీకరణలు క్రింద ఇవ్వబడ్డాయి.
 ఇప్పుడు, సి వ్యక్తీకరణను కలిగి ఉండకూడదు.
 కాబట్టి, వ్యక్తీకరణ ఒక ప్రకటనగా ఉండాలి.
 కాబట్టి, మీరు కలిగి ఉన్న సరళమైన లేదా చిన్న ప్రకటనను శూన్య ప్రకటన అని పిలుస్తారు, ఇది సెమికోలన్ ';'
 లేకపోతే, మీకు వ్యక్తీకరణ ఉంటే, మీరు దానిని సెమికోలన్‌తో ముగించవచ్చు మరియు మీరు దానిని సెమికోలన్‌తో ముగించిన తర్వాత అది ఒక స్టేట్‌మెంట్ అవుతుంది.
 కాబట్టి, మీరు ఈ క్రింది ఉదాహరణను పరిశీలిస్తే, 'i + j' వ్యక్తీకరణ ప్రకటనకు వ్యక్తీకరణ ఉంది, ఎందుకంటే 'i' మరియు 'j' వేరియబుల్ మరియు + ఒక ఆపరేటర్ వారితో చేరడం. అంటే, మీరు `i + j; ఇది ఒక ప్రకటన అవుతుంది.
 ఇది స్వతంత్రంగా ఎక్కడైనా జరగవచ్చు, ఫంక్షన్ కాల్స్ మరియు అసైన్‌మెంట్‌ల కోసం ఇలాంటి ఉదాహరణలు చూపించబడ్డాయి.
 వ్యక్తీకరణ ప్రకటనతో పాటు, సికి అనేక నియంత్రణ ప్రకటనలు లేదా నియంత్రణ నిర్మాణాలు ఉన్నాయి, ఇవి ప్రాథమికంగా ప్రోగ్రామ్‌లో నియంత్రణ ప్రవాహాన్ని నిర్వహించడానికి అనుమతిస్తాయి.
 దీని కోసం, సెలక్షన్ స్టేట్మెంట్ మరియు లూప్ స్టేట్మెంట్ మొదలైనవి ఉన్నాయి.
 మేము తరువాతి స్లైడ్‌లో వాటి గురించి కొంచెం ఎక్కువ చూస్తాము మరియు ఒకదాని తరువాత ఒకటిగా సమూహపరచవలసిన అనేక స్టేట్‌మెంట్‌లు ఉంటే, ఆపై మేము వంకర కలుపులను '{}' ఉపయోగిస్తాము).
 ఇది ఒక బ్లాక్‌గా మారిందని, అలాంటి స్టేట్‌మెంట్‌ను కాంపౌండ్ స్టేట్‌మెంట్ అంటారు.
 అందువల్ల, స్టేట్మెంట్ యొక్క మొత్తం విభాగం ఒక సంకలనం, ఇది మీరు క్రింద ఒక ఉదాహరణను చూడవచ్చు.
 ఇప్పుడు, సి ప్రోగ్రామ్ యొక్క ప్రధాన ప్రాంతం అయిన నియంత్రణ నిర్మాణాల గురించి మాట్లాడుదాం, ఇది ప్రోగ్రామ్ యొక్క అమలు ఎలా జరుగుతుందో ప్రాథమికంగా మీకు తెలియజేస్తుంది.
 ఒక స్టేట్మెంట్ ఎగ్జిక్యూట్ చేసిన తరువాత, ఏ ఇతర స్టేట్మెంట్ ఎగ్జిక్యూట్ అవుతుంది, దీన్ని నియంత్రించడానికి మాకు వేర్వేరు పద్ధతులు ఉన్నాయి.
 అప్రమేయంగా సి ప్రోగ్రామ్‌లోని నియంత్రణ పతనం ద్వారా వస్తుంది, అంటే ఒక స్టేట్‌మెంట్ ఎగ్జిక్యూట్ అయిన తర్వాత, తదుపరి స్టేట్‌మెంట్ వెంటనే అమలు అవుతుంది, కాని నియంత్రణ ప్రవాహం ద్వారా దాన్ని మార్చవచ్చు.
 కాబట్టి, మొదటి రకం నియంత్రణ ప్రవాహం 'if' లేదా 'if-else' అనే ఎంపిక ప్రకటన. ఉదాహరణలో, (a <b) నిజమైతే, మీరు ఆ సమ్మేళనం ప్రకటనను అనుసరిస్తున్నారు.
 సమ్మేళనం స్టేట్మెంట్ ఏమి చెబుతుందో మీరు సులభంగా అర్థం చేసుకోవచ్చు, దీనిలో మీరు మూడవ వేరియబుల్ ఉపయోగించి 'a' మరియు 'b' విలువను మార్చుకుంటారు.
 మీరు తరువాతి ఉదాహరణను పరిశీలిస్తే, అది 'if-else' రకం స్టేట్మెంట్ చూపిస్తుంది, ఇక్కడ 'if (x <5)' యొక్క షరతు నిజమైతే అది ఒక స్టేట్మెంట్, లేకపోతే షరతు ఉంటే తప్పు ఒకటి ఉంటే మరింత ప్రకటన.
 తప్పుడు భాగానికి సమ్మేళనం స్టేట్మెంట్ ఉందని మీరు చూడవచ్చు, అయితే ఇది నిజం, ఇది ఒకే ప్రకటన, ఇది అనేక విధాలుగా చేయవచ్చు.
 మీరు వేరియబుల్ యొక్క విలువను వివిధ మార్గాల్లో ఉపయోగించవచ్చు.
 స్విచ్-కేసులో మీరు జాబితా చేయబడిన కేసులో దేనినైనా తీసుకుంటే, మేము వేరియబుల్ 'i' ను ఉపయోగించాము మరియు మీరు మారేది వేరియబుల్ విలువపై ఆధారపడి ఉంటుంది. కాబట్టి, i యొక్క విలువ 1 అయితే, కేసు 1 ఎంచుకోబడుతుంది, దీని ద్వారా 'x' 6 అవుతుంది. మొత్తం సందర్భంలో i యొక్క విలువ లేకపోతే, మనకు డిఫాల్ట్ కేసు ఉంది, అది అమలు అవుతుంది.
 స్విచ్‌లో మేము చూపించిన 'కేసు' వంటి స్టేట్‌మెంట్‌లను లేబుల్ స్టేట్‌మెంట్‌లు అని కూడా పిలుస్తారు ఎందుకంటే వాటికి లేబుల్ ఉంది.
 expression ఆదేశాలతో పాటుగా, C లో అనేక  నియంత్రణ ఆదేశాలు (Control Statements) లేదా నియంత్రణ నిర్మాణాలు ఉన్నాయి, ఇవి ప్రాధమికంగా  ప్రోగ్రామ్లో నియంత్రణ ప్రవాహాన్ని నియంత్రిస్తాయి.
 అప్పుడు మనకు పునరావృత ప్రకటనలు ఉన్నాయి, ఇక్కడ మీరు వీటిని సాధారణంగా లూప్ స్టేట్మెంట్స్ అని పిలుస్తారు, ఇక్కడ మీరు మూడు భాగాలను కలిగి ఉన్న 'ఫర్' లూప్ కలిగి ఉండవచ్చు.
 ప్రారంభ భాగం 'i' 0 కి కేటాయించబడుతుంది, ఇది ప్రారంభంలో జరుగుతుంది.
 ప్రతిసారి లూప్ నియంత్రించబడే రెండవ కండిషన్ భాగం మరియు మీరు లూప్‌లో కొనసాగితే పరిస్థితి నిజం. మరియు ప్రాథమికంగా 'ఫర్' స్టేట్‌మెంట్‌ను అనుసరించే ఒక శరీరం, ఇది లూప్‌లో భాగంగా అమలు చేయబడిన సూచనలు లేదా స్టేట్‌మెంట్‌ల క్రమం మరియు లూప్ స్టేట్‌మెంట్ ముగింపుకు దారితీసే '++ i'.
 అదేవిధంగా, మనకు 'while' లూప్ మరియు 'do-while' లూప్ ఉన్నాయి. చివరి రకం నియంత్రణ ప్రకటన కోసం 'వెళ్ళు', 'కొనసాగించు', 'విచ్ఛిన్నం' మరియు 'తిరిగి'.
 మీకు తెలిసినట్లుగా, మీరు 'వెళ్ళండి' ఉపయోగించవద్దని సి సూచిస్తుంది, కాబట్టి, మేము 'వెళ్ళు' యొక్క ఉదాహరణను చూపించడం లేదు.+
 మీరు సి ప్రోగ్రామ్‌ను చక్కగా డిజైన్ చేస్తే మీకు 'వెళ్ళండి' ఉపయోగించడానికి ఎటువంటి కారణం ఉండదు.
 అందువల్ల, మీ నియంత్రణ ప్రవాహాన్ని సాధించడానికి వేర్వేరు లూప్ లేదా స్విచ్ స్టేట్‌మెంట్‌లతో 'కొనసాగించు' మరియు 'విచ్ఛిన్నం' మాత్రమే ఉపయోగించడానికి ప్రయత్నించండి, కానీ ఫంక్షన్ నుండి తిరిగి రావడానికి మీకు 'తిరిగి' అవసరం.
 కాబట్టి, నాలుగు రకాల నియంత్రణ నిర్మాణాలు ఉన్నాయి.
 ఈ మాడ్యూల్‌లో మేము ఇప్పటివరకు చూశాము, సి ప్రోగ్రామ్ యొక్క ప్రాథమిక భాగాలు ఏమిటి, మీరు IO ఎలా చేస్తారు, డేటా రకాన్ని ఉపయోగించి వేరియబుల్‌ను ఎలా నిర్వచించాలి? మీరు వాటిని ఎలా ప్రారంభించాలి? ఆపరేటర్లను ఉపయోగించి వాటిని వ్యక్తీకరణలుగా ఎలా చేయాలి? ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని నియంత్రించడానికి వ్యక్తీకరణను స్టేట్‌మెంట్ మరియు విభిన్న కంట్రోల్ ఫ్లో స్టేట్‌మెంట్‌గా ఎలా మార్చాలి? కాబట్టి దీనితో, మేము ఈ భాగాన్ని ముగించాము మరియు ఆ తరువాత ఉత్పన్నమైన రకాలు మరియు సి లో వాటి ఉపయోగం గురించి మాట్లాడుతాము