విషయము

• అడుగు పెట్టడానికి
• 6 యొక్క పార్ట్ 1: సన్నాహాలు
• 6 యొక్క పార్ట్ 2: వేరియబుల్స్ ఉపయోగించడం
• 6 యొక్క 3 వ భాగం: షరతులతో కూడిన ప్రకటనలు
• 6 యొక్క 4 వ భాగం: ఉచ్చులు
• 6 యొక్క 5 వ భాగం: లక్షణాలను ఉపయోగించడం
• 6 యొక్క 6 వ భాగం: నేర్చుకోవడం కొనసాగించండి
• చిట్కాలు

సి పాత ప్రోగ్రామింగ్ భాషలలో ఒకటి. ఇది 1970 లలో అభివృద్ధి చేయబడింది, అయితే ఇది యంత్ర భాషకు దగ్గరగా ఉన్న తక్కువ-స్థాయి భాష కాబట్టి దీనిని ఇప్పటికీ శక్తివంతమైన భాషగా పిలుస్తారు. సి నేర్చుకోవడం అనేది మరింత సంక్లిష్టమైన భాషలలో ప్రోగ్రామింగ్‌కు గొప్ప పరిచయం, మరియు మీరు పొందిన జ్ఞానం దాదాపు ఏ ప్రోగ్రామింగ్ భాషకైనా ఉపయోగపడుతుంది మరియు చివరికి అనువర్తన అభివృద్ధిలోకి రావడానికి మీకు సహాయపడుతుంది. సి లో ప్రోగ్రామింగ్ ప్రారంభించడానికి చదవండి.

అడుగు పెట్టడానికి

6 యొక్క పార్ట్ 1: సన్నాహాలు

1. కంపైలర్‌ను డౌన్‌లోడ్ చేసి, ఇన్‌స్టాల్ చేయండి. సి కోడ్‌ను మొదట ప్రోగ్రామ్ ద్వారా సంకలనం చేయాలి, అది కోడ్‌ను అర్థం చేసుకోగలదు మరియు దానిని యంత్రం అర్థం చేసుకోగలిగే భాషగా మార్చగలదు. కంపైలర్లు సాధారణంగా ఉచితంగా లభిస్తాయి మరియు మీరు ప్రతి ఆపరేటింగ్ సిస్టమ్ కోసం వేర్వేరు కంపైలర్లను డౌన్‌లోడ్ చేసుకోవచ్చు.
   • విండోస్ కోసం, మైక్రోసాఫ్ట్ విజువల్ స్టూడియో ఎక్స్‌ప్రెస్ లేదా మిన్‌జిడబ్ల్యు.
   • Mac కోసం, XCode ఉత్తమ C కంపైలర్లలో ఒకటి.
   • Linux లో, gcc అత్యంత ప్రాచుర్యం పొందిన ఎంపికలలో ఒకటి.
2. ప్రాథాన్యాలు. సి పాత ప్రోగ్రామింగ్ భాషలలో ఒకటి, కానీ చాలా శక్తివంతమైనది. ఇది మొదట యునిక్స్ ఆపరేటింగ్ సిస్టమ్ కోసం రూపొందించబడింది, కాని చివరికి దాదాపు ప్రతి సిస్టమ్‌లోనూ ఇది సాధారణమైంది. సి యొక్క "ఆధునిక" వెర్షన్ సి ++.
   • సి అన్ని ఫంక్షన్లను కలిగి ఉంటుంది మరియు ఈ ఫంక్షన్లలో మీరు డేటాను నిల్వ చేయడానికి మరియు మార్చటానికి వేరియబుల్స్, షరతులతో కూడిన స్టేట్మెంట్స్ మరియు లూప్‌లను ఉపయోగించవచ్చు.
3. సాధారణ కోడ్ యొక్క కొన్ని పంక్తులను చూడండి. భాష యొక్క విభిన్న భాగాలు ఎలా కలిసి పనిచేస్తాయో మరియు ప్రోగ్రామ్‌లు ఎలా పనిచేస్తాయో మొదటి ఆలోచన పొందడానికి దిగువ (చాలా) సాధారణ ప్రోగ్రామ్ ద్వారా వెళ్ళండి.

   # చేర్చండి stdio.h> int main () {printf ("హలో, ప్రపంచం! n"); getchar (); తిరిగి 0; }

   • అప్పగింపు # చేర్చండి ప్రోగ్రామ్ ప్రారంభంలో ఉంచబడుతుంది మరియు మీకు అవసరమైన విధులను కలిగి ఉన్న లైబ్రరీలను (కోడ్ లైబ్రరీలను) లోడ్ చేస్తుంది. ఈ ఉదాహరణలో stdio.h ఖచ్చితంగా మీరు printf () మరియు getchar () ఉపయెాగించవచ్చు.
   • అప్పగింపు పూర్ణాంకానికి ప్రధాన () ప్రోగ్రామ్ "ప్రధాన" ఫంక్షన్‌ను ఉపయోగిస్తుందని మరియు దానిని అమలు చేసిన తర్వాత అది ఒక పూర్ణాంకాన్ని తిరిగి ఇస్తుందని కంపైలర్‌కు చెబుతుంది. అన్ని సి ప్రోగ్రామ్‌లు "ప్రధాన" ఫంక్షన్‌గా నడుస్తాయి.
   • సంకేతాలు {inside లోపల ఉన్న ప్రతిదీ "ప్రధాన" ఫంక్షన్‌లో భాగమని సూచిస్తుంది.
   • ఫంక్షన్ printf () వినియోగదారు తెరపై బ్రాకెట్లలోని విషయాలను చూపుతుంది. కొటేషన్ గుర్తులు స్ట్రింగ్ అక్షరాలా ముద్రించబడిందని నిర్ధారిస్తాయి. ది n కర్సర్‌ను తదుపరి పంక్తికి తరలించమని కంపైలర్‌కు చెబుతుంది.
   • గుర్తు ; ఒక పంక్తి ముగింపును సూచిస్తుంది. కోడ్ యొక్క చాలా పంక్తులు సెమికోలన్‌తో ముగుస్తాయి.
   • అప్పగింపు getchar ()కొనసాగే ముందు కైస్ట్రోక్ కోసం వేచి ఉండమని కంపైలర్‌కు చెబుతుంది. ఇది ఉపయోగపడుతుంది ఎందుకంటే చాలా కంపైలర్లు ప్రోగ్రామ్‌ను రన్ చేసి వెంటనే విండోను మూసివేస్తాయి. ఇది ఒక కీని నొక్కినంత వరకు ప్రోగ్రామ్ నుండి నిష్క్రమించకుండా నిరోధిస్తుంది.
   • అప్పగింపు తిరిగి 0 ఫంక్షన్ ముగింపును సూచిస్తుంది. "ప్రధాన" ఫంక్షన్ a పూర్ణాంకానికి ఫంక్షన్. ప్రోగ్రామ్ పూర్తయిన తర్వాత ఇది పూర్ణాంకాన్ని తిరిగి ఇవ్వాలి. ప్రోగ్రామ్ సరిగ్గా అమలు చేయబడిందని "0" సూచిస్తుంది; ఏదైనా ఇతర సంఖ్య లోపం కనుగొనబడిందని సూచిస్తుంది.
4. ప్రోగ్రామ్‌ను కంపైల్ చేయడానికి ప్రయత్నించండి. మీ కోడ్ ఎడిటర్‌లో కోడ్‌ను ఎంటర్ చేసి దానిని " *. C" ఫైల్‌గా సేవ్ చేయండి. ఇప్పుడు దీన్ని మీ కంపైలర్‌తో కంపైల్ చేయండి, సాధారణంగా బిల్డ్ లేదా రన్ నొక్కడం ద్వారా.
5. మీ కోడ్‌తో ఎల్లప్పుడూ వివరణను చేర్చండి. ఇది ప్రోగ్రామ్ యొక్క సాధారణ భాగం అయి ఉండాలి, కానీ ఇది కంపైల్ చేయబడదు. ఈ ట్యుటోరియల్ కోడ్ ఏమిటో గుర్తుంచుకోవడానికి మీకు సహాయపడుతుంది మరియు మీ కోడ్‌ను చూడటం మరియు / లేదా ఉపయోగించాలనుకునే ప్రోగ్రామర్‌లకు మార్గదర్శకంగా ఉపయోగపడుతుంది.
   • సి లో వ్యాఖ్యను జోడించడానికి, ఒక ఉంచండి /* వ్యాఖ్య ప్రారంభంలో మరియు a */ చివరలో.
   • మీ కోడ్ యొక్క ప్రాథమిక భాగాలు తప్ప ఎక్కడైనా వ్యాఖ్యానించండి.
   • కోడ్ యొక్క భాగాలను తొలగించకుండా వాటిని త్వరగా దాచడానికి వ్యాఖ్యలను ఉపయోగించవచ్చు. వ్యాఖ్య ట్యాగ్‌లలో ఉంచడం ద్వారా కోడ్‌ను చుట్టుముట్టండి, ఆపై ప్రోగ్రామ్‌ను కంపైల్ చేయండి. మీరు మళ్లీ కోడ్‌ను ఉపయోగించాలనుకుంటే, ట్యాగ్‌లను తొలగించండి.

6 యొక్క పార్ట్ 2: వేరియబుల్స్ ఉపయోగించడం

1. వేరియబుల్స్ యొక్క ఫంక్షన్. గణన ఫలితాలు లేదా వినియోగదారు ఇన్‌పుట్ ద్వారా డేటాను నిల్వ చేయడానికి వేరియబుల్స్ మిమ్మల్ని అనుమతిస్తాయి. మీరు వాటిని ఉపయోగించే ముందు వేరియబుల్స్ నిర్వచించబడాలి మరియు ఎంచుకోవడానికి అనేక రకాలు ఉన్నాయి.
   • కొన్ని సాధారణ వేరియబుల్స్ పూర్ణాంకానికి, చార్ మరియు ఫ్లోట్. వీటిలో ప్రతి ఒక్కటి వేరే డేటా రకాన్ని నిల్వ చేస్తుంది.
2. వేరియబుల్స్ ఎలా ప్రకటించబడుతున్నాయో తెలుసుకోండి. సి ప్రోగ్రామ్‌లో ఉపయోగించటానికి ముందు వేరియబుల్స్ మొదట ఒక నిర్దిష్ట రకాన్ని ఇవ్వాలి, లేదా "డిక్లేర్డ్" చేయాలి. మీరు డేటా రకాన్ని పేర్కొనడం ద్వారా వేరియబుల్ ను డిక్లేర్ చేస్తారు, తరువాత వేరియబుల్ పేరు ఉంటుంది. ఉదాహరణకు, కింది ప్రకటనలు అన్నీ సి లో చెల్లుతాయి:

   ఫ్లోట్ x; చార్ పేరు; int a, b, c, d;

   • ఒకే రకమైన పంక్తిలో ఒకే రకమైన బహుళ వేరియబుల్స్‌ను మీరు ప్రకటించవచ్చని గమనించండి. ఒకే విషయం ఏమిటంటే మీరు వేరియబుల్స్ ను కామాతో వేరు చేస్తారు.
   • సి లోని అనేక పంక్తుల మాదిరిగా, ప్రతి వేరియబుల్ డిక్లరేషన్‌ను సెమికోలన్‌తో వేరు చేయడం తప్పనిసరి.
3. వేరియబుల్స్ ఎక్కడ ప్రకటించాలో తెలుసుకోండి. కోడ్ బ్లాక్ ప్రారంభంలో వేరియబుల్స్ ప్రకటించబడాలి (code in లో జతచేయబడిన కోడ్ యొక్క భాగాలు). మీరు తరువాత వేరియబుల్ డిక్లేర్ చేయడానికి ప్రయత్నిస్తే, ప్రోగ్రామ్ సరిగా పనిచేయదు.
4. వినియోగదారు ఇన్‌పుట్‌ను నిల్వ చేయడానికి వేరియబుల్స్‌ను ఉపయోగించుకోండి. వేరియబుల్స్ ఎలా పని చేస్తాయనే దాని యొక్క ప్రాథమికాలను ఇప్పుడు మీకు తెలుసు, మీరు వినియోగదారు నుండి ఇన్పుట్ను అంగీకరించే మరియు నిల్వ చేసే ఒక సాధారణ ప్రోగ్రామ్ను వ్రాయవచ్చు. దీని కోసం మీరు సి యొక్క మరొక ఫంక్షన్‌ను ఉపయోగిస్తారు scanf. ఈ ఫంక్షన్ స్ట్రింగ్‌లోని ప్రత్యేక విలువల కోసం శోధిస్తుంది.

   # చేర్చండి stdio.h> int main () {int x; printf ("దయచేసి సంఖ్యను నమోదు చేయండి:"); scanf ("% d", & x); printf ("సంఖ్య% d", x); getchar (); తిరిగి 0; }

   • ది "% d" స్ట్రింగ్ / స్ట్రింగ్ scanf వినియోగదారు ఇన్పుట్లో పూర్ణాంకం కోసం శోధించడానికి.
   • ది & వేరియబుల్ కోసం X. చెబుతుంది scanf దాన్ని మార్చడానికి వేరియబుల్‌ను ఎక్కడ కనుగొనాలి మరియు పూర్ణాంకాన్ని ఆ వేరియబుల్‌గా నిల్వ చేయండి.
   • చివరి ఆదేశం printf వేరియబుల్ చదివి ఫలితాన్ని వినియోగదారుకు ప్రదర్శిస్తుంది.
5. వేరియబుల్స్ సవరించడం. మీరు గణిత వ్యక్తీకరణలను ఉపయోగించి వేరియబుల్స్‌లో నిల్వ చేసిన డేటాను సవరించవచ్చు. గణిత వ్యక్తీకరణలకు గుర్తుంచుకోవలసిన ప్రధాన వ్యత్యాసం ఏమిటంటే ఒక్కటే = వేరియబుల్ విలువను నిల్వ చేస్తుంది == పాత్ర యొక్క రెండు వైపులా ఉన్న విలువలు అవి సమానంగా ఉన్నాయని నిర్ధారించుకోండి.

   x = 3 * 4; / * "x" ను 3 * 4 కు కేటాయించండి లేదా 12 * / x = x + 3; / * ఇది "x" యొక్క మునుపటి విలువకు 3 ని జోడిస్తుంది మరియు క్రొత్త విలువను వేరియబుల్ గా సెట్ చేస్తుంది * / x == 15; / * "x" 15 * / x 10 కు సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది; / * "x" విలువ 10 * కంటే తక్కువగా ఉందో లేదో తనిఖీ చేస్తుంది /

6 యొక్క 3 వ భాగం: షరతులతో కూడిన ప్రకటనలు

1. షరతులతో కూడిన ప్రకటనల యొక్క ప్రాథమికాలను అర్థం చేసుకోండి. షరతులతో కూడిన ప్రకటనలు చాలా ప్రోగ్రామ్‌ల హృదయంలో ఉంటాయి. ఇవి ఒప్పు లేదా తప్పు అని స్టేట్‌మెంట్‌లు, తదనుగుణంగా ఫలితాన్ని ఇస్తాయి. ఈ ప్రకటనలలో సరళమైనది అది ఉంటే ప్రకటన.
   • మీరు ఉపయోగించిన దానికంటే C లో TRUE మరియు FALSE భిన్నంగా పనిచేస్తాయి. నిజమైన ప్రకటనలు ఎల్లప్పుడూ నాన్జెరో సంఖ్యతో సరిపోలడం తో ముగుస్తాయి. మీరు పోలికలు చేసినప్పుడు మరియు ఫలితం నిజం అయినప్పుడు, "1" తిరిగి వస్తుంది. ఫలితం తప్పు అయితే, "0" తిరిగి ఇవ్వబడుతుంది. దీన్ని అర్థం చేసుకోవడం IF స్టేట్‌మెంట్‌లతో పనిచేయడానికి సహాయపడుతుంది.
2. ప్రామాణిక షరతులతో కూడిన ఆపరేటర్లను తెలుసుకోండి. షరతులతో కూడిన ప్రకటనలు విలువలను పోల్చిన గణిత ఆపరేటర్ల వాడకం చుట్టూ తిరుగుతాయి. కింది జాబితాలో సాధారణంగా ఉపయోగించే షరతులతో కూడిన ఆపరేటర్లు ఉన్నారు.

   > / * కంటే ఎక్కువ * / / * కంటే తక్కువ * /> = / * కంటే ఎక్కువ లేదా సమానం * / = / * కంటే తక్కువ లేదా సమానంగా * / == / * * /! = / * * / కు సమానం కాదు
   

   10> 5 TRUE 6 15 TRUE 8> = 8 TRUE 4 = 8 TRUE 3 == 3 TRUE 4! = 5 TRUE

3. ప్రాథమిక IF స్టేట్మెంట్. స్టేట్మెంట్ మూల్యాంకనం చేసిన తర్వాత ప్రోగ్రామ్ ఏమి చేయాలో నిర్ణయించడానికి మీరు IF స్టేట్మెంట్లను ఉపయోగించవచ్చు. శక్తివంతమైన, సంక్లిష్టమైన విధులను సృష్టించడానికి మీరు దీన్ని ఇతర షరతులతో కూడిన స్టేట్‌మెంట్‌లతో కలపవచ్చు, కాని మేము ఇప్పుడే అలవాటు చేసుకోవడం సులభం.

   # చేర్చండి stdio.h> int main () {if (3 5) printf ("3 5 కన్నా తక్కువ"); getchar (); }

4. మీ పరిస్థితులను విస్తరించడానికి ELSE / ELSE IF స్టేట్‌మెంట్‌లను ఉపయోగించండి. విభిన్న ఫలితాలను ప్రాసెస్ చేయడానికి మీరు ELSE మరియు ELSE IF స్టేట్‌మెంట్‌లను ఉపయోగించడం ద్వారా IF స్టేట్‌మెంట్‌లను రూపొందించవచ్చు. IF స్టేట్మెంట్ FALSE అయితే మాత్రమే ELSE స్టేట్మెంట్స్ అమలు చేయబడతాయి. ELSE IF స్టేట్‌మెంట్‌లు ఒకే కోడ్ బ్లాక్‌లో బహుళ IF స్టేట్‌మెంట్‌లను ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తాయి మరియు తద్వారా మరింత క్లిష్టమైన పరిస్థితులను సృష్టిస్తాయి. ఇది ఎలా పనిచేస్తుందో తెలుసుకోవడానికి క్రింది నమూనా ప్రోగ్రామ్ చూడండి.

   # చేర్చండి stdio.h> int main () {int వయస్సు; printf ("మీ వయస్సును నమోదు చేయండి:"); scanf ("% d", & వయస్సు); if (వయస్సు = 12) {printf ("మీరు ఇంకా పిల్లలే! n"); } else ఉంటే (వయస్సు 20) {printf ("యుక్తవయసులో ఉండటం చాలా బాగుంది! n"); } else if (వయస్సు 40) {printf ("మీరు ఇంకా హృదయపూర్వకంగా ఉన్నారు! n"); } else {printf ("వయస్సుతో జ్ఞానం వస్తుంది. n"); } తిరిగి 0; }

   • ప్రోగ్రామ్ వినియోగదారు నుండి ఇన్పుట్ తీసుకొని అనేక IF స్టేట్మెంట్ల ద్వారా నడుపుతుంది. సంఖ్య మొదటి ప్రకటనను సంతృప్తిపరిస్తే, అది మొదటిది అవుతుంది printf స్టేట్మెంట్ తిరిగి ఇవ్వబడింది. ఇది మొదటి స్టేట్‌మెంట్‌ను సంతృప్తిపరచకపోతే, మీరు పని చేసేదాన్ని కనుగొనే వరకు ఈ క్రింది ELSE IF స్టేట్‌మెంట్లలో ఒకటి సంతృప్తికరంగా ఉందో లేదో తనిఖీ చేస్తుంది. ప్రకటనలు ఏవీ సంతృప్తికరంగా లేకపోతే, చివరి ELSE స్టేట్మెంట్ అమలు అవుతుంది.

6 యొక్క 4 వ భాగం: ఉచ్చులు

1. ఉచ్చులు ఎలా పని చేస్తాయి. ప్రోగ్రామింగ్ యొక్క అతి ముఖ్యమైన అంశాలలో లూప్స్ ఒకటి, ఎందుకంటే కొన్ని షరతులు నెరవేరే వరకు అవి కోడ్ బ్లాకులను పునరావృతం చేయడానికి మిమ్మల్ని అనుమతిస్తాయి. ఇది పునరావృత చర్యలను అమలు చేయడం చాలా సులభం చేస్తుంది మరియు మీరు ఏదైనా జరగాలని కోరుకునే ప్రతిసారీ కొత్త షరతులతో కూడిన ప్రకటనలను వ్రాయవలసిన అవసరం లేదు.
   • మూడు వేర్వేరు ఉచ్చులు ఉన్నాయి: FOR, WHILE మరియు DO ... WHILE.
2. FOR లూప్. ఇది చాలా సాధారణమైన మరియు ఉపయోగకరమైన లూప్ రకం. FOR లూప్‌లో పేర్కొన్న విధంగా కొన్ని షరతులు నెరవేరే వరకు ఇది ఫంక్షన్‌ను అమలు చేస్తుంది. లూప్‌లకు 3 షరతులు అవసరం: వేరియబుల్‌ను ప్రారంభించడం, తీర్చవలసిన పరిస్థితి మరియు వేరియబుల్ నవీకరించబడాలి. మీకు ఈ పరిస్థితులన్నీ అవసరం లేకపోతే, మీరు సెమికోలన్‌తో ఖాళీ స్థలాన్ని ఉంచాలి, లేకపోతే లూప్ నిరవధికంగా కొనసాగుతుంది.

   # చేర్చండి stdio.h> int main () {int y; (y = 0; y 15; y ++;) {printf ("% d n", y); } గెట్చార్ (); }

   • పై కార్యక్రమంలో y 0 కు సెట్ చేయండి మరియు లూప్ విలువ ఉన్నంత వరకు కొనసాగుతుంది y 15 కన్నా తక్కువ. ఎప్పుడైనా విలువ y తెరపై ముద్రించబడుతుంది, 1 విలువకు జోడించబడుతుంది y మరియు లూప్ పునరావృతమవుతుంది. అది లెక్కించబడుతుందా y = 15, లూప్ అంతరాయం కలిగిస్తుంది.
3. WHILE లూప్. WHILE ఉచ్చులు FOR ఉచ్చుల కంటే కొంచెం సరళంగా ఉంటాయి. ఇవి 1 కండిషన్ మాత్రమే కలిగి ఉంటాయి మరియు ఆ షరతు నెరవేరినంత వరకు లూప్ కొనసాగుతుంది. వేరియబుల్‌ను ప్రారంభించడం లేదా నవీకరించడం అవసరం లేదు, కానీ మీరు దానిని లూప్‌లోనే చేయవచ్చు.

   # చేర్చండి stdio.h> int main () {int y; (y = 15) {printf ("% d n", y); y ++; } గెట్చార్ (); }

   • ది y ++ కమాండ్ వేరియబుల్కు 1 ను జతచేస్తుంది yప్రతిసారీ లూప్ అమలు అవుతుంది. ఉంటే y 16 కి చేరుకుంది (ఈ లూప్ ఉన్నంత వరకు కొనసాగుతుందని గుర్తుంచుకోండి y "15 కన్నా తక్కువ లేదా సమానం", లూప్ ఆపివేయబడుతుంది.
4. ది DO...WHILE లూప్. ఈ లూప్ లూప్‌లకు చాలా ఉపయోగకరంగా ఉంటుంది, అవి కనీసం ఒక్కసారైనా పూర్తయ్యాయని మీరు నిర్ధారించుకోవాలి. FOR మరియు WHILE లూప్‌లలో, లూప్ ప్రారంభంలో పరిస్థితి తనిఖీ చేయబడుతుంది, అంటే లూప్ పూర్తయిందో లేదో. DO ... WHILE ఉచ్చులు పరిస్థితి చివరికి నెరవేరిందో లేదో తనిఖీ చేస్తుంది మరియు అందువల్ల కనీసం ఒక్కసారైనా అమలు చేయబడతాయి.

   # చేర్చండి stdio.h> int main () {int y; y = 5; do {printf ("లూప్ నడుస్తోంది! n"); } ఉండగా (y! = 5); getchar (); }

   • ఈ లూప్ పరిస్థితి తప్పు అయినప్పటికీ సందేశాన్ని ప్రదర్శిస్తుంది. వేరియబుల్ y 5 కు సెట్ చేయబడింది మరియు WHILE లూప్ ఎక్కువ కాలం కొనసాగుతుంది y 5 కి సమానం కాదు, ఆ తర్వాత లూప్ ముగుస్తుంది. సందేశం ఇప్పటికే తెరపై ప్రదర్శించబడింది ఎందుకంటే ఇది షరతు తీర్చబడిందని చివరిలో మాత్రమే తనిఖీ చేయబడుతుంది.
   • DO లోని WHILE లూప్ ... WHILE సెమికోలన్‌తో ముగుస్తుంది. సెమికోలన్‌తో లూప్ ముగుస్తున్న ఏకైక సమయం ఇది.

6 యొక్క 5 వ భాగం: లక్షణాలను ఉపయోగించడం

1. విధుల ప్రాథమిక జ్ఞానం. ఫంక్షన్లు ప్రోగ్రామ్ యొక్క మరొక భాగం నుండి పిలువబడే కోడ్ యొక్క స్వీయ-నియంత్రణ బ్లాక్స్. ఇది చదవడానికి మరియు సవరించడానికి కోడ్ మరియు ప్రోగ్రామ్‌లను సులభంగా పునరావృతం చేయడం చాలా సులభం చేస్తుంది. విధులు పైన వివరించిన అన్ని పద్ధతులను మరియు ఇతర విధులను కూడా ఉపయోగిస్తాయి.
   • పాలన ప్రధాన () అన్ని మునుపటి ఉదాహరణల ప్రారంభంలో ఒక ఫంక్షన్ కూడా ఉంది getchar ()
   • కోడ్‌ను చదవడం మరియు వ్రాయడం మరింత సమర్థవంతంగా చేయడానికి విధులు ఉద్దేశించబడ్డాయి. మీ ప్రోగ్రామ్‌ను క్రమబద్ధీకరించడానికి లక్షణాలను బాగా ఉపయోగించుకోండి.
2. సంక్షిప్త వివరణతో ప్రారంభించండి. మీరు వాస్తవ కోడింగ్‌తో ప్రారంభించడానికి ముందు మీరు ఏమి సాధించాలనుకుంటున్నారో వివరించడం ద్వారా విధులను ఉత్తమంగా రూపొందించవచ్చు. సి లోని ఫంక్షన్ యొక్క ప్రాథమిక వాక్యనిర్మాణం "రిటర్న్_టైప్ పేరు (ఆర్గ్యుమెంట్ 1, ఆర్గ్యుమెంట్ 2, మొదలైనవి);". ఉదాహరణకు, రెండు సంఖ్యలను జోడించే ఫంక్షన్‌ను సృష్టించడానికి, ఈ క్రింది వాటిని చేయండి:

   int జోడించు (int x, int y);

   • ఇది రెండు పూర్ణాంకాలను జోడించడానికి ఒక ఫంక్షన్‌ను సృష్టిస్తుంది (X. మరియు y), మరియు మొత్తం పూర్ణాంకంగా తిరిగి వస్తుంది.
3. ప్రోగ్రామ్‌కు ఫంక్షన్‌ను జోడించండి. వినియోగదారు ఎంటర్ చేసిన రెండు పూర్ణాంకాలను జోడించడానికి ప్రోగ్రామ్‌ను సృష్టించడానికి మీరు చిన్న వివరణను ఉపయోగించవచ్చు. ప్రోగ్రామ్ "జోడించు" ఫంక్షన్ ఎలా పనిచేస్తుందో నిర్వచిస్తుంది మరియు ఎంటర్ చేసిన సంఖ్యలను ప్రాసెస్ చేయడానికి దాన్ని ఉపయోగిస్తుంది.

   # చేర్చండి stdio.h> int add (int x, int y); int ప్రధాన () {int x; int y; printf ("దయచేసి జోడించడానికి రెండు సంఖ్యలను నమోదు చేయండి:"); scanf ("% d", & x); scanf ("% d", & y); printf ("సంఖ్యల మొత్తం% d n", జోడించు (x, y)); getchar (); } int జోడించు (int x, int y) {తిరిగి x + y; }

   • చిన్న వివరణ ప్రోగ్రామ్ ప్రారంభంలో ఉందని గమనించండి. ఫంక్షన్‌ను పిలిచినప్పుడు ఏమి ఆశించాలో మరియు అది తిరిగి వస్తుందని ఇది కంపైలర్‌కు చెబుతుంది. మీరు ప్రోగ్రామ్‌లో తరువాత ఫంక్షన్‌ను నిర్వచించాలనుకుంటే మాత్రమే ఇది అవసరం. నువ్వు కూడా జోడించు () ఫంక్షన్ కోసం నిర్వచించండి ప్రధాన () కాబట్టి ఫలితం చిన్న వివరణ లేకుండా ఉంటుంది.
   • ఫంక్షన్ యొక్క ఆపరేషన్ ప్రోగ్రామ్ చివరిలో నిర్వచించబడుతుంది. ఫంక్షన్ ప్రధాన () యూజర్ యొక్క పూర్ణాంకాలను పొందుతుంది మరియు తరువాత వాటిని ఫంక్షన్‌కు ఫార్వార్డ్ చేస్తుంది జోడించు () ప్రాసెస్ చేయబడాలి. ఫంక్షన్ జోడించు () ఫలితాన్ని తిరిగి ఇస్తుంది ప్రధాన ()
   • ఇప్పుడు జోడించు () నిర్వచించబడింది, దీనిని ప్రోగ్రామ్‌లో ఎక్కడైనా పిలుస్తారు.

6 యొక్క 6 వ భాగం: నేర్చుకోవడం కొనసాగించండి

1. సి లో ప్రోగ్రామింగ్ గురించి కొన్ని పుస్తకాల ద్వారా వెళ్ళండి. ఈ వ్యాసం బేసిక్స్ లోకి మాత్రమే వెళుతుంది, మరియు అది సి అని పిలువబడే మంచుకొండ యొక్క కొన మరియు దానితో వెళ్ళే ప్రతిదీ. మంచి పుస్తకం సమస్యలను పరిష్కరించడంలో సహాయపడుతుంది మరియు తరువాత మీకు చాలా తలనొప్పిని ఆదా చేస్తుంది.
2. ఒక గుంపులో చేరండి. ఆన్‌లైన్ మరియు వాస్తవ ప్రపంచంలో అనేక రకాల సమూహాలు ఉన్నాయి, అన్ని రకాల ప్రోగ్రామింగ్ మరియు ప్రోగ్రామింగ్ భాషలకు అంకితం చేయబడ్డాయి. కోడ్ మరియు ఆలోచనలను మార్పిడి చేసుకోవడానికి కొంతమంది మనస్సు గల సి ప్రోగ్రామర్‌లను కనుగొనండి మరియు తక్కువ సమయంలో మీరు సాధ్యం అనుకున్నదానికంటే చాలా ఎక్కువ నేర్చుకున్నారని మీరు కనుగొంటారు.
   • వీలైతే కొన్ని హాక్-ఎ-థోన్స్‌కు వెళ్లండి. జట్లు మరియు వ్యక్తులు ఒక నిర్దిష్ట సమయం లోపు సమస్యకు పరిష్కారం మరియు సంబంధిత ప్రోగ్రామ్‌తో ముందుకు రావాల్సిన సంఘటనలు ఇవి, చాలా సృజనాత్మకత అవసరం. మీరు చాలా గొప్ప ప్రోగ్రామర్‌లను కలవవచ్చు మరియు హాక్-ఎ-థోన్స్ ప్రపంచవ్యాప్తంగా నిర్వహించబడతాయి.
3. ఒక కోర్సు పడుతుంది. ప్రోగ్రామర్‌గా శిక్షణ ఇవ్వడానికి మీరు నిజంగా పాఠశాలకు తిరిగి వెళ్లవలసిన అవసరం లేదు, కానీ ఒక కోర్సు తీసుకోవటానికి మరియు మీ అభ్యాస వేగాన్ని పెంచడానికి ఇది బాధించదు. ఒక నిర్దిష్ట విషయంపై బాగా ప్రావీణ్యం ఉన్న వ్యక్తుల నుండి ప్రత్యక్ష సహాయంతో ఏమీ పోటీపడదు. మీరు తరచుగా సమీపంలో ఒక కోర్సును కనుగొనవచ్చు లేదా ఆన్‌లైన్ కోర్సు కోసం శోధించడానికి ప్రయత్నించండి.
4. సి ++ నేర్చుకోవడాన్ని కూడా పరిగణించండి. మీరు C ని ప్రావీణ్యం పొందిన తర్వాత, C ++ కి వెళ్లడం బాధించదు. ఇది సి యొక్క మరింత ఆధునిక వేరియంట్, మరియు చాలా ఎక్కువ సౌలభ్యాన్ని అందిస్తుంది. C ++ వస్తువులతో పనిచేయడం కోసం రూపొందించబడింది, మరియు C ++ తో పనిచేయగలగడం దాదాపు ఏదైనా ఆపరేటింగ్ సిస్టమ్ కోసం శక్తివంతమైన ప్రోగ్రామ్‌లను వ్రాయడానికి మిమ్మల్ని అనుమతిస్తుంది.

చిట్కాలు

• మీ ప్రోగ్రామ్‌లపై ఎల్లప్పుడూ వ్యాఖ్యానించండి. ఇది మీ సోర్స్ కోడ్‌ను అర్థం చేసుకోవడానికి ఇతరులకు సహాయపడటమే కాకుండా, మీరు ఎన్‌కోడ్ చేసిన వాటిని మరియు ఎందుకు గుర్తుంచుకోవాలో కూడా సహాయపడుతుంది. మీరు ఏమి చేస్తున్నారో మీకు ఇప్పుడు తెలిసి ఉండవచ్చు, కానీ సుమారు 2-3 నెలల తరువాత, మీకు ఇకపై తెలియదు.
• ప్రింట్ ఎఫ్ (), స్కాన్ఫ్ (), గెట్చ్ (), మొదలైనవాటిని సెమికోలన్ (;) తో ముగించడం మర్చిపోవద్దు, కానీ "ఉంటే", "అయితే" లేదా "ఉచ్చులు" వంటి స్టేట్మెంట్ల తర్వాత ఉంచవద్దు.
• కంపైల్ సమయంలో మీరు సింటాక్స్ లోపాన్ని ఎదుర్కొని, మీరు చిక్కుకుపోతే, దోష సందేశం అంటే ఏమిటో తెలుసుకోవడానికి మీకు ఇష్టమైన సెర్చ్ ఇంజిన్‌ను ఉపయోగించండి. ఇదే సమస్యకు వేరొకరు ఇప్పటికే ఒక పరిష్కారాన్ని పోస్ట్ చేసిన మంచి అవకాశం ఉంది.
• సోర్స్ కోడ్‌లో *. C పొడిగింపు ఉండాలి, తద్వారా కంపైలర్‌కు ఇది సి ఫైల్ అని తెలుసు.
• గుర్తుంచుకోండి, అభ్యాసం పరిపూర్ణంగా ఉంటుంది. మీరు ప్రోగ్రామ్‌లు రాయడం ఎంత ఎక్కువ సాధన చేస్తే అంత మంచిది. కాబట్టి మీకు దృ f మైన పట్టు ఉండే వరకు సరళమైన, చిన్న ప్రోగ్రామ్‌లతో ప్రారంభించండి, ఆపై మరింత క్లిష్టమైన ప్రోగ్రామ్‌లకు వెళ్లండి.
• తర్కం గురించి తెలుసుకోండి. మీరు కోడింగ్ చేస్తున్నప్పుడు ఇది వివిధ సమస్యలను పరిష్కరించడంలో సహాయపడుతుంది.