సంఖ్యా డేటా అనేది భాషకు బదులుగా సంఖ్యల రూపంలో సూచించబడే డేటా రకం. ఇది డేటా యొక్క పరిమాణాత్మక ప్రాతినిధ్యం. పిల్లవాడు డబ్బును లెక్కించడం నుండి ఒక గొప్ప వ్యాపారవేత్త విక్రయాలను విశ్లేషించడం వరకు, సంఖ్యలు ఇమిడి ఉంటాయి. పెద్ద డేటాలో ఈ సంఖ్యలను లెక్కించేందుకు, మానవ మెదడు తక్కువ సమయంలో మానవీయంగా దీన్ని చేయడం చాలా సులభం కాదు, కాబట్టి ఈ ఫంక్షన్ కాలిక్యులేటర్ల ద్వారా నిర్వహించబడుతుంది. కాలిక్యులేటర్ అనేది గణిత శాస్త్ర కార్యకలాపాలను సరళమైన నుండి సంక్లిష్టమైన వరకు సమర్ధవంతంగా నిర్వహించడానికి ఉపయోగించే ఒక పోర్టబుల్ పరికరం మరియు ప్రాథమిక కార్యకలాపాలలో కూడిక, తీసివేత, గుణకారం మరియు భాగహారం ఉంటాయి.
C++లో ప్రాథమిక కాలిక్యులేటర్‌ను ఎలా నిర్మించాలి
ప్రాథమిక కాలిక్యులేటర్ కూడిక, తీసివేత, గుణకారం మరియు భాగహారం వంటి సాధారణ అంకగణిత కార్యకలాపాలను నిర్వహిస్తుంది. C++లో, కాలిక్యులేటర్‌ను రూపొందించడానికి స్విచ్ కేస్ స్టేట్‌మెంట్‌ను ఉపయోగించవచ్చు.
C++లో ప్రాథమిక కాలిక్యులేటర్
ఈ ప్రోగ్రామ్‌లో ఒక ప్రాథమిక కాలిక్యులేటర్ నిర్మించబడింది, ఇది సంఖ్యలను జోడించడం, తీసివేయడం, గుణించడం, విభజించడం, స్క్వేర్ మరియు వర్గమూలాలను తీసుకోవచ్చు:
#include
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
పూర్ణాంక ఎంపిక;
ఫ్లోట్ num1, num2, x;
కోట్ << 'మీ ఎంపికలను ఎంచుకోండి:'
' \n 1 = అదనంగా'
' \n 2 = వ్యవకలనం'
' \n 3 = గుణకారం'
' \n 4 = విభజన'
' \n 5 = చతురస్రాలు'
' \n 6 = వర్గమూలం'
' \n 7 = నిష్క్రమించు' << endl;
చేయండి {
// వినియోగదారు ఎంపిక తీసుకోవడం
కోట్ << ' \n మీ ఎంపికను నమోదు చేయండి: ' << endl;
ఆహారపు >> ఎంపిక;
మారండి ( ఎంపిక ) {
// అదనంగా
కేసు 1 : {
కోట్ << 'మొదటి ఆపరాండ్‌ని నమోదు చేయండి:' ;
ఆహారపు >> సంఖ్య1;
కోట్ << 'సెకండ్ ఆపరాండ్‌ని నమోదు చేయండి :' ;
ఆహారపు >> సంఖ్య2;
x = num1 + num2;
కోట్ << 'మొత్తం =' << x;
బ్రేక్ ;
}
// తీసివేత
కేసు 2 :
కోట్ << 'మొదటి ఆపరాండ్‌ని నమోదు చేయండి:' ;
ఆహారపు >> సంఖ్య1;
కోట్ << 'సెకండ్ ఆపరాండ్‌ని నమోదు చేయండి :' ;
ఆహారపు >> సంఖ్య2;
x = num1 - num2;
కోట్ << 'వ్యవకలనం =' << x;
బ్రేక్ ;
// గుణకారం
కేసు 3 :
కోట్ << 'మొదటి ఆపరాండ్‌ని నమోదు చేయండి:' ;
ఆహారపు >> సంఖ్య1;
కోట్ << 'సెకండ్ ఆపరాండ్‌ని నమోదు చేయండి :' ;
ఆహారపు >> సంఖ్య2;
x = సంఖ్య1 * సంఖ్య2;
కోట్ << 'ఉత్పత్తి =' << x;
బ్రేక్ ;
// విభజన
కేసు 4 :
కోట్ << 'డివిడెండ్ నమోదు చేయండి:' ;
ఆహారపు >> సంఖ్య1;
కోట్ << 'డివైజర్‌ని నమోదు చేయండి:' ;
ఆహారపు >> సంఖ్య2;
అయితే ( సంఖ్య2 == 0 )
{
కోట్ << ' \n డివైజర్ సున్నా కాకూడదు.'
' \n మరోసారి డివైజర్‌ని నమోదు చేయండి: ' ;
ఆహారపు >> సంఖ్య2;
}
x = సంఖ్య1 / సంఖ్య2;
కోట్ << ' \n కోషెంట్ = ' << x;
బ్రేక్ ;
// చతురస్రం
కేసు 5 :
కోట్ << 'సంఖ్యను నమోదు చేయండి: \n ' ;
ఆహారపు >> సంఖ్య1;
x = సంఖ్య1 * సంఖ్య1;
కోట్ << 'చదరపు' << సంఖ్య1 << ' = ' << x;
బ్రేక్ ;
కేసు 6 :
కోట్ << 'సంఖ్యను నమోదు చేయండి: \n ' ;
ఆహారపు >> సంఖ్య1;
x = చ ( సంఖ్య1 ) ;
కోట్ << 'స్క్వేర్ రూట్' << సంఖ్య1 << ' = ' << x;
బ్రేక్ ;
కేసు 7 :
తిరిగి 0 ;
డిఫాల్ట్: cout << ' \n లోపం! ఈ పరిధిలో ఎంపిక నిర్వచించబడలేదు' ;
}
}
అయితే ( ఎంపిక ! = 7 ) ;
తిరిగి 0 ;
}
వినియోగదారుకు 7 ఎంపికలు ఇవ్వబడ్డాయి, ఎంపిక 7 నిష్క్రమణ ఎంపికను ఇస్తుంది, మిగిలిన ఎంపికలు వేర్వేరు అంకగణిత కార్యకలాపాలను నిర్వహిస్తాయి. కూడిక, గుణకారం మరియు వ్యవకలనాన్ని నిర్వహించడానికి వినియోగదారు రెండు ఒపెరాండ్‌లను ఇన్‌పుట్ చేస్తారు, భాగహారం కోసం, వినియోగదారు డివిడెండ్ (ల్యూమరేటర్) మరియు భాగహారం (హారం) చొప్పిస్తారు.
డివైజర్ సున్నా లేదా సున్నా కాని సంఖ్యా కాదా అని తనిఖీ చేయడానికి కాసే లూప్ ఉపయోగించబడుతుంది, అది సున్నా అయితే, వినియోగదారు మరొక డివైజర్‌ను చొప్పించమని అడుగుతారు. విభజన సున్నా డివైజర్‌తో నిర్వహించబడదు కాబట్టి, అది నిర్వచించబడని విలువను అందిస్తుంది. స్క్వేర్ మరియు స్క్వేర్ రూట్‌లను తనిఖీ చేయడానికి వినియోగదారు తనకు నచ్చిన సంఖ్యను ఇన్‌పుట్ చేయవచ్చు. వినియోగదారు చేసిన ఎంపిక చెల్లనిది అయితే, అది తిరిగి వస్తుంది; మరియు ఏ ఆపరేషన్ నిర్వహించబడదు. ఎంపిక 7 ఎంచుకోబడే వరకు, సాఫ్ట్‌వేర్ రన్ అవుతూనే ఉంటుంది:
వినియోగదారు 1ని ఎంచుకుని, అదనంగా చేయడానికి రెండు ఆపరాండ్‌లను ఇన్‌పుట్ చేస్తారు, ప్రోగ్రామ్ రెండు సంఖ్యల మొత్తాన్ని అందిస్తుంది. వినియోగదారు 2ని ఎంచుకుని, రెండు ఆపరాండ్‌లను ఇన్‌పుట్ చేసినప్పుడు, రెండు సంఖ్యల తేడా తిరిగి వస్తుంది. ఎంపిక 3 వినియోగదారుని రెండు సంఖ్యలపై గుణకారం చేయడానికి అనుమతిస్తుంది. ఎంపిక 7 చేసినప్పుడు, వినియోగదారు ప్రోగ్రామ్ నుండి నిష్క్రమించాలి మరియు ఏదైనా కీని నొక్కినప్పుడు, కన్సోల్ విండో అదృశ్యమవుతుంది.
వినియోగదారు ఎంపిక 4ని ఎంచుకున్నప్పుడు, వినియోగదారు డివిడెండ్ మరియు డివైజర్‌ను ఇన్‌పుట్ చేయమని అడుగుతారు. డివైజర్ సున్నా అయినప్పుడు, విభజన నిర్వహించబడదు మరియు వినియోగదారు మరొక సున్నా కాని డివైజర్‌ను ఇన్‌పుట్ చేయాలి. డివైజర్ ఎక్కువగా ఉన్నందున, గుణకం పాయింట్‌లలో ఉంటుంది, అంటే, ఈ ప్రోగ్రామ్ ఫ్లోట్ విలువలను కూడా చదవగలదు మరియు తిరిగి ఇవ్వగలదు.
5 మరియు 6 ఎంపికలు వరుసగా ఇన్‌పుట్ సంఖ్య యొక్క వర్గ మరియు వర్గమూలాన్ని అందిస్తాయి. ఈ sqrt() ఫంక్షన్ cmath హెడర్ లైబ్రరీలో నిర్వచించబడింది. ఈ లైబ్రరీ నిర్వచించబడకపోతే, ఈ ఫంక్షన్ అమలు చేయబడదు.
ముగింపు
కాలిక్యులేటర్ అనేది అంకగణిత కార్యకలాపాలను నిర్వహించడానికి ఒక పరికరం. C++లో స్విచ్ కేస్ స్టేట్‌మెంట్‌ని నేరుగా కాలిక్యులేటర్‌ని రూపొందించడానికి ఉపయోగించవచ్చు. ఇక్కడ రూపొందించబడిన కాలిక్యులేటర్ కూడిక, తీసివేత, గుణకారం, వర్గము, వర్గమూలం మరియు సంఖ్యల విభజనతో సహా వివిధ అంకగణిత కార్యకలాపాలను నిర్వహించగలదు.