విధానము
ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో వివిధ ఫంక్షన్ల కోసం మనం ఉపయోగించే మాడ్యులస్ ఆపరేటర్‌కి అనేక ఉపయోగాలు ఉన్నాయి. మేము వేర్వేరు ఉదాహరణల కోసం వేర్వేరు ఫంక్షన్ల కోసం మాడ్యులస్ చేస్తాము. ప్రతి ఉదాహరణ మాడ్యులస్ ఆపరేటర్ యొక్క విభిన్న ఉపయోగం గురించి మాకు తెలియజేస్తుంది. కాబట్టి, 'C++ మాడ్యులస్ ఆపరేటర్' కోసం ఉదాహరణలను పరిష్కరిద్దాం.
ఉదాహరణ # 01
మొదటి ఉదాహరణలో, మేము మాడ్యులస్ ఆపరేటర్ యొక్క సింటాక్స్ గురించి తెలుసుకుంటాము మరియు మాడ్యులస్ ఆపరేటర్ యొక్క సాధారణ ఉదాహరణను పరిష్కరిస్తాము. ఈ ప్రయోజనం కోసం, మేము మాడ్యులస్ ఆపరేటర్‌ను డివిడెండ్ మరియు డివైజర్ రెండింటిలోనూ ఒకే రకమైన డేటా రకాలను కలిగి ఉంటాము అంటే పూర్ణాంకం “పూర్ణాంకము”. మేము రెండు వేరియబుల్స్‌ని నిర్వచిస్తాము, x & y ని పూర్ణాంకాలుగా చెప్పండి. అప్పుడు, మేము ఈ పూర్ణాంకాలకి కొంత యాదృచ్ఛిక విలువను కేటాయిస్తాము. విలువను కేటాయించిన తర్వాత, మేము ఈ రెండు విలువలపై మాడ్యులస్ ఆపరేటర్‌ను “డివిడెండ్ % డివైజర్”గా వర్తింపజేస్తాము మరియు దీన్ని వేరే వేరియబుల్‌లో నిల్వ చేస్తాము. అప్పుడు, మేము ప్రింట్ ఫంక్షన్‌ని ఉపయోగించి ఆ వేరియబుల్‌ని ప్రదర్శిస్తాము.
అవుట్‌పుట్:
అవుట్‌పుట్‌లోని శేషం సున్నాకి సమానమైన విలువను అందించింది. అంటే x పూర్తిగా y చేత భాగించబడుతుంది. కాబట్టి, x అనేది y యొక్క కారకం.
ఉదాహరణ # 02
ఈ రెండవ ఉదాహరణలో, రెండు కంటే ఎక్కువ వేరియబుల్స్ యొక్క మాడ్యులస్‌ను గణించడానికి గొలుసులోని మాడ్యులస్ ఆపరేటర్‌ను ఎలా ఉపయోగించవచ్చో మనం నేర్చుకుంటాము. మొదట, మేము వేరియబుల్స్ యొక్క డేటా రకాన్ని నిర్వచిస్తాము. ఈ సందర్భంలో, మేము మూడు వేరియబుల్స్ తీసుకుంటాము మరియు వాటి చైన్ మాడ్యులస్‌ను గణిస్తాము. యాదృచ్ఛికంగా మూడు వేరియబుల్‌లను ఎంచుకోండి ఉదా., x, y, z పూర్ణాంకాల వలె అదే డేటా రకాలతో మరియు ప్రతి వేరియబుల్‌కు వేర్వేరు విలువలను కేటాయించడం ద్వారా వాటిని ప్రారంభించండి. అప్పుడు, ఈ మూడు వేరియబుల్స్‌పై మాడ్యులస్ ఆపరేటర్‌ను “x% y% z”గా వర్తింపజేయండి. 'కౌట్ <<' ఉపయోగించి దీన్ని ప్రదర్శించండి. కోడ్ ఎడిటర్‌లో కింది కోడ్‌ని అమలు చేయడం ద్వారా ఇది చేయవచ్చు:
అవుట్‌పుట్:
x % y యొక్క మాడ్యులస్ అంటే 13 % 5 3 మరియు మాడ్యులస్ (x % y) % z అంటే (3) % 2 1. మన అవుట్‌పుట్ సరిగ్గా ఒకదానికి సమానంగా రావడానికి ఇదే కారణం.
ఉదాహరణ # 03
మేము వేరియబుల్‌పై మాడ్యులస్‌ను అవే డేటా రకాలు లేదా మాడ్యులస్ ఆపరేటర్‌తో సమ్మతమైన డేటా రకాలతో వర్తింపజేసాము. ఈ ఉదాహరణలో, మాడ్యులస్ ఆపరేటర్ యొక్క ఆపరేషన్ యొక్క పరిమితులను మేము నేర్చుకుంటాము. మాడ్యులస్ ఆపరేటర్ డేటా రకాలు, ఫ్లోట్ మరియు రెట్టింపుపై పని చేయదు. ధృవీకరించడానికి, మేము డేటా టైప్ ఫ్లోట్‌తో రెండు వేరియబుల్‌లను నిర్వచించే ఉదాహరణను ప్రయత్నిద్దాం మరియు వాటిపై మాడ్యులస్‌ను వర్తింపజేస్తాము. ఫలితాలను క్రింది అవుట్‌పుట్‌లో చూడవచ్చు.
ఉదాహరణలో మేము 'a' మరియు 'b' అనే రెండు వేరియబుల్స్ యొక్క డేటా రకంగా ఫ్లోట్‌ను ఉపయోగించినప్పుడు మరియు వాటికి తేలియాడే విలువలను కేటాయించినప్పుడు ఉదా. వరుసగా 13.4 మరియు 5.5. మాడ్యులస్ ఆపరేటర్ ఈ రెండు వేరియబుల్స్‌పై బాగా పని చేయలేదు మరియు డేటా టైప్ ఫ్లోట్‌ను సూచించే కంపైలేషన్ ఎర్రర్‌లను కలిగి ఉంది.
ఉదాహరణ # 04
మాడ్యులస్ ఆపరేటర్ సహాయంతో, మేము సంఖ్య సరి లేదా బేసి అని కూడా కనుగొనవచ్చు. మేము నిర్దిష్ట బేసి మరియు సరి విలువలను తనిఖీ చేయాలనుకుంటున్న అప్లికేషన్‌లలో ఈ ఫంక్షన్‌ను ఉపయోగించవచ్చు. సరి సంఖ్యను కనుగొనడానికి, మేము ఆ సంఖ్య యొక్క మాడ్యులస్‌ను 2 ద్వారా తీసుకుంటాము. మిగిలినది 1 లేదా 0 కాకుండా ఏదైనా ఇతర సంఖ్య అయితే, ఆ సంఖ్య బేసిగా ఉంటుంది. శేషం 0 అని వస్తే, ఆ సంఖ్య సరి అవుతుంది. మేము దిగువ ఇచ్చిన కోడ్‌తో ఈ భావనను అమలు చేయడానికి ప్రయత్నించాము:
అవుట్‌పుట్:
పూర్ణాంకం “a”కి విలువ 4 కేటాయించబడింది మరియు దాని మాడ్యులస్‌ను 2తో తీసుకుంటారు. మిగిలినది సున్నాకి దారితీసింది అంటే ‘a’ అనేది సరి సంఖ్య.
ఉదాహరణ # 05
నిర్దిష్ట విలువ లేదా పూర్ణాంకం కంటే తక్కువ ఉన్న కొన్ని పూర్ణాంకాలను మనం రూపొందించాలనుకుంటే మోడ్ ఆపరేటర్ మాడ్యులస్ ఆపరేటర్‌ని మనం ఎలా ఉపయోగించవచ్చో ఈ ఉదాహరణ చూపుతుంది. మేము ర్యాండ్ ఫంక్షన్‌ని ఉపయోగిస్తాము, దీని విలువ మాడ్యులస్ ఆపరేటర్ ద్వారా పేర్కొన్న గరిష్ట విలువ యొక్క కావలసిన ఎగువ పరిమితితో జత చేయడానికి ఉపయోగించబడుతుంది. ముందుగా, మేము అన్ని ముఖ్యమైన లైబ్రరీలను ఇలా దిగుమతి చేస్తాము:
$ #
$ #
నేమ్‌స్పేస్ stdని ఉపయోగించి, మేము వెక్టర్, endl (స్టేట్‌మెంట్‌ను ముగించడానికి), కౌట్ (ప్రదర్శించడానికి) మరియు సిన్‌ని దిగుమతి చేస్తాము. ఈ దశ తర్వాత, మేము గరిష్ట పరిమితిని నిర్వచిస్తాము, ఈ ఉదాహరణలో ఇది 1000. ఆ తర్వాత, 10కి సమానంగా ఉండేలా మనం ఎన్ని సంఖ్యలను రూపొందించాలనుకుంటున్నామో సెట్ చేస్తాము. ప్రధానంగా, మేము ఇండెక్స్‌ను గరిష్టంగా అమలు చేస్తాము. పరిమితి మరియు గరిష్ట పరిమితి యొక్క మాడ్యులస్‌తో దాని తిరిగి వచ్చిన విలువను జత చేయడం ద్వారా ర్యాండ్ ఫంక్షన్‌ని ఉపయోగించి సంఖ్యలను ఉత్పత్తి చేస్తుంది మరియు అవుట్‌పుట్‌ను ప్రదర్శిస్తుంది.
అవుట్‌పుట్:
పైన పేర్కొన్న కోడ్ పది సంఖ్యలు ఉత్పత్తి చేయబడిన అవుట్‌పుట్‌ను రూపొందించింది, అది మేము ఉత్పత్తి చేయవలసిన సంఖ్యల గరిష్ట పరిమితిని వెయ్యి కంటే తక్కువ మరియు సంఖ్యలలో మొత్తం పదిగా నిర్వచించినందున వెయ్యి కంటే తక్కువ.
ముగింపు
ఈ గైడ్ సహాయంతో, మాడ్యులస్ ఆపరేటర్ అంటే ఏమిటి, దాని సింటాక్స్ ఏమిటి మరియు వివిధ అప్లికేషన్‌లలో మాడ్యులస్ ఆపరేటర్ యొక్క ఉపయోగాన్ని మనం ఎలా కనుగొనగలము. మేము C++ అప్లికేషన్‌లలో మాడ్యులస్ ఆపరేటర్ యొక్క వివిధ ఉపయోగాలకు సంబంధించిన విభిన్న ఉదాహరణలను పరిష్కరించాము. ఇంకా, మాడ్యులస్ ఆపరేటర్ యొక్క పరిమితుల గురించి కూడా మేము తెలుసుకున్నాము.