ఈ బిల్డింగ్ బ్లాక్‌లు లేదా మూలకాల గురించి మీకు తెలియకుంటే, ఈ కథనం యొక్క మార్గదర్శకాలను అనుసరించండి.
సి భాష యొక్క మూలకాలు
సి భాషకు అనేక విభిన్నతలు ఉన్నాయి అంశాలు ఇది ఉపయోగించడానికి సులభమైన మరియు సమర్ధవంతంగా చేస్తుంది. ఇవి అంశాలు ఉన్నాయి వేరియబుల్స్ , డేటా రకాలు , కీలకపదాలు , ఆపరేటర్లు ఇంకా చాలా. అయినప్పటికీ, క్రింద పేర్కొన్న అంశాలు ముఖ్యమైనవి మరియు C ప్రోగ్రామింగ్ భాషలో విస్తృతంగా ఉపయోగించబడతాయి.
1: వేరియబుల్స్
వేరియబుల్స్ సి భాష యొక్క ప్రధాన అంశాలు. ఎ వేరియబుల్ నిర్దిష్ట సూచనల సెట్ కోసం వాదనగా ఉపయోగించబడే విలువను కలిగి ఉండే మెమరీ భాగం. ప్రకటిస్తున్నారు వేరియబుల్స్ వారి పేరు, విలువ మరియు డేటా రకాన్ని పేర్కొనడం. వేరియబుల్స్ సంఖ్యలు, స్ట్రింగ్‌లు, అక్షర శ్రేణులు లేదా ఏదైనా ఇతర డేటా రకాన్ని సూచించడానికి కూడా ఉపయోగించవచ్చు.
#
శూన్యం ఫంక్షన్ ( )
{
int a = 10 ;
printf ( 'వేరియబుల్ a విలువ %d' , a ) ;
}
int ప్రధాన ( ) {
ఫంక్షన్ ( ) ;
}
ఈ కోడ్‌లో, మేము a ఉపయోగిస్తున్నాము వేరియబుల్ 'a' మరియు ఉపయోగించి దాని విలువను ముద్రించడం printf ప్రకటన.
అవుట్‌పుట్
2: డేటా రకాలు
అని పిలువబడే విలువల సమూహం డేటా రకాలు వేరియబుల్‌లో ఉంచవచ్చు. సి భాష చాలా ఉపయోగిస్తుంది డేటా రకాలు వంటివి int (పూర్ణాంకాల కోసం), చార్ (అక్షరాల కోసం), ఫ్లోట్ (దశాంశ బిందువులతో సంఖ్యా విలువల కోసం) , రెట్టింపు (డబుల్ ప్రెసిషన్ ఫ్లోటింగ్ పాయింట్ విలువల కోసం) ఇంకా చాలా. మీరు జోడించదలిచిన వేరియబుల్ రకం ఆధారంగా, అవి కోడ్‌లో ఉపయోగించబడతాయి. క్రింద చర్చించిన ఉదాహరణను అనుసరించండి:
#
int ప్రధాన ( ) {
int ఒకదానిపై = 10 ;
printf ( 'సంఖ్య యొక్క విలువ %d' , ఒకదానిపై ) ;
}
పై కోడ్‌లో, మేము ఒక ఉపయోగిస్తున్నాము పూర్ణ సంఖ్య సమాచార తరహా 'ఒకదానిపై' మరియు ఉపయోగించి దాని విలువను ముద్రించడం printf ప్రకటన.
అవుట్‌పుట్
3: కీలకపదాలు
కీలకపదాలు నిర్దిష్ట అర్థాన్ని కలిగి ఉండే మరియు ప్రోగ్రామ్‌ను ప్రారంభించడానికి సహాయపడే ముందే నిర్వచించబడిన పదాలు. 32 ఉన్నాయి కీలకపదాలు సి భాషలో if, else, while, for, int మరియు floatతో సహా. ప్రతి కీవర్డ్ దాని స్వంత నిర్దిష్ట ప్రయోజనాన్ని కలిగి ఉంది, ఇది వాటిని కోడ్‌లో చాలా ముఖ్యమైన అంశాలను చేస్తుంది.
#int ప్రధాన ( )
{
దానంతట అదే a = 10 ;
printf ( '%d' , a ) ;
తిరిగి 0 ;
}
ఈ కోడ్‌లో, మేము కీవర్డ్‌ని ఉపయోగిస్తున్నాము 'దానంతట అదే' మరియు ఉపయోగించి దాని విలువను ముద్రించడం printf ప్రకటన.
గమనిక: మీరు మీ వేరియబుల్ పేరుగా కీవర్డ్ పేరును ఉపయోగించలేరు ఎందుకంటే ఇది లోపాలను సృష్టిస్తుంది. కారణం అవి ఇప్పటికే సి ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో నిర్వచించబడ్డాయి.
అవుట్‌పుట్
4: ఆపరేటర్లు
ఆపరేటర్లు ఫలితాలను రూపొందించడానికి ఒపెరాండ్‌ల (విలువలు) సెట్‌పై కార్యకలాపాలను నిర్వహించే ఏకైక చిహ్నాలు. సి భాషలో అనేక రకాలు ఉన్నాయి ఆపరేటర్లు పోలిక, అంకగణితం, అసైన్‌మెంట్ మరియు తార్కికం వంటివి ఆపరేటర్లు . ప్రతి రకమైన ఆపరేటర్ ఇచ్చిన విలువలపై నిర్దిష్ట రకమైన ఆపరేషన్‌ను నిర్వహిస్తుంది.
#int ప్రధాన ( )
{
int a = పదకొండు , బి = 5 ;
printf ( 'మొత్తం = %d \n ' , a + బి ) ;
తిరిగి 0 ;
}
ఈ కోడ్‌లో, మేము ఒక ఉపయోగిస్తున్నాము ఆపరేటర్ '+' ముద్రించడానికి మొత్తం రెండు వేరియబుల్స్ a మరియు b.
అవుట్‌పుట్
5: నియంత్రణ నిర్మాణాలు
సి భాష పరిధిని కలిగి ఉంటుంది నియంత్రణ నిర్మాణాలు ఇది డెవలపర్‌లు వారి ప్రోగ్రామ్ యొక్క అమలు ప్రవాహాన్ని నియంత్రించడానికి అనుమతిస్తుంది. ఇవి if స్టేట్‌మెంట్‌లు, లూప్‌ల కోసం మరియు అయితే లూప్‌ల వంటి ప్రాసెసింగ్ ఆబ్జెక్ట్‌లను కలిగి ఉంటాయి, వీటిని కొన్ని షరతులపై ఆధారపడి నిర్దిష్ట ఆపరేషన్‌లను పునరావృతం చేయడానికి ఉపయోగించవచ్చు. నియంత్రణ నిర్మాణాలు ఇలాంటి డెవలపర్‌లు దాదాపు పుస్తకంలోని సూచనలను చదివినట్లుగా సంక్లిష్ట సూచనలను రూపొందించడంలో సహాయపడతారు.
#includeint ప్రధాన ( )
{
int సంవత్సరం ;
printf ( 'ఒక సంవత్సరం నమోదు చేయండి:' ) ;
స్కాన్ఎఫ్ ( '%d' ,& సంవత్సరం ) ;
ఉంటే ( సంవత్సరం % 4 == 0 )
printf ( '%d ఒక లీపు సంవత్సరం.' , సంవత్సరం ) ;
లేకపోతే printf ( '%d లీపు సంవత్సరం కాదు.' , సంవత్సరం ) ;
}
ఈ కోడ్‌లో, మేము దీనిని ఉపయోగిస్తాము 'if-else' నియంత్రణ నిర్మాణం వినియోగదారు ప్రవేశించిన సంవత్సరం లీప్ ఇయర్ కాదా అని నిర్ణయించడానికి.
అవుట్‌పుట్
6: విధులు
ఒక ఎక్జిక్యూటబుల్ ఫంక్షన్ ప్రధాన ప్రోగ్రామ్ నుండి ప్రారంభించబడే కోడ్ యొక్క విభాగం. ఇది డెవలపర్‌లు కోడ్ ముక్కను ఒకే స్థలంలో ఉంచడానికి అనుమతిస్తుంది, ఆపై వారికి అవసరమైతే కోడ్‌లో మరెక్కడైనా అనేకసార్లు కాల్ చేయండి. విధులు డెవలపర్‌లు కోడ్‌ను మాడ్యులర్ పద్ధతిలో వ్రాయడానికి అనుమతిస్తారు, తద్వారా పెద్ద సమస్యలను చిన్న, నిర్వహించదగిన ముక్కలుగా విభజించవచ్చు.
#includeశూన్యం ప్రపంచం ( ) ;
int ప్రధాన ( )
{
printf ( 'హలో ' ) ;
ప్రపంచం ( ) ;
}
శూన్యం ప్రపంచం ( )
{
printf ( 'ప్రపంచం' ) ;
}
ఈ కోడ్‌లో, పదం 'ప్రపంచం' ఉపయోగించి ముద్రించబడింది ఫంక్షన్ 'వరల్డ్', నుండి పిలుస్తారు ఫంక్షన్ 'ప్రధాన ()' పదబంధాన్ని ముద్రించడానికి 'హలో వరల్డ్'.
అవుట్‌పుట్
7: శ్రేణులు
ఒక యొక్క నిర్వచనం అమరిక C లో ఒకే రకమైన అనేక అంశాలను ఒకచోట చేర్చడానికి ఒక మార్గం. శ్రేణులు పూర్ణాంక, ఫ్లోట్, చార్, డబుల్ వంటి డేటా రకాలను కలిగి ఉండవచ్చు లేదా నిర్మాణాల వంటి వినియోగదారు నిర్వచించిన డేటా రకాలను కలిగి ఉంటాయి. ఏది ఏమైనప్పటికీ, భాగాలు ఒకదానితో ఒకటి కలిసి ఉంచబడతాయి అమరిక , అవన్నీ ఒకే రకమైన డేటాను కలిగి ఉండాలి. అంశాలు ఎడమ నుండి కుడికి క్రమంలో ఉంచబడతాయి, ఎడమవైపు 0వ సూచిక మరియు కుడి వైపున (n-1)వ సూచిక ఉంటుంది.
#int ప్రధాన ( ) {
int విలువలు [ 5 ] ;
printf ( '5 పూర్ణాంకాలను నమోదు చేయండి:' ) ;
కోసం ( int x = 0 ; x < 5 ; ++ x ) {
స్కాన్ఎఫ్ ( '%d' , & విలువలు [ x ] ) ;
}
printf ( 'పూర్ణాంకాలను ప్రదర్శిస్తోంది: \n ' ) ;
కోసం ( int i = 0 ; i < 5 ; ++ i ) {
printf ( '%d \n ' , విలువలు [ i ] ) ;
}
తిరిగి 0 ;
}
వినియోగదారు ఒక లోకి 5 సంఖ్యలను నమోదు చేస్తారు అమరిక అని పిలిచారు 'విలువలు' ఈ కోడ్‌లో, మరియు శ్రేణి విషయాలు తరువాత ప్రదర్శించబడతాయి.
అవుట్‌పుట్
8: నిర్మాణాలు
ఎ నిర్మాణం C కంప్యూటర్ భాషలో ఒకే పేరుతో మెమరీ బ్లాక్‌లో భౌతికంగా వ్యవస్థీకృత వేరియబుల్స్ జాబితాను సృష్టించే మిశ్రమ డేటా రకం ప్రకటన. ఒకే పాయింటర్ లేదా స్ట్రక్ట్-డిక్లేర్డ్ పేరును ఉపయోగించడం ద్వారా, అదే చిరునామాను అందించడం ద్వారా, విభిన్న వేరియబుల్స్‌ను యాక్సెస్ చేయడం సాధ్యపడుతుంది. Cలో, వినియోగదారు నిర్వచించిన డేటా రకాన్ని అంటారు నిర్మాణం వివిధ రకాలైన విభిన్న డేటాను నిల్వ చేయడానికి మమ్మల్ని అనుమతిస్తుంది. a యొక్క ప్రతి భాగం నిర్మాణం a గా సూచిస్తారు 'సభ్యుడు' . విభిన్న డేటాను కలిగి ఉండే సామర్థ్యం కారణంగా, నిర్మాణాలు తరగతులు మరియు టెంప్లేట్‌ల వినియోగాన్ని అనుకరించవచ్చు.
##include
నిర్మాణం పుస్తకం {
చార్ పేరు [ యాభై ] ;
int ధర ;
} పుస్తకం 1 ;
int ప్రధాన ( ) {
strcpy ( పుస్తకం 1. పేరు , ఒడెస్సా ) ;
పుస్తకం 1. ధర = 500 ;
printf ( 'పేరు: %s \n ' , పుస్తకం 1. పేరు ) ;
printf ( 'పుస్తకం ధర: %d \n ' , పుస్తకం 1. ధర ) ;
తిరిగి 0 ;
}
పై కోడ్ aని సృష్టిస్తుంది నిర్మాణం అని పిలిచారు 'పుస్తకం' లక్షణాలతో 'పేరు' మరియు 'ధర' తరువాత a లో నమోదు చేయబడతాయి నిర్మాణం ముద్రించడానికి ముందు ఉదాహరణ.
అవుట్‌పుట్
ముగింపు
C ప్రోగ్రామ్‌ను వ్రాయడానికి డెవలపర్‌లను అనుమతించడానికి కలిసి పని చేసే C అంశాలు ఉపయోగకరంగా ఉంటాయి. C ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో అనేక అంశాలు ఉన్నాయి, ఇందులో వేరియబుల్స్, డేటా రకాలు, కీలకపదాలు మరియు పై మార్గదర్శకాలలో మరింత చర్చించబడ్డాయి. వీటిని అర్థం చేసుకోవడం అంశాలు సమర్థవంతమైన మరియు బాగా వ్రాసిన సి ప్రోగ్రామ్‌లను రూపొందించడంలో వినియోగదారులకు సహాయం చేస్తుంది.