ఈ వివరణాత్మక గైడ్‌లో, మేము సి ప్రోగ్రామింగ్‌లోని ఆపరేటర్లు మరియు వాటి రకాలను చర్చిస్తాము.
C ప్రోగ్రామింగ్‌లో ఆపరేటర్లు మరియు వారి రకాలు
ఆపరేటర్లు నిర్దిష్ట గణిత పనులను నిర్వహించడానికి ఉపయోగించే చిహ్నాలు. డేటా మరియు వేరియబుల్స్‌ను మార్చటానికి అవి ఉపయోగించబడతాయి. C ప్రోగ్రామింగ్‌లోని వివిధ రకాల ఆపరేటర్లు క్రిందివి:
- అరిథ్మెటిక్ ఆపరేటర్లు
- యునరీ ఆపరేటర్లు
- అసైన్‌మెంట్ ఆపరేటర్లు
- లాజికల్ లేదా బూలియన్ ఆపరేటర్లు
- రిలేషనల్ ఆపరేటర్లు
- షరతులతో కూడిన ఆపరేటర్లు
- బిట్‌వైస్ ఆపరేటర్లు
1: అంకగణిత ఆపరేటర్లు
ఇవి కూడిక, తీసివేత లేదా గుణకారం వంటి ప్రాథమిక గణిత విధులను నిర్వహించడానికి ఉపయోగించే ఆపరేటర్లు. మీరు C ప్రోగ్రామింగ్‌లోని దాదాపు అన్ని అంతర్నిర్మిత డేటా రకాల్లో ఈ ఆపరేటర్లను ఉపయోగించవచ్చు. సి ప్రోగ్రామింగ్‌లో ఉపయోగించే అంకగణిత ఆపరేటర్లు క్రిందివి:
| ఆపరేటర్లు | విధులు |
| + | 2 ఆపరాండ్లను జోడించండి |
| – | 2 ఆపరాండ్లను తీసివేయండి |
| * | 2 ఆపరాండ్లను గుణించండి |
| / | 2 ఆపరాండ్లను విభజించండి |
| % | మాడ్యులస్ ఆపరేటర్ విభజన యొక్క మిగిలిన భాగాన్ని ఇస్తుంది |
ఉదాహరణ
దిగువ ఉదాహరణలో, మేము వేరియబుల్ X మరియు వేరియబుల్ Y పై పైన పేర్కొన్న అంకగణిత ఆపరేషన్‌లను చేసాము. వేరియబుల్ X విలువ 20 మరియు Y విలువ 5 కలిగి ఉంటుంది:
#
int ప్రధాన ( )
{
int X = ఇరవై ;
int మరియు = 5 ;
int ఫలితం ;
ఫలితం = X + మరియు ;
printf ( 'X మరియు Y యొక్క అదనం: %d \n ' , ఫలితం ) ;
ఫలితం = X - మరియు ;
printf ( 'X మరియు Y యొక్క వ్యవకలనం: %d \n ' , ఫలితం ) ;
ఫలితం = X * మరియు ;
printf ( 'X మరియు Y యొక్క గుణకారం: %d \n ' , ఫలితం ) ;
ఫలితం = X / మరియు ;
printf ( 'X మరియు Y యొక్క విభజన: %d \n ' , ఫలితం ) ;
ఫలితం = X % మరియు ;
printf ( 'X మరియు Y యొక్క మాడ్యులస్ డివిజన్: %d \n ' , ఫలితం ) ;
తిరిగి 0 ;
}
2: యునరీ ఆపరేటర్లు
C లాంగ్వేజ్, ఇంక్రిమెంట్ ++ మరియు డిక్రిమెంట్ — ఆపరేటర్ల ద్వారా మాత్రమే మద్దతిచ్చే రెండు ప్రత్యేకమైన unary ఆపరేటర్లు ఉన్నాయి. ఇంక్రిమెంట్ ఆపరేటర్ ఒపెరాండ్‌కు 1ని జోడిస్తుంది మరియు డిక్రిమెంట్ ఆపరేటర్ ఒపెరాండ్ నుండి 1ని తీసివేస్తుంది.
ఇంక్రిమెంట్ ఆపరేటర్ ఇలా వ్రాయబడింది:
++ a లేదా a ++
తగ్గింపు ఆపరేటర్:
-- a లేదా a --మేము ఇంక్రిమెంట్ మరియు డిక్రిమెంట్ ఆపరేటర్‌ను ఉపసర్గగా ఉపయోగిస్తే అది మొదట వేరియబుల్ విలువను జోడిస్తుంది లేదా తీసివేస్తుంది మరియు ఫలితం ఎడమవైపు ఉన్న వేరియబుల్‌కు కేటాయించబడుతుంది. ఆపరేటర్లు ముందు జోడించబడితే, అది మొదట అసలు విలువను అందిస్తుంది మరియు తర్వాత operand 1 ద్వారా జోడించబడుతుంది లేదా తీసివేయబడుతుంది.
ఉదాహరణ
క్రింద మేము రెండు వేరియబుల్స్ a మరియు b లకు విలువలను కేటాయించాము మరియు వాటిపై ఇంక్రిమెంట్ మరియు డిక్రిమెంట్ ఆపరేటర్లను వర్తింపజేసాము:
#int ప్రధాన ( )
{
int a = పదిహేను , బి = 10 ;
printf ( '++a = %d \n ' , ++ a ) ;
printf ( 'a++ = %d \n ' , a ++ ) ;
తిరిగి 0 ;
}
3: అసైన్‌మెంట్ ఆపరేటర్
ఒక అసైన్‌మెంట్ ఆపరేటర్ (=) ప్రోగ్రామ్‌లోని వేరియబుల్‌కు విలువను కేటాయించడం కోసం ఉపయోగించబడుతుంది. దిగువ పేర్కొన్న అసైన్‌మెంట్ ఆపరేటర్లు:
| ఆపరేటర్లు | ఫంక్షన్ |
| = | ఒపెరాండ్‌కు విలువలను కేటాయించండి |
| += | ఎడమ ఒపెరాండ్‌కు కుడి వైపున ఉన్న ఒపెరాండ్ విలువను జోడించండి |
| -= | ఎడమ ఒపెరాండ్ నుండి కుడి ఒపెరాండ్ విలువను తీసివేయండి |
| *= | కుడి ఒపెరాండ్ విలువను ఎడమ ఒపెరాండ్‌కి గుణించండి |
| /= | కుడి ఒపెరాండ్ విలువను ఎడమ ఒపెరాండ్‌కు విభజించండి |
| %= | రెండు విలువల మాడ్యులస్‌ని తీసుకోండి మరియు ఎడమ ఒపెరాండ్‌కు విలువను కేటాయించండి |
ఉదాహరణ
దిగువ ఉదాహరణలో X మరియు Y అనే రెండు ఆపరేటర్‌లపై అసైన్‌మెంట్ ఆపరేటర్ల పనిని మేము ప్రదర్శించాము:
#int ప్రధాన ( )
{
int X = 10 ;
int ఫలితం ;
ఫలితం = X ;
printf ( 'ఫలితం విలువ = %d \n ' , ఫలితం ) ;
ఫలితం += X ;
printf ( 'ఫలితం విలువ = %d \n ' , ఫలితం ) ;
ఫలితం -= X ;
printf ( 'ఫలితం విలువ = %d \n ' , ఫలితం ) ;
ఫలితం *= X ;
printf ( 'ఫలితం విలువ = %d \n ' , ఫలితం ) ;
ఫలితం /= X ;
printf ( 'ఫలితం విలువ = %d \n ' , ఫలితం ) ;
తిరిగి 0 ;
}
4: రిలేషనల్ ఆపరేటర్లు
రెండు వేరియబుల్స్ మధ్య సంబంధాన్ని తనిఖీ చేయడానికి రిలేషనల్ ఆపరేటర్లు C ప్రోగ్రామింగ్‌లో ఉపయోగించబడతాయి. ఇది వస్తువుల ధరలను లేదా ఇద్దరు వ్యక్తుల వయస్సును పోల్చడానికి ఉపయోగించబడుతుంది C ప్రోగ్రామింగ్‌లో ఉపయోగించే రిలేషనల్ ఆపరేటర్లు క్రిందివి:
| ఆపరేటర్లు | విధులు |
| == | సమానంగా |
| > | అంతకన్నా ఎక్కువ |
| < | కంటే తక్కువ |
| >= | సమానం కంటే ఎక్కువ |
| <= | సమానం కంటే తక్కువ |
| != | సమానం కాదు |
ఉదాహరణ
దిగువ ఉదాహరణ సి ప్రోగ్రామింగ్‌లో రిలేషనల్ ఆపరేటర్ల పనిని చూపుతోంది:
#int ప్రధాన ( )
{
int a = 9 ;
int బి = 10 ;
printf ( '%d == %d అనేది %d \n ' , a , బి , a == బి ) ;
printf ( '%d > %d అనేది %d \n ' , a , బి , a > బి ) ;
printf ( '%d < %d అంటే %d \n ' , a , బి , a < బి ) ;
printf ( '%d != %d అనేది %d \n ' , a , బి , a != బి ) ;
printf ( '%d >= %d అనేది %d \n ' , a , బి , a >= బి ) ;
printf ( '%d <= %d అనేది %d \n ' , a , బి , a <= బి ) ;
తిరిగి 0 ;
}
5: లాజికల్ ఆపరేటర్లు
సి లాంగ్వేజ్ ద్వారా సపోర్ట్ చేసే నాలుగు లాజికల్ ఆపరేటర్లు ఉన్నాయి:
| ఆపరేటర్లు | ఫంక్షన్ |
| లాజికల్ మరియు (&&) | అన్ని పరిస్థితులు సంతృప్తికరంగా ఉంటే మాత్రమే నిజం |
| లాజికల్ OR (||) | ఒక షరతు మాత్రమే సంతృప్తి చెందితే ఫలితం నిజం |
| తార్కికం కాదు(!) | ఒపెరాండ్ 0 అయితే ఫలితం నిజం |
| బిట్‌వైస్ కాదు (~). | ఒపెరాండ్ యొక్క అన్ని బిట్‌లను విలోమం చేస్తుంది |
ఉదాహరణ
దిగువ ఉదాహరణ కోడ్ C లో లాజికల్ ఆపరేటర్ల పనిని వివరిస్తుంది:
#int ప్రధాన ( )
{
int X = 10 , మరియు = 4 , తో = 10 , ఫలితం ;
ఫలితం = ( X == మరియు ) && ( తో > మరియు ) ;
printf ( '(X == Y) && (Z > Y) %d \n ' , ఫలితం ) ;
ఫలితం = ( X == మరియు ) && ( తో < మరియు ) ;
printf ( '(X == Y) && (Z
ఫలితం = ( X == మరియు ) || ( తో < మరియు ) ;
printf ( '(X == Y) || (Z < Y) %d \n ' , ఫలితం ) ;
ఫలితం = ( X != మరియు ) || ( తో < మరియు ) ;
printf ( '(X != Y) || (Z
ఫలితం = ! ( X != మరియు ) ;
printf ( '!(X != Y) %d \n ' , ఫలితం ) ;
ఫలితం = ! ( X == మరియు ) ;
printf ( '!(X == Y) %d \n ' , ఫలితం ) ;
ఫలితం = ! ( X > మరియు ) ;
printf ( '!(X > Y) %d \n ' , ఫలితం ) ;
తిరిగి 0 ;
}
6: షరతులతో కూడిన ఆపరేటర్లు
C లోని షరతులతో కూడిన ఆపరేటర్‌ని కూడా అంటారు టెర్నరీ ఆపరేటర్ ఎందుకంటే ఇది మూడు ఆపరేండ్‌లను తీసుకుంటుంది - షరతు, స్టేట్‌మెంట్ 1 మరియు స్టేట్‌మెంట్ 2. ఇది కండిషన్‌ను మూల్యాంకనం చేస్తుంది మరియు ఇచ్చిన షరతు యొక్క ఫలితం ఆధారంగా స్టేట్‌మెంట్ 1 లేదా స్టేట్‌మెంట్ 2ని అందిస్తుంది, అది నిజం లేదా తప్పు కావచ్చు
పరిస్థితి ? ప్రకటన 1 : ప్రకటన 2- పరిస్థితి: బూలియన్ వ్యక్తీకరణ నిజమా లేదా తప్పు అని తనిఖీ చేస్తుంది.
- ప్రకటన 1: పరిస్థితి నిజమైతే మూల్యాంకనం చేసే వ్యక్తీకరణ.
- ప్రకటన 2: పరిస్థితి తప్పు అయితే మూల్యాంకనం చేసే వ్యక్తీకరణ.
ఉదాహరణ
దిగువ ఉదాహరణలో, నేను సంఖ్యకు విలువను కేటాయించి, ఆపై షరతును వర్తింపజేసాను, షరతు నిజమైతే స్టేట్‌మెంట్ 1 అవుట్‌పుట్ అవుతుంది మరియు కండిషన్ తప్పు అయితే స్టేట్‌మెంట్ రెండు అవుట్‌పుట్ అవుతుంది:
#int ప్రధాన ( )
{
int సంఖ్య = 10 ;
( సంఖ్య < ఇరవై ) ? ( printf ( 'ఇది సంఖ్య 20 కంటే తక్కువ!' ) ) : ( printf ( 'ఇది సంఖ్య 20 కంటే ఎక్కువ!' ) ) ;
తిరిగి 0 ;
}
7: బిట్‌వైస్ ఆపరేటర్లు
బిట్‌వైజ్ ఆపరేటర్లు C లో బిట్ స్థాయిలో డేటాను మానిప్యులేట్ చేయండి, అంటే అవి పూర్ణాంకాల వంటి డేటా రకాల్లోని వ్యక్తిగత బిట్‌లపై పనిచేస్తాయి. అవి డబుల్ మరియు ఫ్లోట్‌కు వర్తించబడవు మరియు బిట్‌లను పరీక్షించడానికి మరియు వాటిని కుడి లేదా ఎడమకు మార్చడానికి ఉపయోగించబడతాయి.
C ప్రోగ్రామింగ్‌లోని బిట్‌వైస్ ఆపరేటర్లు క్రింది పట్టికలో ఇవ్వబడ్డాయి:
| ఆపరేటర్లు | ఫంక్షన్ |
| & | బిట్‌వైస్ మరియు |
| | | బిట్‌వైస్ OR |
| ^ | Bitwise Exclusive OR |
| << | షిఫ్ట్ ఎడమ |
| >> | కుడివైపుకి మారండి |
| ~ | ఒకరి పూరక |
ఉదాహరణ
కింది ఉదాహరణ బిట్‌వైస్ ఆపరేటర్లను ఉపయోగించే C ప్రోగ్రామ్‌ను చూపుతుంది:
#int ప్రధాన ( ) {
int a = 13 ; // బైనరీ 1101
int బి = 7 ; // బైనరీ 0111
int ఫలితం ;
// బిట్‌వైస్ మరియు
ఫలితం = a & బి ; // 1101 & 0111 = 0101 (దశాంశం 5)
printf ( 'a & b = %u \n ' , ఫలితం ) ;
// బిట్‌వైస్ లేదా
ఫలితం = a | బి ; // 1101 | 0111 = 1111 (దశాంశం 15)
printf ( 'a | b = %u \n ' , ఫలితం ) ;
// బిట్‌వైస్ XOR
ఫలితం = a ^ బి ; // 1101 ^ 0111 = 1010 (దశాంశం 10)
printf ( 'a ^ b = %u \n ' , ఫలితం ) ;
// బిట్‌వైజ్ ఎడమ షిఫ్ట్
ఫలితం = a << 2 ; // 1101 << 2 = 110100 (దశాంశం 52)
printf ( 'a << 2 = %u \n ' , ఫలితం ) ;
// బిట్‌వైస్ రైట్ షిఫ్ట్
ఫలితం = a >> 2 ; // 1101 >> 2 = 0011 (దశాంశం 3)
printf ( 'a >> 2 = %u \n ' , ఫలితం ) ;
// బిట్‌వైస్ కాదు
ఫలితం = ~a ; // ~1101 = 0010 (దశాంశ 2 యొక్క పూరక ప్రాతినిధ్యం -14)
printf ( '~a = %d \n ' , ఫలితం ) ;
తిరిగి 0 ;
}
గమనిక: బిట్‌వైజ్ ఆపరేటర్లు బిట్ స్థాయిలో విధులను నిర్వహించడానికి ఉపయోగిస్తారు, అంటే అవి బైనరీ సంఖ్యలో వ్యక్తిగత బిట్‌లపై పనిచేస్తాయి. బూలియన్ ఆపరేటర్లు, మరోవైపు, తార్కిక విలువలపై కార్యకలాపాలను నిర్వహించడానికి ఉపయోగిస్తారు. అవి బూలియన్ విలువలపై పనిచేస్తాయి (నిజం/తప్పు లేదా 1/0) మరియు సాధారణంగా నిర్ణయం తీసుకునే ప్రక్రియలు లేదా షరతులతో కూడిన ప్రకటనలలో ఉపయోగించబడతాయి.
క్రింది గీత
ఆపరేటర్ అనేది కంపైలర్‌కు నిర్దిష్ట విధులను నిర్వహించమని సూచించే చిహ్నం. C భాషలో అంకగణితం, యునరీ, అసైన్‌మెంట్, లాజికల్, రిలేషనల్, షరతులతో కూడిన, బూలియన్ మరియు బిట్‌వైస్ వంటి అనేక అంతర్నిర్మిత ఆపరేటర్లు ఉన్నాయి. మేము వాటిని వివరంగా చర్చించాము మరియు ఉదాహరణ అవుట్‌పుట్‌తో వాటిని ప్రదర్శించాము. ఈ ఆపరేటర్ల గురించి వివరణాత్మక సమాచారాన్ని పొందడానికి గైడ్‌లోని పై విభాగాన్ని చదవండి.