C++ భాష యొక్క ప్రారంభం 1983లో తిరిగి ఎప్పుడైతే జరిగింది 'బ్జారే స్ట్రౌస్ట్రప్' ఆపరేటర్ ఓవర్లోడింగ్ వంటి కొన్ని అదనపు ఫీచర్లతో సహా C భాషలోని తరగతులతో పని చేసింది. ఉపయోగించిన ఫైల్ పొడిగింపులు ‘.c’ మరియు ‘.cpp’. C++ అనేది విస్తరించదగినది మరియు ప్లాట్ఫారమ్పై ఆధారపడి ఉండదు మరియు స్టాండర్డ్ టెంప్లేట్ లైబ్రరీ యొక్క సంక్షిప్తీకరణ అయిన STLని కలిగి ఉంటుంది. కాబట్టి, ప్రాథమికంగా తెలిసిన C++ లాంగ్వేజ్ని నిజానికి కంపైల్డ్ లాంగ్వేజ్ అని పిలుస్తారు, ఇది ఆబ్జెక్ట్ ఫైల్లను రూపొందించడానికి సోర్స్ ఫైల్ను కలిపి కంపైల్ చేసి, లింకర్తో కలిపి రన్ చేయదగిన ప్రోగ్రామ్ను ఉత్పత్తి చేస్తుంది.
మరోవైపు, మేము దాని స్థాయి గురించి మాట్లాడినట్లయితే, ఇది డ్రైవర్లు లేదా కెర్నల్ల వంటి తక్కువ-స్థాయి ప్రోగ్రామింగ్ యొక్క ప్రయోజనాన్ని మరియు గేమ్లు, GUI లేదా డెస్క్టాప్ యాప్ల వంటి ఉన్నత-స్థాయి యాప్ల ప్రయోజనాన్ని మధ్య స్థాయికి వివరిస్తుంది. కానీ సింటాక్స్ C మరియు C++ రెండింటికీ దాదాపు ఒకే విధంగా ఉంటుంది.
C++ భాష యొక్క భాగాలు:
#include
ఈ కమాండ్ 'cout' కమాండ్తో కూడిన హెడర్ ఫైల్. వినియోగదారు అవసరాలు మరియు ప్రాధాన్యతలను బట్టి ఒకటి కంటే ఎక్కువ హెడర్ ఫైల్ ఉండవచ్చు.
int ప్రధాన()
ఈ స్టేట్మెంట్ మాస్టర్ ప్రోగ్రామ్ ఫంక్షన్, ఇది ప్రతి C++ ప్రోగ్రామ్కు అవసరమైనది, అంటే ఈ స్టేట్మెంట్ లేకుండా ఏ C++ ప్రోగ్రామ్ను అమలు చేయలేరు. ఇక్కడ 'int' అనేది ఫంక్షన్ తిరిగి ఇచ్చే డేటా రకం గురించి చెప్పే రిటర్న్ వేరియబుల్ డేటా రకం.
ప్రకటన:
వేరియబుల్స్ ప్రకటించబడ్డాయి మరియు వాటికి పేర్లు కేటాయించబడతాయి.
సమస్యల నివేదిక:
ప్రోగ్రామ్లో ఇది చాలా అవసరం మరియు ఇది 'వేళ' లూప్, 'ఫర్' లూప్ లేదా ఏదైనా ఇతర షరతు వర్తింపజేయవచ్చు.
ఆపరేటర్లు:
ఆపరేటర్లు C++ ప్రోగ్రామ్లలో ఉపయోగించబడతారు మరియు కొన్ని కీలకమైనవి ఎందుకంటే అవి షరతులకు వర్తించబడతాయి. కొన్ని ముఖ్యమైన ఆపరేటర్లు &&, ||, !, &, !=, |, &=, |=, ^, ^=.
C++ ఇన్పుట్ అవుట్పుట్:
ఇప్పుడు, మేము C++లో ఇన్పుట్ మరియు అవుట్పుట్ సామర్థ్యాలను చర్చిస్తాము. C++లో ఉపయోగించిన అన్ని ప్రామాణిక లైబ్రరీలు గరిష్ట ఇన్పుట్ మరియు అవుట్పుట్ సామర్థ్యాలను అందిస్తున్నాయి, ఇవి బైట్ల క్రమం రూపంలో ప్రదర్శించబడతాయి లేదా సాధారణంగా స్ట్రీమ్లకు సంబంధించినవి.
ఇన్పుట్ స్ట్రీమ్:
ఒకవేళ బైట్లు పరికరం నుండి ప్రధాన మెమరీకి ప్రసారం చేయబడితే, అది ఇన్పుట్ స్ట్రీమ్.
అవుట్పుట్ స్ట్రీమ్:
బైట్లు వ్యతిరేక దిశలో ప్రసారం చేయబడితే, అది అవుట్పుట్ స్ట్రీమ్.
C++లో ఇన్పుట్ మరియు అవుట్పుట్ను సులభతరం చేయడానికి హెడర్ ఫైల్ ఉపయోగించబడుతుంది. ఇది
ఉదాహరణ:
మేము అక్షర రకం స్ట్రింగ్ని ఉపయోగించి స్ట్రింగ్ సందేశాన్ని ప్రదర్శిస్తాము.
మొదటి లైన్లో, మేము C++ ప్రోగ్రామ్ని అమలు చేయడానికి అవసరమైన దాదాపు అన్ని అవసరమైన లైబ్రరీలను కలిగి ఉన్న 'iostream'ని చేర్చాము. తర్వాతి లైన్లో, ఐడెంటిఫైయర్ల కోసం స్కోప్ను అందించే నేమ్స్పేస్ను మేము ప్రకటిస్తున్నాము. ప్రధాన ఫంక్షన్కు కాల్ చేసిన తర్వాత, మేము స్ట్రింగ్ సందేశాన్ని నిల్వ చేసే అక్షర రకం శ్రేణిని ప్రారంభిస్తున్నాము మరియు 'కౌట్' దానిని సంగ్రహించడం ద్వారా ప్రదర్శిస్తుంది. స్క్రీన్పై వచనాన్ని ప్రదర్శించడానికి మేము 'కౌట్'ని ఉపయోగిస్తున్నాము. అలాగే, మేము అక్షరాల స్ట్రింగ్ను నిల్వ చేయడానికి అక్షర డేటా రకం శ్రేణిని కలిగి ఉన్న వేరియబుల్ 'A'ని తీసుకున్నాము మరియు ఆపై మేము 'cout' ఆదేశాన్ని ఉపయోగించి స్టాటిక్ సందేశంతో పాటు శ్రేణి సందేశం రెండింటినీ జోడించాము.
ఉత్పత్తి చేయబడిన అవుట్పుట్ క్రింద చూపబడింది:
ఉదాహరణ:
ఈ సందర్భంలో, మేము సాధారణ స్ట్రింగ్ సందేశంలో వినియోగదారు వయస్సుని సూచిస్తాము.
మొదటి దశలో మేము లైబ్రరీని కలుపుతున్నాము. ఆ తర్వాత, మేము ఐడెంటిఫైయర్ల కోసం స్కోప్ను అందించే నేమ్స్పేస్ని ఉపయోగిస్తున్నాము. తదుపరి దశలో, మేము కాల్ చేస్తున్నాము ప్రధాన () ఫంక్షన్. దీని తరువాత, మేము వయస్సును 'పూర్ణాంక' వేరియబుల్గా ప్రారంభిస్తున్నాము. మేము ఇన్పుట్ కోసం 'cin' కమాండ్ని మరియు సాధారణ స్ట్రింగ్ సందేశం యొక్క అవుట్పుట్ కోసం 'cout' కమాండ్ని ఉపయోగిస్తున్నాము. 'సిన్' వినియోగదారు నుండి వయస్సు విలువను ఇన్పుట్ చేస్తుంది మరియు 'కౌట్' దానిని ఇతర స్టాటిక్ సందేశంలో ప్రదర్శిస్తుంది.
ప్రోగ్రామ్ని అమలు చేసిన తర్వాత ఈ సందేశం స్క్రీన్పై చూపబడుతుంది, తద్వారా వినియోగదారు వయస్సును పొందవచ్చు మరియు ఆపై ENTER నొక్కండి.
ఉదాహరణ:
ఇక్కడ, 'కౌట్' ఉపయోగించడం ద్వారా స్ట్రింగ్ను ఎలా ప్రింట్ చేయాలో మేము ప్రదర్శిస్తాము.
స్ట్రింగ్ను ప్రింట్ చేయడానికి, మేము మొదట్లో లైబ్రరీని చేర్చుతాము, ఆపై ఐడెంటిఫైయర్ల కోసం నేమ్స్పేస్ను చేర్చుతాము. ది ప్రధాన () ఫంక్షన్ అంటారు. ఇంకా, మేము ఇన్సర్షన్ ఆపరేటర్తో 'cout' కమాండ్ని ఉపయోగించి స్ట్రింగ్ అవుట్పుట్ను ప్రింట్ చేస్తున్నాము, అది స్క్రీన్పై స్టాటిక్ సందేశాన్ని ప్రదర్శిస్తుంది.
C++ డేటా రకాలు:
C++లోని డేటా రకాలు చాలా ముఖ్యమైన మరియు విస్తృతంగా తెలిసిన అంశం ఎందుకంటే ఇది C++ ప్రోగ్రామింగ్ లాంగ్వేజ్కి ఆధారం. అదేవిధంగా, ఉపయోగించిన ఏదైనా వేరియబుల్ తప్పనిసరిగా పేర్కొన్న లేదా గుర్తించబడిన డేటా రకంగా ఉండాలి.
అన్ని వేరియబుల్స్ కోసం, పునరుద్ధరించాల్సిన డేటా రకాన్ని పరిమితం చేయడానికి మేము డిక్లరేషన్లో ఉన్నప్పుడు డేటా రకాన్ని ఉపయోగిస్తామని మాకు తెలుసు. లేదా, డేటా రకాలు ఎల్లప్పుడూ వేరియబుల్కు అది నిల్వ చేసే డేటా రకాన్ని తెలియజేస్తుందని మేము చెప్పగలం. మేము వేరియబుల్ని నిర్వచించిన ప్రతిసారీ, కంపైలర్ డిక్లేర్డ్ డేటా రకం ఆధారంగా మెమరీని కేటాయిస్తుంది, ఎందుకంటే ప్రతి డేటా రకం వేర్వేరు మెమరీ నిల్వ సామర్థ్యాన్ని కలిగి ఉంటుంది.
C++ భాష డేటా రకాల వైవిధ్యానికి సహాయం చేస్తుంది, తద్వారా ప్రోగ్రామర్ తనకు అవసరమైన తగిన డేటా రకాన్ని ఎంచుకోవచ్చు.
C++ క్రింద పేర్కొన్న డేటా రకాల వినియోగాన్ని సులభతరం చేస్తుంది:
- వినియోగదారు నిర్వచించిన డేటా రకాలు
- ఉత్పన్నమైన డేటా రకాలు
- అంతర్నిర్మిత డేటా రకాలు
ఉదాహరణకు, కొన్ని సాధారణ డేటా రకాలను ప్రారంభించడం ద్వారా డేటా రకాల ప్రాముఖ్యతను వివరించడానికి క్రింది పంక్తులు ఇవ్వబడ్డాయి:
int a = రెండు ; // పూర్ణాంక విలువతేలుతుంది F_N = 3.66 ; // ఫ్లోటింగ్ పాయింట్ విలువ
రెట్టింపు D_N = 8.87 ; // డబుల్ ఫ్లోటింగ్ పాయింట్ విలువ
చార్ ఆల్ఫా = 'p' ; // పాత్ర
బూల్ బి = నిజం ; // బూలియన్
కొన్ని సాధారణ డేటా రకాలు: అవి ఏ పరిమాణాన్ని పేర్కొంటాయి మరియు వాటి వేరియబుల్స్ ఏ రకమైన సమాచారాన్ని నిల్వ చేస్తాయో క్రింద చూపబడ్డాయి:
- చార్: ఒక బైట్ పరిమాణంతో, ఇది ఒకే అక్షరం, అక్షరం, సంఖ్య లేదా ASCII విలువలను నిల్వ చేస్తుంది.
- బూలియన్: 1 బైట్ పరిమాణంతో, ఇది నిజమైన లేదా తప్పుగా విలువలను నిల్వ చేస్తుంది మరియు అందిస్తుంది.
- Int: 2 లేదా 4 బైట్ల పరిమాణంతో, ఇది దశాంశం లేని పూర్ణ సంఖ్యలను నిల్వ చేస్తుంది.
- ఫ్లోటింగ్ పాయింట్: 4 బైట్ల పరిమాణంతో, ఇది ఒకటి లేదా అంతకంటే ఎక్కువ దశాంశాలను కలిగి ఉన్న పాక్షిక సంఖ్యలను నిల్వ చేస్తుంది. 7 దశాంశ అంకెల వరకు నిల్వ చేయడానికి ఇది సరిపోతుంది.
- డబుల్ ఫ్లోటింగ్ పాయింట్: 8 బైట్ల పరిమాణంతో, ఇది ఒకటి లేదా అంతకంటే ఎక్కువ దశాంశాలను కలిగి ఉన్న పాక్షిక సంఖ్యలను కూడా నిల్వ చేస్తుంది. 15 దశాంశ అంకెల వరకు నిల్వ చేయడానికి ఇది సరిపోతుంది.
- శూన్యం: నిర్దిష్ట పరిమాణం లేకుండా శూన్యం విలువలేనిదాన్ని కలిగి ఉంటుంది. కాబట్టి, ఇది శూన్య విలువను అందించే ఫంక్షన్ల కోసం ఉపయోగించబడుతుంది.
- విస్తృత అక్షరం: సాధారణంగా 2 లేదా 4 బైట్ల పొడవు ఉండే 8-బిట్ కంటే ఎక్కువ పరిమాణంలో ఉన్న wchar_t సూచించబడుతుంది, ఇది char లాగా ఉంటుంది మరియు తద్వారా అక్షర విలువను కూడా నిల్వ చేస్తుంది.
ప్రోగ్రామ్ లేదా కంపైలర్ వినియోగాన్ని బట్టి పైన పేర్కొన్న వేరియబుల్స్ పరిమాణం భిన్నంగా ఉండవచ్చు.
ఉదాహరణ:
పైన వివరించిన కొన్ని డేటా రకాల ఖచ్చితమైన పరిమాణాలను అందించే సాధారణ కోడ్ను C++లో వ్రాస్దాం:
ఈ కోడ్లో, మేము
చిత్రంలో చూపిన విధంగా అవుట్పుట్ బైట్లలో స్వీకరించబడింది:
ఉదాహరణ:
ఇక్కడ మేము రెండు వేర్వేరు డేటా రకాల పరిమాణాన్ని జోడిస్తాము.
ముందుగా, మేము ఐడెంటిఫైయర్ల కోసం 'ప్రామాణిక నేమ్స్పేస్'ని ఉపయోగించి హెడర్ ఫైల్ను చేర్చుతున్నాము. తదుపరి, ది ప్రధాన () ఫంక్షన్ అంటారు, దీనిలో మనం మొదట 'int' వేరియబుల్ని ప్రారంభించాము మరియు ఈ రెండింటి పరిమాణాల మధ్య వ్యత్యాసాన్ని తనిఖీ చేయడానికి 'డబుల్' వేరియబుల్ను ప్రారంభిస్తాము. అప్పుడు, వాటి పరిమాణాలు ఉపయోగించడం ద్వారా సంగ్రహించబడతాయి పరిమాణం () ఫంక్షన్. అవుట్పుట్ 'కౌట్' స్టేట్మెంట్ ద్వారా ప్రదర్శించబడుతుంది.
ఇక్కడ ప్రస్తావించాల్సిన మరో పదం ఉంది మరియు అది 'డేటా సవరణలు' . కంపైలర్ యొక్క ఆవశ్యకత లేదా ఆవశ్యకతను బట్టి నిర్దిష్ట డేటా రకం సమర్థించగలిగే వాటి పొడవులను సవరించడానికి అంతర్నిర్మిత డేటా రకాలతో పాటు 'డేటా మాడిఫైయర్లు' ఉపయోగించబడతాయని పేరు సూచిస్తుంది.
కిందివి C++లో యాక్సెస్ చేయగల డేటా మాడిఫైయర్లు:
- సంతకం చేశారు
- సంతకం చేయలేదు
- పొడవు
- పొట్టి
డేటా రకం మాడిఫైయర్లతో కలిపినప్పుడు, సవరించిన పరిమాణం మరియు అంతర్నిర్మిత డేటా రకాల యొక్క తగిన శ్రేణి కూడా క్రింద పేర్కొనబడింది:
- చిన్న పూర్ణం: 2 బైట్ల పరిమాణాన్ని కలిగి ఉండటం, -32,768 నుండి 32,767 వరకు మార్పుల శ్రేణిని కలిగి ఉంది
- సంతకం చేయని చిన్న పూర్ణాంక: 2 బైట్ల పరిమాణాన్ని కలిగి ఉండటం, 0 నుండి 65,535 వరకు మార్పుల పరిధిని కలిగి ఉంది
- సంతకం చేయని పూర్ణం: 4 బైట్ల పరిమాణాన్ని కలిగి ఉంది, 0 నుండి 4,294,967,295 వరకు మార్పుల పరిధిని కలిగి ఉంది
- Int: 4 బైట్ల పరిమాణాన్ని కలిగి ఉండటం, -2,147,483,648 నుండి 2,147,483,647 వరకు మార్పుల పరిధిని కలిగి ఉంది
- దీర్ఘ పూర్ణం: 4 బైట్ల పరిమాణాన్ని కలిగి ఉండటం, -2,147,483,648 నుండి 2,147,483,647 వరకు మార్పుల పరిధిని కలిగి ఉంది
- సంతకం చేయని పొడవైన పూర్ణాంకం: 4 బైట్ల పరిమాణాన్ని కలిగి ఉంది, 0 నుండి 4,294,967.295 వరకు మార్పుల పరిధిని కలిగి ఉంది
- పొడవైన పొడవాటి పూర్ణాంకం: 8 బైట్ల పరిమాణాన్ని కలిగి ఉండటం, –(2^63) నుండి (2^63)-1 వరకు మార్పుల శ్రేణిని కలిగి ఉంది
- సంతకం చేయని పొడవాటి పూర్ణాంకం: 8 బైట్ల పరిమాణం కలిగి, 0 నుండి 18,446,744,073,709,551,615 వరకు మార్పుల పరిధిని కలిగి ఉంది
- సంతకం చేసిన అక్షరం: 1 బైట్ పరిమాణం కలిగి, -128 నుండి 127 వరకు మార్పుల పరిధిని కలిగి ఉంది
- సంతకం చేయని అక్షరం: 1 బైట్ పరిమాణం కలిగి, 0 నుండి 255 వరకు మార్పుల పరిధిని కలిగి ఉంది.
C++ గణన:
C++ ప్రోగ్రామింగ్ భాషలో 'ఎన్యూమరేషన్' అనేది వినియోగదారు నిర్వచించిన డేటాటైప్. గణన 'గా ప్రకటించబడింది enum' C++లో. ప్రోగ్రామ్లో ఉపయోగించే ఏదైనా స్థిరాంకానికి నిర్దిష్ట పేర్లను కేటాయించడానికి ఇది ఉపయోగించబడుతుంది. ఇది ప్రోగ్రామ్ యొక్క రీడబిలిటీ మరియు వినియోగాన్ని మెరుగుపరుస్తుంది.
సింటాక్స్:
మేము ఈ క్రింది విధంగా C++లో గణనను ప్రకటిస్తాము:
enum enum_పేరు { స్థిరమైన 1 , స్థిరమైన 2 , స్థిరమైన 3… }C++లో గణన యొక్క ప్రయోజనాలు:
Enum క్రింది మార్గాల్లో ఉపయోగించవచ్చు:
- ఇది స్విచ్ కేస్ స్టేట్మెంట్లలో తరచుగా ఉపయోగించవచ్చు.
- ఇది కన్స్ట్రక్టర్లు, ఫీల్డ్లు మరియు పద్ధతులను ఉపయోగించవచ్చు.
- ఇది 'enum' తరగతిని మాత్రమే పొడిగించగలదు, ఏ ఇతర తరగతి కాదు.
- ఇది కంపైల్ సమయాన్ని పెంచవచ్చు.
- ఇది దాటవచ్చు.
C++లో గణన యొక్క ప్రతికూలతలు:
Enum కొన్ని ప్రతికూలతలు కూడా ఉన్నాయి:
పేరును ఒకసారి లెక్కించినట్లయితే, దానిని అదే పరిధిలో మళ్లీ ఉపయోగించలేరు.
ఉదాహరణకి:
enum రోజులు{ శని , సూర్యుడు , నా } ;
int శని = 8 ; // ఈ లైన్లో లోపం ఉంది
ఎనమ్ ఫార్వార్డ్ ప్రకటించబడదు.
ఉదాహరణకి:
enum ఆకారాలు ;తరగతి రంగు
{
శూన్యం డ్రా ( ఆకారాలు ) ; //ఆకారాలు ప్రకటించబడలేదు
} ;
అవి పేర్లలా కనిపిస్తున్నా అవి పూర్ణాంకాలు. కాబట్టి, వారు స్వయంచాలకంగా ఏదైనా ఇతర డేటాటైప్కి మార్చగలరు.
ఉదాహరణకి:
enum ఆకారాలు{
త్రిభుజం , వృత్తం , చతురస్రం
} ;
int రంగు = నీలం ;
రంగు = చతురస్రం ;
ఉదాహరణ:
ఈ ఉదాహరణలో, మేము C++ గణన యొక్క వినియోగాన్ని చూస్తాము:
ఈ కోడ్ అమలులో, ముందుగా మనం #include
అమలు చేయబడిన ప్రోగ్రామ్ యొక్క మా ఫలితం ఇక్కడ ఉంది:
కాబట్టి, మేము సబ్జెక్ట్ యొక్క విలువలను కలిగి ఉన్నామని మీరు చూడగలరు: గణితం, ఉర్దూ, ఇంగ్లీష్; అంటే 1,2,3.
ఉదాహరణ:
ఎనమ్ గురించి మన భావనలను క్లియర్ చేసే మరొక ఉదాహరణ ఇక్కడ ఉంది:
ఈ ప్రోగ్రామ్లో, మేము హెడర్ ఫైల్
మనం if-else స్టేట్మెంట్ని ఉపయోగించాలి . మేము 'if' స్టేట్మెంట్లోని కంపారిజన్ ఆపరేటర్ని కూడా ఉపయోగించాము అంటే 'bowler2' 'bowler1' కంటే ఎక్కువగా ఉంటే పోల్చి చూస్తున్నాము. అప్పుడు, ‘if’ బ్లాక్ ఎగ్జిక్యూట్ అవుతుంది అంటే అది ఆఫ్రిది ఓవర్ అని అర్థం. అప్పుడు, మేము అవుట్పుట్ను ప్రదర్శించడానికి 'cout<<'ని నమోదు చేసాము. మొదట, మేము 'ఇది ముగిసింది' అనే ప్రకటనను ముద్రిస్తాము. అప్పుడు, 'బౌలర్2' విలువ. కాకపోతే, else బ్లాక్ని ఆవాహన చేస్తారు, అంటే అది షాదాబ్ ఓవర్ అని అర్థం. అప్పుడు, 'cout<<' ఆదేశాన్ని వర్తింపజేయడం ద్వారా మనం 'It is over' అనే ప్రకటనను ప్రదర్శిస్తాము. అప్పుడు, 'బౌలర్1' విలువ.
If-else స్టేట్మెంట్ ప్రకారం, మా వద్ద అఫ్రిది విలువ 25 కంటే ఎక్కువ ఉంది. అంటే 'bowler2' enum వేరియబుల్ యొక్క విలువ 'bowler1' కంటే ఎక్కువగా ఉంటుంది, అందుకే 'if' స్టేట్మెంట్ అమలు చేయబడుతుంది.
C++ లేకపోతే, మారండి:
C ++ ప్రోగ్రామింగ్ లాంగ్వేజ్లో, ప్రోగ్రామ్ యొక్క ఫ్లోను సవరించడానికి మేము 'if స్టేట్మెంట్' మరియు 'స్విచ్ స్టేట్మెంట్'ని ఉపయోగిస్తాము. ఈ స్టేట్మెంట్లు వరుసగా పేర్కొన్న స్టేట్మెంట్ల యొక్క నిజమైన విలువను బట్టి ప్రోగ్రామ్ అమలు కోసం బహుళ సెట్ల ఆదేశాలను అందించడానికి ఉపయోగించబడతాయి. చాలా సందర్భాలలో, మేము 'if' స్టేట్మెంట్కు ప్రత్యామ్నాయంగా ఆపరేటర్లను ఉపయోగిస్తాము. ఈ పైన పేర్కొన్న స్టేట్మెంట్లన్నీ నిర్ణయాత్మక లేదా షరతులతో కూడిన స్టేట్మెంట్లుగా పిలువబడే ఎంపిక ప్రకటనలు.
'if' ప్రకటన:
ఏదైనా ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని మార్చాలని మీకు అనిపించినప్పుడు ఇచ్చిన స్థితిని పరీక్షించడానికి ఈ ప్రకటన ఉపయోగించబడుతుంది. ఇక్కడ, ఒక షరతు నిజమైతే, ప్రోగ్రామ్ వ్రాసిన సూచనలను అమలు చేస్తుంది కానీ షరతు తప్పు అయితే, అది కేవలం ముగుస్తుంది. ఒక ఉదాహరణను పరిశీలిద్దాం;
ఇది ఉపయోగించిన సాధారణ ‘if’ స్టేట్మెంట్, ఇక్కడ మనం ‘int’ వేరియబుల్ను 10గా ప్రారంభిస్తున్నాము. తర్వాత, వినియోగదారు నుండి విలువ తీసుకోబడుతుంది మరియు అది ‘if’ స్టేట్మెంట్లో క్రాస్-చెక్ చేయబడుతుంది. ఇది 'if' స్టేట్మెంట్లో వర్తించే షరతులను సంతృప్తిపరిచినట్లయితే, అవుట్పుట్ ప్రదర్శించబడుతుంది.
ఎంచుకున్న అంకె 40 కాబట్టి, అవుట్పుట్ సందేశం.
'అయితే' ప్రకటన:
'if' స్టేట్మెంట్ సాధారణంగా సహకరించని క్లిష్టమైన ప్రోగ్రామ్లో, మేము 'if-else' స్టేట్మెంట్ని ఉపయోగిస్తాము. ఇచ్చిన సందర్భంలో, వర్తించే షరతులను తనిఖీ చేయడానికి మేము 'if- else' స్టేట్మెంట్ని ఉపయోగిస్తున్నాము.
ముందుగా, వినియోగదారు నుండి విలువ తీసుకోబడిన 'x' అనే డేటాటైప్ 'int' యొక్క వేరియబుల్ని మేము ప్రకటిస్తాము. ఇప్పుడు, వినియోగదారు నమోదు చేసిన పూర్ణాంకం విలువ 2 అయితే, అవుట్పుట్ కావాల్సినది మరియు ఒక సాధారణ 'NICE TRY' సందేశం ప్రదర్శించబడుతుంది అనే షరతును మేము వర్తింపజేసినప్పుడు 'if' స్టేట్మెంట్ ఉపయోగించబడుతుంది. లేకపోతే, నమోదు చేసిన సంఖ్య 2 కాకపోతే, అవుట్పుట్ భిన్నంగా ఉంటుంది.
వినియోగదారు సంఖ్య 2ని వ్రాసినప్పుడు, కింది అవుట్పుట్ చూపబడుతుంది.
వినియోగదారు 2 తప్ప మరేదైనా సంఖ్యను వ్రాసినప్పుడు, మనకు లభించే అవుట్పుట్:
ఒకవేళ-లేకపోతే-ఇఫ్ స్టేట్మెంట్:
Nested if-else-if స్టేట్మెంట్లు చాలా క్లిష్టంగా ఉంటాయి మరియు ఒకే కోడ్లో అనేక షరతులు వర్తించినప్పుడు ఉపయోగించబడతాయి. మరొక ఉదాహరణను ఉపయోగించి దీని గురించి ఆలోచించండి:
ఇక్కడ, హెడర్ ఫైల్ మరియు నేమ్స్పేస్ను ఏకీకృతం చేసిన తర్వాత, మేము వేరియబుల్ 'm' విలువను 200గా ప్రారంభించాము. 'm' విలువ వినియోగదారు నుండి తీసుకోబడుతుంది మరియు ప్రోగ్రామ్లో పేర్కొన్న బహుళ షరతులతో క్రాస్-చెక్ చేయబడుతుంది.
ఇక్కడ, వినియోగదారు 195 విలువను ఎంచుకున్నారు. అందుకే ఇది 'm' యొక్క వాస్తవ విలువ అని అవుట్పుట్ చూపిస్తుంది.
ప్రకటన మారండి:
ఒక వేరియబుల్ కోసం C++లో ‘స్విచ్’ స్టేట్మెంట్ ఉపయోగించబడుతుంది, అది బహుళ విలువల జాబితాకు సమానంగా ఉంటే పరీక్షించాల్సిన అవసరం ఉంది. 'స్విచ్' స్టేట్మెంట్లో, మేము విభిన్న కేసుల రూపంలో పరిస్థితులను గుర్తిస్తాము మరియు ప్రతి కేసు స్టేట్మెంట్ చివరిలో అన్ని కేసులకు విరామం ఉంటుంది. అనేక సందర్భాల్లో సరైన షరతులు మరియు స్టేట్మెంట్లు వాటికి వర్తింపజేయబడతాయి, ఇవి స్విచ్ స్టేట్మెంట్ను ముగించాయి మరియు షరతుకు మద్దతు ఇవ్వని పక్షంలో డిఫాల్ట్ స్టేట్మెంట్కు తరలించబడతాయి.
కీవర్డ్ 'బ్రేక్':
స్విచ్ స్టేట్మెంట్లో 'బ్రేక్' అనే కీవర్డ్ ఉంది. ఇది తదుపరి సందర్భంలో అమలు చేయకుండా కోడ్ను ఆపివేస్తుంది. C++ కంపైలర్ 'బ్రేక్' కీవర్డ్లో వచ్చినప్పుడు స్విచ్ స్టేట్మెంట్ అమలు ముగుస్తుంది మరియు నియంత్రణ స్విచ్ స్టేట్మెంట్ను అనుసరించే లైన్కు కదులుతుంది. స్విచ్లో బ్రేక్ స్టేట్మెంట్ను ఉపయోగించాల్సిన అవసరం లేదు. అది ఉపయోగించబడకపోతే అమలు తదుపరి కేసుకు వెళుతుంది.
షేర్ చేసిన కోడ్లోని మొదటి లైన్లో, మేము లైబ్రరీని చేర్చాము. దాని తర్వాత, మేము 'నేమ్స్పేస్'ని జోడిస్తున్నాము. మేము ఆవాహన చేస్తాము ప్రధాన () ఫంక్షన్. అప్పుడు, మేము అక్షర డేటాటైప్ గ్రేడ్ను ‘F’గా ప్రకటిస్తున్నాము. ఈ గ్రేడ్ మీ కోరిక కావచ్చు మరియు ఎంచుకున్న కేసులకు వరుసగా ఫలితం చూపబడుతుంది. మేము ఫలితాన్ని పొందడానికి స్విచ్ స్టేట్మెంట్ను వర్తింపజేసాము.
మనం ‘F’ని గ్రేడ్గా ఎంచుకుంటే, అవుట్పుట్ ‘బెటర్ లక్ నెక్స్ట్ టైమ్’ ఎందుకంటే గ్రేడ్ ‘F’ అయితే ప్రింట్ చేయాలనుకుంటున్నాము.
గ్రేడ్ని Xకి మారుద్దాం మరియు ఏమి జరుగుతుందో చూద్దాం. నేను 'X'ని గ్రేడ్గా వ్రాసాను మరియు అందుకున్న అవుట్పుట్ క్రింద చూపబడింది:
కాబట్టి, 'స్విచ్'లోని సరికాని కేస్ స్వయంచాలకంగా పాయింటర్ను నేరుగా డిఫాల్ట్ స్టేట్మెంట్కి తరలించి ప్రోగ్రామ్ను ముగించింది.
if-else మరియు స్విచ్ స్టేట్మెంట్లు కొన్ని సాధారణ లక్షణాలను కలిగి ఉన్నాయి:
- ప్రోగ్రామ్ ఎలా అమలు చేయబడుతుందో నిర్వహించడానికి ఈ ప్రకటనలు ఉపయోగించబడతాయి.
- వారిద్దరూ ఒక పరిస్థితిని అంచనా వేస్తారు మరియు ప్రోగ్రామ్ ఎలా ప్రవహిస్తుందో అది నిర్ణయిస్తుంది.
- విభిన్న ప్రాతినిధ్య శైలులు ఉన్నప్పటికీ, వాటిని ఒకే ప్రయోజనం కోసం ఉపయోగించవచ్చు.
if-else మరియు స్విచ్ స్టేట్మెంట్లు కొన్ని మార్గాల్లో విభిన్నంగా ఉంటాయి:
- వినియోగదారు 'స్విచ్' కేస్ స్టేట్మెంట్లలో విలువలను నిర్వచించినప్పుడు, పరిమితులు 'if-else' స్టేట్మెంట్లలో విలువలను నిర్ణయిస్తాయి.
- మార్పు ఎక్కడ జరగాలో నిర్ణయించడానికి సమయం పడుతుంది, 'if-else' స్టేట్మెంట్లను సవరించడం సవాలుగా ఉంది. మరోవైపు, 'స్విచ్' స్టేట్మెంట్లను అప్డేట్ చేయడం చాలా సులభం ఎందుకంటే వాటిని సులభంగా సవరించవచ్చు.
- అనేక వ్యక్తీకరణలను చేర్చడానికి, మేము అనేక 'if-else' స్టేట్మెంట్లను ఉపయోగించవచ్చు.
C++ లూప్లు:
ఇప్పుడు, C++ ప్రోగ్రామింగ్లో లూప్లను ఎలా ఉపయోగించాలో మేము కనుగొంటాము. 'లూప్' అని పిలువబడే నియంత్రణ నిర్మాణం స్టేట్మెంట్ల శ్రేణిని పునరావృతం చేస్తుంది. మరో మాటలో చెప్పాలంటే, దీనిని పునరావృత నిర్మాణం అంటారు. అన్ని స్టేట్మెంట్లు సీక్వెన్షియల్ స్ట్రక్చర్లో ఒకేసారి అమలు చేయబడతాయి . మరోవైపు, పేర్కొన్న స్టేట్మెంట్పై ఆధారపడి, కండిషన్ స్ట్రక్చర్ ఎక్స్ప్రెషన్ను అమలు చేయవచ్చు లేదా వదిలివేయవచ్చు. నిర్దిష్ట పరిస్థితుల్లో ఒకటి కంటే ఎక్కువ సార్లు ప్రకటనను అమలు చేయడం అవసరం కావచ్చు.
లూప్ రకాలు:
లూప్లలో మూడు వర్గాలు ఉన్నాయి:
లూప్ కోసం:
లూప్ అనేది ఒక సైకిల్ లాగా పునరావృతమవుతుంది మరియు అందించిన షరతును ధృవీకరించనప్పుడు ఆగిపోతుంది. 'ఫర్' లూప్ అనేక సార్లు స్టేట్మెంట్ల క్రమాన్ని అమలు చేస్తుంది మరియు లూప్ వేరియబుల్తో వ్యవహరించే కోడ్ను ఘనీభవిస్తుంది. 'ఫర్' లూప్ అనేది ఒక నిర్దిష్ట రకమైన పునరుక్తి నియంత్రణ నిర్మాణం అని ఇది చూపుతుంది, ఇది నిర్ణీత సంఖ్యలో పునరావృతమయ్యే లూప్ను సృష్టించడానికి అనుమతిస్తుంది. లూప్ ఒక సాధారణ లైన్ కోడ్ని ఉపయోగించడం ద్వారా 'N' దశల సంఖ్యను అమలు చేయడానికి అనుమతిస్తుంది. మీ సాఫ్ట్వేర్ అప్లికేషన్లో అమలు చేయడానికి 'ఫర్' లూప్ కోసం మనం ఉపయోగించే సింటాక్స్ గురించి మాట్లాడుకుందాం.
'ఫర్' లూప్ ఎగ్జిక్యూషన్ యొక్క సింటాక్స్:
ఉదాహరణ:
ఇక్కడ, మేము ఈ లూప్ను 'ఫర్' లూప్లో నియంత్రించడానికి లూప్ వేరియబుల్ని ఉపయోగిస్తాము. మేము లూప్గా పేర్కొన్న ఈ వేరియబుల్కు విలువను కేటాయించడం మొదటి దశ. ఆ తర్వాత, అది కౌంటర్ విలువ కంటే తక్కువ లేదా ఎక్కువ అని మనం నిర్వచించాలి. ఇప్పుడు, లూప్ యొక్క బాడీ అమలు చేయబడాలి మరియు స్టేట్మెంట్ నిజమని తిరిగి వచ్చినప్పుడు లూప్ వేరియబుల్ కూడా నవీకరించబడుతుంది. మేము నిష్క్రమణ స్థితికి చేరుకునే వరకు పై దశలు తరచుగా పునరావృతమవుతాయి.
- ప్రారంభ వ్యక్తీకరణ: మొదట, మేము ఈ వ్యక్తీకరణలో ఏదైనా ప్రారంభ విలువకు లూప్ కౌంటర్ని సెట్ చేయాలి.
- పరీక్ష వ్యక్తీకరణ : ఇప్పుడు, మేము ఇచ్చిన వ్యక్తీకరణలో ఇచ్చిన పరిస్థితిని పరీక్షించాలి. ప్రమాణాలు నెరవేరినట్లయితే, మేము 'ఫర్' లూప్ బాడీని అమలు చేస్తాము మరియు వ్యక్తీకరణను నవీకరించడాన్ని కొనసాగిస్తాము; లేకపోతే, మనం ఆపాలి.
- వ్యక్తీకరణను నవీకరించండి: ఈ వ్యక్తీకరణ లూప్ యొక్క బాడీని అమలు చేసిన తర్వాత నిర్దిష్ట విలువతో లూప్ వేరియబుల్ను పెంచుతుంది లేదా తగ్గిస్తుంది.
'For' లూప్ని ధృవీకరించడానికి C++ ప్రోగ్రామ్ ఉదాహరణలు:
ఉదాహరణ:
ఈ ఉదాహరణ 0 నుండి 10 వరకు పూర్ణాంక విలువల ముద్రణను చూపుతుంది.
ఈ దృష్టాంతంలో, మేము పూర్ణాంకాలను 0 నుండి 10 వరకు ముద్రించవలసి ఉంటుంది. ముందుగా, మేము యాదృచ్ఛిక వేరియబుల్ iని '0'తో ప్రారంభించాము, ఆపై మేము ఇప్పటికే ఉపయోగించిన కండిషన్ పరామితి i<=10 అయితే పరిస్థితిని తనిఖీ చేస్తుంది. మరియు అది షరతును సంతృప్తిపరిచినప్పుడు మరియు అది నిజం అయినప్పుడు, 'ఫర్' లూప్ యొక్క అమలు ప్రారంభమవుతుంది. అమలు చేసిన తర్వాత, రెండు ఇంక్రిమెంట్ లేదా డిక్రిమెంట్ పారామితులలో, ఒకటి అమలు చేయబడుతుంది మరియు దీనిలో పేర్కొన్న షరతు i<=10 తప్పుగా మారే వరకు, వేరియబుల్ i విలువ పెరుగుతుంది.
i<10 షరతుతో పునరావృతాల సంఖ్య:
సంఖ్య పునరావృత్తులు |
వేరియబుల్స్ | i<10 | చర్య |
ప్రధమ | i=0 | నిజం | 0 ప్రదర్శించబడుతుంది మరియు i 1 ద్వారా పెంచబడింది. |
రెండవ | i=1 | నిజం | 1 ప్రదర్శించబడుతుంది మరియు i 2 ద్వారా పెంచబడింది. |
మూడవది | i=2 | నిజం | 2 ప్రదర్శించబడుతుంది మరియు i 3 ద్వారా పెంచబడింది. |
నాల్గవది | i=3 | నిజం | 3 ప్రదర్శించబడుతుంది మరియు i 4 ద్వారా పెంచబడింది. |
ఐదవది | i=4 | నిజం | 4 ప్రదర్శించబడుతుంది మరియు i 5తో పెంచబడింది. |
ఆరవది | i=5 | నిజం | 5 ప్రదర్శించబడుతుంది మరియు i 6తో పెంచబడింది. |
ఏడవ | i=6 | నిజం | 6 ప్రదర్శించబడుతుంది మరియు i 7తో పెంచబడింది. |
ఎనిమిదవది | i=7 | నిజం | 7 ప్రదర్శించబడుతుంది మరియు i 8 ద్వారా పెంచబడింది |
తొమ్మిదవ | i=8 | నిజం | 8 ప్రదర్శించబడుతుంది మరియు i 9తో పెంచబడింది. |
పదవ | i=9 | నిజం | 9 ప్రదర్శించబడుతుంది మరియు i 10కి పెంచబడింది. |
పదకొండవ | i=10 | నిజం | 10 ప్రదర్శించబడుతుంది మరియు i 11 ద్వారా పెంచబడింది. |
పన్నెండవది | i=11 | తప్పుడు | లూప్ ముగిసింది. |
ఉదాహరణ:
కింది ఉదాహరణ పూర్ణాంకం యొక్క విలువను ప్రదర్శిస్తుంది:
పై సందర్భంలో, 'a' అనే వేరియబుల్ 50 ఇచ్చిన విలువతో ప్రారంభించబడుతుంది. 'a' వేరియబుల్ 70 కంటే తక్కువ ఉన్న చోట షరతు వర్తించబడుతుంది. తర్వాత, 'a' విలువ జోడించబడే విధంగా నవీకరించబడుతుంది. 2. 'a' విలువ 50 ఉన్న ప్రారంభ విలువ నుండి ప్రారంభించబడుతుంది మరియు 2 షరతు తప్పుగా తిరిగి వచ్చే వరకు లూప్ అంతటా ఏకకాలంలో జోడించబడుతుంది మరియు 'a' విలువ 70 నుండి పెంచబడుతుంది మరియు లూప్ ముగిసే వరకు.
పునరావృతాల సంఖ్య:
సంఖ్య మరల |
వేరియబుల్ | a=50 | చర్య |
ప్రధమ | a=50 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 50 52 అవుతుంది |
రెండవ | a=52 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 52 54 అవుతుంది |
మూడవది | a=54 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 54 56 అవుతుంది |
నాల్గవది | a=56 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 56 58 అవుతుంది |
ఐదవది | a=58 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 58 60 అవుతుంది |
ఆరవది | a=60 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 60 62 అవుతుంది |
ఏడవ | a=62 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 62 64 అవుతుంది |
ఎనిమిదవది | a=64 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 64 66 అవుతుంది |
తొమ్మిదవ | a=66 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 66 68 అవుతుంది |
పదవ | a=68 | నిజం | మరో రెండు పూర్ణాంకాలను జోడించడం ద్వారా a విలువ నవీకరించబడుతుంది మరియు 68 70 అవుతుంది |
పదకొండవ | a=70 | తప్పుడు | లూప్ ముగిసింది |
లూప్ అయితే:
నిర్వచించిన షరతు సంతృప్తి చెందే వరకు, ఒకటి లేదా అంతకంటే ఎక్కువ స్టేట్మెంట్లు అమలు చేయబడవచ్చు. పునరావృతం ముందుగానే తెలియనప్పుడు, ఇది చాలా ఉపయోగకరంగా ఉంటుంది. మొదట, పరిస్థితి తనిఖీ చేయబడుతుంది మరియు ప్రకటనను అమలు చేయడానికి లేదా అమలు చేయడానికి లూప్ యొక్క శరీరంలోకి ప్రవేశిస్తుంది.
మొదటి పంక్తిలో, మేము హెడర్ ఫైల్
డూ-వేల్ లూప్:
నిర్వచించిన షరతు సంతృప్తి చెందినప్పుడు, వరుస ప్రకటనలు నిర్వహించబడతాయి. మొదట, లూప్ యొక్క శరీరం నిర్వహించబడుతుంది. ఆ తర్వాత పరిస్థితి నిజమా కాదా అని తనిఖీ చేస్తారు. అందువల్ల, ప్రకటన ఒకసారి అమలు చేయబడుతుంది. పరిస్థితిని మూల్యాంకనం చేయడానికి ముందు లూప్ యొక్క శరీరం 'డూ-వైల్' లూప్లో ప్రాసెస్ చేయబడుతుంది. అవసరమైన పరిస్థితి సంతృప్తి చెందినప్పుడు ప్రోగ్రామ్ నడుస్తుంది. లేకపోతే, షరతు తప్పు అయినప్పుడు, ప్రోగ్రామ్ ముగుస్తుంది.
ఇక్కడ, మేము హెడర్ ఫైల్
C++ కొనసాగించు/విరామం:
C++ ప్రకటన కొనసాగించు:
లూప్ యొక్క ప్రస్తుత అవతారాన్ని నివారించడానికి అలాగే తదుపరి పునరావృతానికి నియంత్రణను తరలించడానికి C++ ప్రోగ్రామింగ్ భాషలో కొనసాగింపు ప్రకటన ఉపయోగించబడుతుంది. లూపింగ్ సమయంలో, కొన్ని స్టేట్మెంట్లను దాటవేయడానికి కొనసాగింపు స్టేట్మెంట్ను ఉపయోగించవచ్చు. ఇది ఎగ్జిక్యూటివ్ స్టేట్మెంట్లతో కలిపి లూప్లో కూడా ఉపయోగించబడుతుంది. నిర్దిష్ట షరతు నిజమైతే, కొనసాగింపు ప్రకటన తర్వాత అన్ని స్టేట్మెంట్లు అమలు చేయబడవు.
లూప్ కోసం:
ఈ సందర్భంలో, మేము కొన్ని పేర్కొన్న అవసరాలను దాటినప్పుడు అవసరమైన ఫలితాన్ని పొందడానికి C++ నుండి కొనసాగింపు స్టేట్మెంట్తో 'ఫర్ లూప్'ని ఉపయోగిస్తాము.
మేము
కాసేపు లూప్తో:
ఈ ప్రదర్శన అంతటా, మేము 'while loop' మరియు C++ 'continue' స్టేట్మెంట్ రెండింటినీ ఉపయోగించాము, వీటిలో ఏ విధమైన అవుట్పుట్ ఉత్పత్తి చేయబడుతుందో చూడడానికి కొన్ని షరతులు ఉన్నాయి.
ఈ ఉదాహరణలో, మేము సంఖ్యలను 40కి మాత్రమే జోడించడానికి షరతును సెట్ చేసాము. నమోదు చేసిన పూర్ణాంకం ప్రతికూల సంఖ్య అయితే, 'while' లూప్ రద్దు చేయబడుతుంది. మరోవైపు, సంఖ్య 40 కంటే ఎక్కువ ఉంటే, ఆ నిర్దిష్ట సంఖ్య పునరావృతం నుండి దాటవేయబడుతుంది.
మేము
C++ బ్రేక్ స్టేట్మెంట్:
C++లో లూప్లో బ్రేక్ స్టేట్మెంట్ ఉపయోగించబడినప్పుడల్లా, లూప్ తక్షణమే ముగుస్తుంది అలాగే లూప్ తర్వాత స్టేట్మెంట్లో ప్రోగ్రామ్ కంట్రోల్ రీస్టార్ట్ అవుతుంది. 'స్విచ్' స్టేట్మెంట్ లోపల కేసును ముగించడం కూడా సాధ్యమే.
లూప్ కోసం:
ఇక్కడ, విభిన్న విలువలపై పునరావృతం చేయడం ద్వారా అవుట్పుట్ను గమనించడానికి మనం 'బ్రేక్' స్టేట్మెంట్తో 'ఫర్' లూప్ను ఉపయోగిస్తాము.
ముందుగా, మేము
కాసేపు లూప్తో:
మేము బ్రేక్ స్టేట్మెంట్తో పాటు 'వైల్' లూప్ను ఉపయోగించబోతున్నాము.
మేము
C++ విధులు:
ఇప్పటికే తెలిసిన ప్రోగ్రామ్ను అనేక కోడ్ల శకలాలుగా రూపొందించడానికి విధులు ఉపయోగించబడతాయి, అవి పిలిచినప్పుడు మాత్రమే అమలు చేయబడతాయి. C++ ప్రోగ్రామింగ్ లాంగ్వేజ్లో, ఒక ఫంక్షన్ అనేది స్టేట్మెంట్ల సమూహంగా నిర్వచించబడింది, దానికి తగిన పేరు ఇవ్వబడుతుంది మరియు వాటి ద్వారా పిలవబడుతుంది. మేము పారామితులు అని పిలుస్తున్న ఫంక్షన్లకు వినియోగదారు డేటాను పాస్ చేయవచ్చు. కోడ్ని ఎక్కువగా ఉపయోగించినప్పుడు చర్యలను అమలు చేయడానికి విధులు బాధ్యత వహిస్తాయి.
ఒక ఫంక్షన్ యొక్క సృష్టి:
C++ వంటి అనేక ముందే నిర్వచించబడిన ఫంక్షన్లను అందిస్తుంది ప్రధాన (), ఇది కోడ్ అమలును సులభతరం చేస్తుంది. అదే విధంగా, మీరు మీ అవసరాలకు అనుగుణంగా మీ ఫంక్షన్లను సృష్టించవచ్చు మరియు నిర్వచించవచ్చు. అన్ని సాధారణ ఫంక్షన్ల మాదిరిగానే, ఇక్కడ కూడా, '()' తర్వాత కుండలీకరణంతో జోడించబడిన డిక్లరేషన్ కోసం మీ ఫంక్షన్కి పేరు అవసరం.
సింటాక్స్:
శూన్య శ్రమ ( ){
// ఫంక్షన్ యొక్క శరీరం
}
శూన్యం అనేది ఫంక్షన్ యొక్క రిటర్న్ రకం. లేబర్ అనేది దీనికి ఇవ్వబడిన పేరు మరియు కర్లీ బ్రాకెట్లు ఫంక్షన్ యొక్క బాడీని చుట్టుముట్టాయి, ఇక్కడ మేము అమలు కోసం కోడ్ను జోడిస్తాము.
ఫంక్షన్కి కాల్ చేస్తోంది:
కోడ్లో డిక్లేర్ చేయబడిన ఫంక్షన్లు అమలు చేయబడినప్పుడు మాత్రమే అమలు చేయబడతాయి. ఫంక్షన్కి కాల్ చేయడానికి, మీరు కుండలీకరణంతో పాటు ఫంక్షన్ పేరును పేర్కొనాలి, దాని తర్వాత సెమికోలన్ ‘;’ ఉంటుంది.
ఉదాహరణ:
ఈ పరిస్థితిలో వినియోగదారు-నిర్వచించిన ఫంక్షన్ను ప్రకటించి, నిర్మిస్తాము.
ప్రారంభంలో, ప్రతి ప్రోగ్రామ్లో వివరించినట్లుగా, ప్రోగ్రామ్ యొక్క అమలుకు మద్దతు ఇవ్వడానికి మాకు లైబ్రరీ మరియు నేమ్స్పేస్ కేటాయించబడతాయి. వినియోగదారు నిర్వచించిన ఫంక్షన్ శ్రమ() వ్రాసే ముందు ఎల్లప్పుడూ అంటారు ప్రధాన () ఫంక్షన్. అనే ఫంక్షన్ శ్రమ() ఒక కార్మికుడు గౌరవానికి అర్హుడు!’ అనే సందేశం ప్రదర్శించబడిన చోట ప్రకటించబడింది. లో ప్రధాన () పూర్ణాంక రిటర్న్ రకంతో ఫంక్షన్, మేము కాల్ చేస్తున్నాము శ్రమ() ఫంక్షన్.
దీని సహాయంతో ఇక్కడ ప్రదర్శించబడే వినియోగదారు నిర్వచించిన ఫంక్షన్లో నిర్వచించబడిన సాధారణ సందేశం ఇది ప్రధాన () ఫంక్షన్.
శూన్యం:
పైన పేర్కొన్న సందర్భంలో, వినియోగదారు నిర్వచించిన ఫంక్షన్ యొక్క రిటర్న్ రకం శూన్యంగా ఉందని మేము గమనించాము. ఫంక్షన్ ద్వారా విలువ ఏదీ తిరిగి ఇవ్వబడదని ఇది సూచిస్తుంది. విలువ ప్రస్తుతం లేదని లేదా బహుశా శూన్యమని ఇది సూచిస్తుంది. ఎందుకంటే ఒక ఫంక్షన్ కేవలం సందేశాలను ముద్రించినప్పుడల్లా, దానికి ఎలాంటి రిటర్న్ విలువ అవసరం లేదు.
ఈ శూన్యత అదే విధంగా ఫంక్షన్ యొక్క పారామీటర్ స్థలంలో ఉపయోగించబడుతుంది, ఈ ఫంక్షన్ కాల్ చేయబడినప్పుడు అసలు విలువను తీసుకోదు. పై పరిస్థితిలో, మేము కూడా కాల్ చేస్తాము శ్రమ() ఫంక్షన్:
శూన్య శ్రమ ( శూన్యం ){
కౌట్ << 'ఒక కార్మికుడు గౌరవానికి అర్హుడు ! ” ;
}
వాస్తవ పారామితులు:
ఫంక్షన్ కోసం పారామితులను నిర్వచించవచ్చు. ఫంక్షన్ యొక్క పారామితులు ఫంక్షన్ పేరుకు జోడించే ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్ జాబితాలో నిర్వచించబడ్డాయి. మేము ఫంక్షన్ని పిలిచినప్పుడల్లా, అమలును పూర్తి చేయడానికి పారామితుల యొక్క నిజమైన విలువలను పాస్ చేయాలి. ఇవి వాస్తవ పారామితులుగా ముగించబడ్డాయి. అయితే ఫంక్షన్ నిర్వచించబడినప్పుడు నిర్వచించబడిన పారామీటర్లను ఫార్మల్ పారామీటర్లు అంటారు.
ఉదాహరణ:
ఈ ఉదాహరణలో, మేము ఫంక్షన్ ద్వారా రెండు పూర్ణాంకాల విలువలను మార్పిడి లేదా ప్రత్యామ్నాయం చేయబోతున్నాము.
ప్రారంభంలో, మేము హెడర్ ఫైల్ను తీసుకుంటున్నాము. వినియోగదారు నిర్వచించిన ఫంక్షన్ డిక్లేర్డ్ మరియు నిర్వచించబడిన పేరు ఉప(). ఈ ఫంక్షన్ i మరియు n అనే రెండు పూర్ణాంకాల విలువల ప్రత్యామ్నాయం కోసం ఉపయోగించబడుతుంది. తరువాత, ఈ రెండు పూర్ణాంకాల మార్పిడికి అంకగణిత ఆపరేటర్లు ఉపయోగించబడతాయి. మొదటి పూర్ణాంకం 'i' విలువ 'n' విలువ స్థానంలో నిల్వ చేయబడుతుంది మరియు n విలువ 'i' విలువ స్థానంలో సేవ్ చేయబడుతుంది. అప్పుడు, విలువలను మార్చిన తర్వాత ఫలితం ముద్రించబడుతుంది. మేము గురించి మాట్లాడినట్లయితే ప్రధాన () ఫంక్షన్, మేము వినియోగదారు నుండి రెండు పూర్ణాంకాల విలువలను తీసుకుంటాము మరియు ప్రదర్శించబడతాము. చివరి దశలో, వినియోగదారు నిర్వచించిన ఫంక్షన్ ఉప() అని పిలుస్తారు మరియు రెండు విలువలు పరస్పరం మార్చబడతాయి.
ఈ రెండు సంఖ్యలను ప్రత్యామ్నాయం చేసే సందర్భంలో, ఉపయోగించేటప్పుడు మనం స్పష్టంగా చూడవచ్చు ఉప() ఫంక్షన్, పరామితి జాబితాలోని 'i' మరియు 'n' విలువలు అధికారిక పారామితులు. అసలు పారామితులు అనేది ముగింపులో ఉన్న పరామితి ప్రధాన () ప్రతిక్షేపణ ఫంక్షన్ అని పిలువబడే ఫంక్షన్.
C++ పాయింటర్లు:
C++లోని పాయింటర్ నేర్చుకోవడం చాలా సులభం మరియు ఉపయోగించడానికి గొప్పది. C++ భాషలో పాయింటర్లు ఉపయోగించబడతాయి ఎందుకంటే అవి మా పనిని సులభతరం చేస్తాయి మరియు పాయింటర్లు ప్రమేయం ఉన్నప్పుడు అన్ని కార్యకలాపాలు గొప్ప సామర్థ్యంతో పని చేస్తాయి. అలాగే, డైనమిక్ మెమరీ కేటాయింపు వంటి పాయింటర్లను ఉపయోగించకపోతే కొన్ని పనులు పూర్తి కావు. పాయింటర్ల గురించి మాట్లాడేటప్పుడు, ప్రధాన ఆలోచన ఏమిటంటే, పాయింటర్ అనేది కేవలం ఒక వేరియబుల్, అది ఖచ్చితమైన మెమరీ చిరునామాను దాని విలువగా నిల్వ చేస్తుంది. C++లో పాయింటర్ల విస్తృత ఉపయోగం కింది కారణాల వల్ల:
- ఒక ఫంక్షన్ను మరొకదానికి పంపడానికి.
- కుప్పపై కొత్త వస్తువులను కేటాయించడానికి.
- శ్రేణిలోని మూలకాల పునరావృతం కోసం
సాధారణంగా, మెమరీలోని ఏదైనా వస్తువు యొక్క చిరునామాను యాక్సెస్ చేయడానికి ‘&’ (యాంపర్సండ్) ఆపరేటర్ ఉపయోగించబడుతుంది.
పాయింటర్లు మరియు వాటి రకాలు:
పాయింటర్ క్రింది అనేక రకాలను కలిగి ఉంది:
- శూన్య సూచికలు: ఇవి C++ లైబ్రరీలలో నిల్వ చేయబడిన సున్నా విలువ కలిగిన పాయింటర్లు.
- అంకగణిత పాయింటర్: ఇది యాక్సెస్ చేయగల నాలుగు ప్రధాన అంకగణిత ఆపరేటర్లను కలిగి ఉంటుంది, అవి ++, –, +, -.
- పాయింటర్ల శ్రేణి: అవి కొన్ని పాయింటర్లను నిల్వ చేయడానికి ఉపయోగించే శ్రేణులు.
- పాయింటర్ నుండి పాయింటర్: పాయింటర్పై పాయింటర్ ఉపయోగించబడుతుంది.
ఉదాహరణ:
కొన్ని వేరియబుల్స్ యొక్క చిరునామాలు ముద్రించబడిన తదుపరి ఉదాహరణ గురించి ఆలోచించండి.
హెడర్ ఫైల్ మరియు స్టాండర్డ్ నేమ్స్పేస్ని చేర్చిన తర్వాత, మేము రెండు వేరియబుల్లను ప్రారంభిస్తున్నాము. ఒకటి i' ద్వారా సూచించబడే పూర్ణాంకం విలువ మరియు మరొకటి 10 అక్షరాల పరిమాణంతో అక్షర రకం శ్రేణి 'I'. రెండు వేరియబుల్స్ యొక్క చిరునామాలు 'cout' ఆదేశాన్ని ఉపయోగించడం ద్వారా ప్రదర్శించబడతాయి.
మేము అందుకున్న అవుట్పుట్ క్రింద చూపబడింది:
ఈ ఫలితం రెండు వేరియబుల్స్ చిరునామాను చూపుతుంది.
మరోవైపు, పాయింటర్ అనేది వేరియబుల్గా పరిగణించబడుతుంది, దీని విలువ వేరే వేరియబుల్ చిరునామాగా ఉంటుంది. పాయింటర్ ఎల్లప్పుడూ (*) ఆపరేటర్తో సృష్టించబడిన అదే రకాన్ని కలిగి ఉన్న డేటాటైప్ను సూచిస్తుంది.
పాయింటర్ యొక్క ప్రకటన:
పాయింటర్ ఈ విధంగా ప్రకటించబడింది:
రకం * ఉంది - పేరు ;పాయింటర్ యొక్క ఆధార రకం 'రకం' ద్వారా సూచించబడుతుంది, అయితే పాయింటర్ పేరు 'var-name' ద్వారా వ్యక్తీకరించబడుతుంది. మరియు పాయింటర్ ఆస్టరిస్క్(*)కి వేరియబుల్ని పొందుపరచడానికి ఉపయోగించబడుతుంది.
వేరియబుల్స్కు పాయింటర్లను కేటాయించే మార్గాలు:
Int * పై ; //పూర్ణాంక డేటాటైప్ యొక్క పాయింటర్రెట్టింపు * pd ; // డబుల్ డేటాటైప్ యొక్క పాయింటర్
ఫ్లోట్ * pf ; // ఫ్లోట్ డేటాటైప్ యొక్క పాయింటర్
చార్ * pc ; // చార్ డేటాటైప్ యొక్క పాయింటర్
దాదాపు ఎల్లప్పుడూ దీర్ఘ హెక్సాడెసిమల్ సంఖ్య మెమరీ చిరునామాను సూచిస్తుంది, ఇది డేటాటైప్లతో సంబంధం లేకుండా అన్ని పాయింటర్లకు ప్రారంభంలో ఒకే విధంగా ఉంటుంది.
ఉదాహరణ:
కింది ఉదాహరణ పాయింటర్లు '&' ఆపరేటర్ని ఎలా భర్తీ చేస్తాయో మరియు వేరియబుల్స్ చిరునామాను ఎలా నిల్వ చేస్తాయో చూపుతుంది.
మేము లైబ్రరీలు మరియు డైరెక్టరీల మద్దతును ఏకీకృతం చేయబోతున్నాము. అప్పుడు, మేము పిలుస్తాము ప్రధాన () 55 విలువతో 'int' టైప్ యొక్క వేరియబుల్ 'n'ని ప్రకటించి, ప్రారంభించే ఫంక్షన్. తదుపరి లైన్లో, మనం 'p1' అనే పాయింటర్ వేరియబుల్ని ప్రారంభిస్తున్నాము. దీని తరువాత, మేము 'n' వేరియబుల్ యొక్క చిరునామాను పాయింటర్ 'p1'కి కేటాయిస్తాము మరియు ఆపై 'n' వేరియబుల్ విలువను చూపుతాము. 'p1' పాయింటర్లో నిల్వ చేయబడిన 'n' చిరునామా ప్రదర్శించబడుతుంది. తరువాత, 'cout' ఆదేశాన్ని ఉపయోగించడం ద్వారా '*p1' విలువ స్క్రీన్పై ముద్రించబడుతుంది. అవుట్పుట్ క్రింది విధంగా ఉంది:
ఇక్కడ, 'n' విలువ 55 అని మరియు పాయింటర్ 'p1'లో నిల్వ చేయబడిన 'n' చిరునామా 0x6ffe14గా చూపబడిందని మనం చూస్తాము. పాయింటర్ వేరియబుల్ యొక్క విలువ కనుగొనబడింది మరియు ఇది 55, ఇది పూర్ణాంక వేరియబుల్ విలువకు సమానం. కాబట్టి, ఒక పాయింటర్ వేరియబుల్ యొక్క చిరునామాను నిల్వ చేస్తుంది మరియు * పాయింటర్ కూడా పూర్ణాంకం యొక్క విలువను కలిగి ఉంటుంది, దీని ఫలితంగా ప్రారంభంలో నిల్వ చేయబడిన వేరియబుల్ విలువను తిరిగి ఇస్తుంది.
ఉదాహరణ:
మేము స్ట్రింగ్ చిరునామాను నిల్వ చేసే పాయింటర్ను ఉపయోగిస్తున్న మరొక ఉదాహరణను పరిశీలిద్దాం.
ఈ కోడ్లో, మేము ముందుగా లైబ్రరీలు మరియు నేమ్స్పేస్ని జోడిస్తున్నాము. లో ప్రధాన () ఫంక్షన్లో మనం 'మేకప్' అనే స్ట్రింగ్ను డిక్లేర్ చేయాలి, అందులో 'మస్కరా' విలువ ఉంటుంది. మేకప్ వేరియబుల్ చిరునామాను నిల్వ చేయడానికి స్ట్రింగ్ టైప్ పాయింటర్ ‘*p2’ ఉపయోగించబడుతుంది. వేరియబుల్ 'మేకప్' విలువ 'కౌట్' స్టేట్మెంట్ను ఉపయోగించి స్క్రీన్పై ప్రదర్శించబడుతుంది. దీని తరువాత, వేరియబుల్ 'మేకప్' యొక్క చిరునామా ముద్రించబడుతుంది మరియు చివరికి, పాయింటర్తో 'మేకప్' వేరియబుల్ యొక్క మెమరీ చిరునామాను చూపే పాయింటర్ వేరియబుల్ 'p2' ప్రదర్శించబడుతుంది.
పై కోడ్ నుండి అందుకున్న అవుట్పుట్ క్రింది విధంగా ఉంది:
మొదటి పంక్తిలో ప్రదర్శించబడే 'మేకప్' వేరియబుల్ విలువ ఉంది. రెండవ పంక్తి వేరియబుల్ 'మేకప్' చిరునామాను చూపుతుంది. చివరి పంక్తిలో, పాయింటర్ వాడకంతో 'మేకప్' వేరియబుల్ యొక్క మెమరీ చిరునామా చూపబడింది.
C++ మెమరీ నిర్వహణ:
C++లో సమర్థవంతమైన మెమరీ నిర్వహణ కోసం, C++లో పనిచేస్తున్నప్పుడు మెమరీ నిర్వహణకు అనేక కార్యకలాపాలు సహాయపడతాయి. మేము C++ని ఉపయోగించినప్పుడు, అత్యంత సాధారణంగా ఉపయోగించే మెమరీ కేటాయింపు విధానం డైనమిక్ మెమరీ కేటాయింపు, ఇక్కడ రన్టైమ్ సమయంలో వేరియబుల్స్కు మెమరీలు కేటాయించబడతాయి; కంపైలర్ మెమరీని వేరియబుల్స్కు కేటాయించగలిగే ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్ల వలె కాదు. C++లో, డైనమిక్గా కేటాయించబడిన వేరియబుల్స్ యొక్క డీలోకేషన్ అవసరం, తద్వారా వేరియబుల్ ఉపయోగంలో లేనప్పుడు మెమరీ ఉచితంగా విడుదల చేయబడుతుంది.
C++లో మెమరీ యొక్క డైనమిక్ కేటాయింపు మరియు డీలోకేషన్ కోసం, మేము ' కొత్త' మరియు 'తొలగించు' ఆపరేషన్లు. జ్ఞాపకశక్తిని వృధా చేయకుండా మెమరీని నిర్వహించడం చాలా ముఖ్యం. మెమరీ కేటాయింపు సులభం మరియు ప్రభావవంతంగా మారుతుంది. ఏదైనా C++ ప్రోగ్రామ్లో, మెమరీ రెండు అంశాలలో ఒకదానిలో ఉపయోగించబడుతుంది: హీప్ లేదా స్టాక్గా.
- స్టాక్ : ఫంక్షన్ లోపల డిక్లేర్ చేయబడిన అన్ని వేరియబుల్ మరియు ఫంక్షన్తో పరస్పర సంబంధం ఉన్న ప్రతి ఇతర వివరాలు స్టాక్లో నిల్వ చేయబడతాయి.
- కుప్ప : ఏదైనా ఉపయోగించని మెమరీ లేదా ప్రోగ్రామ్ అమలు సమయంలో మనం డైనమిక్ మెమరీని కేటాయించే లేదా కేటాయించే భాగాన్ని హీప్ అంటారు.
శ్రేణులను ఉపయోగిస్తున్నప్పుడు, మెమరీ కేటాయింపు అనేది రన్టైమ్ తప్ప మెమరీని గుర్తించలేము. కాబట్టి, మేము శ్రేణికి గరిష్ట మెమరీని కేటాయిస్తాము, అయితే ఇది కూడా మంచి పద్ధతి కాదు, ఎందుకంటే చాలా సందర్భాలలో మెమరీ ఉపయోగించబడదు మరియు ఇది మీ వ్యక్తిగత కంప్యూటర్కు మంచి ఎంపిక లేదా అభ్యాసం కాదు. అందుకే, రన్టైమ్ సమయంలో హీప్ నుండి మెమరీని కేటాయించడానికి ఉపయోగించే కొన్ని ఆపరేటర్లను మేము కలిగి ఉన్నాము. రెండు ప్రధాన ఆపరేటర్లు 'కొత్త' మరియు 'తొలగించు' సమర్థవంతమైన మెమరీ కేటాయింపు మరియు డీలోకేషన్ కోసం ఉపయోగించబడతాయి.
C++ కొత్త ఆపరేటర్:
కొత్త ఆపరేటర్ మెమరీ కేటాయింపుకు బాధ్యత వహిస్తాడు మరియు ఈ క్రింది విధంగా ఉపయోగించబడుతుంది:
ఈ కోడ్లో, మేము లైబ్రరీ
పాయింటర్ వాడకంతో విజయవంతంగా 'int' వేరియబుల్కు మెమరీ కేటాయించబడింది.
C++ తొలగింపు ఆపరేటర్:
మనం వేరియబుల్ని ఉపయోగించి పూర్తి చేసినప్పుడల్లా, మనం ఒకసారి కేటాయించిన మెమరీని డీలోకేట్ చేయాలి ఎందుకంటే అది ఇప్పుడు ఉపయోగంలో లేదు. దీని కోసం, మెమరీని విడుదల చేయడానికి మేము 'తొలగించు' ఆపరేటర్ని ఉపయోగిస్తాము.
మేము ప్రస్తుతం సమీక్షించబోయే ఉదాహరణ రెండు ఆపరేటర్లను కలిగి ఉంది.
మేము వినియోగదారు నుండి తీసుకున్న మూడు వేర్వేరు విలువలకు సగటును గణిస్తున్నాము. పాయింటర్ వేరియబుల్స్ విలువలను నిల్వ చేయడానికి 'కొత్త' ఆపరేటర్తో కేటాయించబడతాయి. సగటు సూత్రం అమలు చేయబడింది. దీని తరువాత, 'కొత్త' ఆపరేటర్ని ఉపయోగించి పాయింటర్ వేరియబుల్స్లో నిల్వ చేయబడిన విలువలను తొలగించే 'తొలగించు' ఆపరేటర్ ఉపయోగించబడుతుంది. ఇది డైనమిక్ కేటాయింపు, ఇక్కడ రన్టైమ్ సమయంలో కేటాయింపు జరుగుతుంది మరియు ప్రోగ్రామ్ ముగిసిన వెంటనే డీలోకేషన్ జరుగుతుంది.
మెమరీ కేటాయింపు కోసం శ్రేణిని ఉపయోగించడం:
ఇప్పుడు, శ్రేణులను ఉపయోగించేటప్పుడు 'కొత్త' మరియు 'తొలగించు' ఆపరేటర్లు ఎలా ఉపయోగించబడతాయో మనం చూడబోతున్నాం. డైనమిక్ కేటాయింపు వేరియబుల్స్కు జరిగిన విధంగానే జరుగుతుంది, ఎందుకంటే వాక్యనిర్మాణం దాదాపు ఒకే విధంగా ఉంటుంది.
ఇవ్వబడిన సందర్భంలో, వినియోగదారు నుండి విలువ తీసుకోబడిన మూలకాల శ్రేణిని మేము పరిశీలిస్తున్నాము. శ్రేణి యొక్క మూలకాలు తీసుకోబడతాయి మరియు పాయింటర్ వేరియబుల్ ప్రకటించబడుతుంది మరియు తర్వాత మెమరీ కేటాయించబడుతుంది. మెమరీ కేటాయింపు తర్వాత, శ్రేణి మూలకాల ఇన్పుట్ విధానం ప్రారంభించబడుతుంది. తరువాత, శ్రేణి మూలకాల కోసం అవుట్పుట్ 'ఫర్' లూప్ని ఉపయోగించడం ద్వారా చూపబడుతుంది. ఈ లూప్ n ద్వారా సూచించబడే శ్రేణి యొక్క వాస్తవ పరిమాణం కంటే తక్కువ పరిమాణాన్ని కలిగి ఉన్న మూలకాల యొక్క పునరావృత స్థితిని కలిగి ఉంటుంది.
అన్ని మూలకాలను ఉపయోగించినప్పుడు మరియు వాటిని మళ్లీ ఉపయోగించాల్సిన అవసరం లేనప్పుడు, మూలకాలకు కేటాయించిన మెమరీ 'డిలీట్' ఆపరేటర్ని ఉపయోగించి డీలోకేట్ చేయబడుతుంది.
అవుట్పుట్లో, రెండుసార్లు ముద్రించిన విలువల సెట్లను మనం చూడవచ్చు. మూలకాల కోసం విలువలను వ్రాయడానికి మొదటి 'ఫర్' లూప్ ఉపయోగించబడింది మరియు వినియోగదారు స్పష్టత కోసం ఈ విలువలను వ్రాసినట్లు చూపిస్తూ ఇప్పటికే వ్రాసిన విలువల ముద్రణ కోసం ఇతర 'ఫర్' లూప్ ఉపయోగించబడుతుంది.
ప్రయోజనాలు:
C++ ప్రోగ్రామింగ్ లాంగ్వేజ్లో 'క్రొత్త' మరియు 'తొలగించు' ఆపరేటర్కు ఎల్లప్పుడూ ప్రాధాన్యత ఉంటుంది మరియు విస్తృతంగా ఉపయోగించబడుతుంది. సమగ్రమైన చర్చ మరియు అవగాహన కలిగి ఉన్నప్పుడు, 'కొత్త' ఆపరేటర్కు చాలా ప్రయోజనాలు ఉన్నాయని గుర్తించబడింది. మెమరీ కేటాయింపు కోసం 'కొత్త' ఆపరేటర్ యొక్క ప్రయోజనాలు క్రింది విధంగా ఉన్నాయి:
- కొత్త ఆపరేటర్ను మరింత సులభంగా ఓవర్లోడ్ చేయవచ్చు.
- రన్టైమ్ సమయంలో మెమరీని కేటాయించేటప్పుడు, తగినంత మెమరీ లేనప్పుడు ప్రోగ్రామ్ను ముగించడం కంటే ఆటోమేటిక్ మినహాయింపు విసిరివేయబడుతుంది.
- టైప్కాస్టింగ్ విధానాన్ని ఉపయోగించడం యొక్క హడావిడి ఇక్కడ లేదు ఎందుకంటే 'కొత్త' ఆపరేటర్కు మనం కేటాయించిన మెమరీ మాదిరిగానే ఉంటుంది.
- 'కొత్త' ఆపరేటర్ సైజ్ఆఫ్() ఆపరేటర్ను 'కొత్త'గా ఉపయోగించాలనే ఆలోచనను కూడా తిరస్కరిస్తుంది, అనివార్యంగా వస్తువుల పరిమాణాన్ని గణిస్తుంది.
- 'కొత్త' ఆపరేటర్ ఆబ్జెక్ట్ల కోసం స్పాంటేనియస్గా స్పేస్ను ఉత్పత్తి చేస్తున్నప్పటికీ వాటిని ప్రారంభించి, ప్రకటించడానికి మాకు వీలు కల్పిస్తుంది.
C++ శ్రేణులు:
C++ ప్రోగ్రామ్లో శ్రేణులు అంటే ఏమిటి మరియు అవి ఎలా ప్రకటించబడతాయి మరియు అమలు చేయబడతాయి అనే దానిపై మేము సమగ్రంగా చర్చించబోతున్నాము. శ్రేణి అనేది ఒక వేరియబుల్లో బహుళ విలువలను నిల్వ చేయడానికి ఉపయోగించే డేటా నిర్మాణం, తద్వారా అనేక వేరియబుల్లను స్వతంత్రంగా ప్రకటించే హస్ల్ని తగ్గిస్తుంది.
శ్రేణుల ప్రకటన:
శ్రేణిని ప్రకటించడానికి, ముందుగా వేరియబుల్ రకాన్ని నిర్వచించాలి మరియు స్క్వేర్ బ్రాకెట్ల వెంట జోడించబడే శ్రేణికి తగిన పేరును ఇవ్వాలి. ఇది నిర్దిష్ట శ్రేణి యొక్క పరిమాణాన్ని చూపించే మూలకాల సంఖ్యను కలిగి ఉంటుంది.
ఉదాహరణకి:
స్ట్రింగ్ మేకప్ [ 5 ] ;ఈ వేరియబుల్ 'మేకప్' అనే శ్రేణిలో ఐదు స్ట్రింగ్లను కలిగి ఉన్నట్లు చూపుతుంది. ఈ శ్రేణి కోసం విలువలను గుర్తించడానికి మరియు వివరించడానికి, మేము కర్లీ బ్రాకెట్లను ఉపయోగించాలి, ప్రతి మూలకం విడివిడిగా డబుల్ ఇన్వర్టెడ్ కామాలతో జతచేయబడుతుంది, ప్రతి ఒక్కటి మధ్యలో ఒకే కామాతో వేరు చేయబడుతుంది.
ఉదాహరణకి:
స్ట్రింగ్ మేకప్ [ 5 ] = { 'మస్కరా' , 'టింట్' , 'లిప్స్టిక్' , 'ఫౌండేషన్' , 'ప్రధమ' } ;అదేవిధంగా, మీరు వేరొక డేటాటైప్తో 'int'గా భావించబడే మరొక శ్రేణిని సృష్టించాలని భావిస్తే, ప్రక్రియ అదే విధంగా ఉంటుంది, మీరు క్రింద చూపిన విధంగా వేరియబుల్ యొక్క డేటా రకాన్ని మార్చాలి:
int మల్టిపుల్స్ [ 5 ] = { రెండు , 4 , 6 , 8 , 10 } ;పూర్ణాంక విలువలను శ్రేణికి కేటాయించేటప్పుడు, వాటిని విలోమ కామాల్లో కలిగి ఉండకూడదు, ఇది స్ట్రింగ్ వేరియబుల్ కోసం మాత్రమే పని చేస్తుంది. కాబట్టి, నిశ్చయంగా శ్రేణి అనేది వాటిలో నిల్వ చేయబడిన ఉత్పన్నమైన డేటా రకాలతో పరస్పర సంబంధం ఉన్న డేటా అంశాల సమాహారం.
శ్రేణిలోని మూలకాలను ఎలా యాక్సెస్ చేయాలి?
శ్రేణిలో చేర్చబడిన అన్ని మూలకాలు ప్రత్యేక సంఖ్యతో కేటాయించబడతాయి, ఇది శ్రేణి నుండి మూలకాన్ని యాక్సెస్ చేయడానికి ఉపయోగించే వాటి సూచిక సంఖ్య. శ్రేణి పరిమాణం కంటే ఒకటి తక్కువగా ఉండే వరకు సూచిక విలువ 0తో ప్రారంభమవుతుంది. మొదటి విలువ 0 యొక్క సూచిక విలువను కలిగి ఉంటుంది.
ఉదాహరణ:
మేము శ్రేణిలో వేరియబుల్స్ను ప్రారంభించే చాలా ప్రాథమిక మరియు సులభమైన ఉదాహరణను పరిగణించండి.
మొదటి దశలో, మేము
ఇది పై కోడ్ నుండి స్వీకరించబడిన ఫలితం. 'endl' కీవర్డ్ ఇతర అంశాన్ని స్వయంచాలకంగా తదుపరి పంక్తికి తరలిస్తుంది.
ఉదాహరణ:
ఈ కోడ్లో, మేము శ్రేణిలోని అంశాలను ప్రింట్ చేయడానికి ‘ఫర్’ లూప్ని ఉపయోగిస్తున్నాము.
పై సందర్భంలో, మేము అవసరమైన లైబ్రరీని జోడిస్తున్నాము. ప్రామాణిక నేమ్స్పేస్ జోడించబడుతోంది. ది ప్రధాన () ఫంక్షన్ అనేది ఒక నిర్దిష్ట ప్రోగ్రామ్ యొక్క అమలు కోసం మేము అన్ని ఫంక్షనాలిటీలను నిర్వహించబోతున్న ఫంక్షన్. తరువాత, మేము 10 పరిమాణంలో ఉన్న ‘Num’ అనే పేరుతో ఒక పూర్ణాంక రకం శ్రేణిని ప్రకటిస్తున్నాము. ఈ పది వేరియబుల్స్ యొక్క విలువ వినియోగదారు నుండి ‘ఫర్’ లూప్ వాడకంతో తీసుకోబడుతుంది. ఈ శ్రేణి యొక్క ప్రదర్శన కోసం, 'ఫర్' లూప్ మళ్లీ ఉపయోగించబడుతుంది. శ్రేణిలో నిల్వ చేయబడిన 10 పూర్ణాంకాలు 'కౌట్' ప్రకటన సహాయంతో ప్రదర్శించబడతాయి.
ఇది పైన పేర్కొన్న కోడ్ అమలు నుండి మనకు లభించిన అవుట్పుట్, వివిధ విలువలను కలిగి ఉన్న 10 పూర్ణాంకాలను చూపుతుంది.
ఉదాహరణ:
ఈ దృష్టాంతంలో, మేము ఒక విద్యార్థి యొక్క సగటు స్కోర్ మరియు అతను తరగతిలో సంపాదించిన శాతాన్ని కనుగొనబోతున్నాము.
ముందుగా, మీరు C++ ప్రోగ్రామ్కు ప్రారంభ మద్దతును అందించే లైబ్రరీని జోడించాలి. తరువాత, మేము 'స్కోర్' అనే పేరు గల శ్రేణి యొక్క పరిమాణం 5ని పేర్కొంటున్నాము. అప్పుడు, మేము డేటాటైప్ ఫ్లోట్ యొక్క వేరియబుల్ 'మొత్తం'ని ప్రారంభించాము. ప్రతి సబ్జెక్ట్ యొక్క స్కోర్లు వినియోగదారు నుండి మాన్యువల్గా తీసుకోబడతాయి. ఆపై, చేర్చబడిన అన్ని సబ్జెక్టుల సగటు మరియు శాతాన్ని కనుగొనడానికి 'ఫర్' లూప్ ఉపయోగించబడుతుంది. అర్రే మరియు 'ఫర్' లూప్ని ఉపయోగించడం ద్వారా మొత్తం పొందబడుతుంది. అప్పుడు, సగటు సూత్రాన్ని ఉపయోగించి సగటు కనుగొనబడుతుంది. సగటును కనుగొన్న తర్వాత, శాతాన్ని పొందడానికి ఫార్ములాకు జోడించిన శాతానికి దాని విలువను మేము పాస్ చేస్తున్నాము. అప్పుడు సగటు మరియు శాతం లెక్కించబడతాయి మరియు ప్రదర్శించబడతాయి.
ఇది ప్రతి సబ్జెక్టుకు వ్యక్తిగతంగా వినియోగదారు నుండి స్కోర్లు తీసుకోబడిన చివరి అవుట్పుట్ మరియు సగటు మరియు శాతం వరుసగా లెక్కించబడతాయి.
శ్రేణులను ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు:
- శ్రేణిలోని ఐటెమ్లకు కేటాయించిన సూచిక సంఖ్య కారణంగా వాటిని యాక్సెస్ చేయడం సులభం.
- మేము శ్రేణిలో శోధన ఆపరేషన్ను సులభంగా నిర్వహించగలము.
- మీరు ప్రోగ్రామింగ్లో సంక్లిష్టతలను కోరుకుంటే, మీరు మాత్రికలను కూడా వర్ణించే 2-డైమెన్షనల్ శ్రేణిని ఉపయోగించవచ్చు.
- ఒకే విధమైన డేటాటైప్ని కలిగి ఉన్న బహుళ విలువలను నిల్వ చేయడానికి, శ్రేణిని సులభంగా ఉపయోగించుకోవచ్చు.
శ్రేణులను ఉపయోగించడం వల్ల కలిగే నష్టాలు:
- శ్రేణులు స్థిర పరిమాణాన్ని కలిగి ఉంటాయి.
- శ్రేణులు సజాతీయంగా ఉంటాయి అంటే ఒకే రకమైన విలువ మాత్రమే నిల్వ చేయబడుతుంది.
- శ్రేణులు వ్యక్తిగతంగా భౌతిక మెమరీలో డేటాను నిల్వ చేస్తాయి.
- శ్రేణుల కోసం చొప్పించడం మరియు తొలగించడం సులభం కాదు.
C++ వస్తువులు మరియు తరగతులు:
C++ అనేది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్, అంటే వస్తువులు C++లో కీలక పాత్ర పోషిస్తాయి. వస్తువుల గురించి మాట్లాడేటప్పుడు వస్తువులు ఏమిటో మొదట పరిగణించాలి, కాబట్టి ఒక వస్తువు తరగతికి సంబంధించిన ఏదైనా ఉదాహరణ. C++ OOP యొక్క భావనలతో వ్యవహరిస్తున్నందున, చర్చించవలసిన ప్రధాన విషయాలు వస్తువులు మరియు తరగతులు. క్లాసులు వాస్తవానికి వినియోగదారుచే నిర్వచించబడిన డేటాటైప్లు మరియు డేటా మెంబర్లను ఎన్క్యాప్సులేట్ చేయడానికి నియమించబడతాయి మరియు నిర్దిష్ట తరగతి కోసం మాత్రమే యాక్సెస్ చేయగల ఫంక్షన్లు సృష్టించబడతాయి. డేటా సభ్యులు తరగతి లోపల నిర్వచించబడిన వేరియబుల్స్.
ఇతర మాటలలో క్లాస్ అనేది డేటా సభ్యుల నిర్వచనం మరియు డిక్లరేషన్ మరియు ఆ డేటా సభ్యులకు కేటాయించిన విధులకు బాధ్యత వహించే అవుట్లైన్ లేదా డిజైన్. తరగతిలో ప్రకటించబడిన ప్రతి వస్తువులు తరగతి ప్రదర్శించిన అన్ని లక్షణాలు లేదా విధులను పంచుకోగలవు.
పక్షులు అనే తరగతి ఉందని అనుకుందాం, ఇప్పుడు మొదట్లో పక్షులన్నీ ఎగురుతూ రెక్కలు కలిగి ఉండేవి. అందువల్ల, ఎగరడం అనేది ఈ పక్షులు అనుసరించే ప్రవర్తన మరియు రెక్కలు వాటి శరీరంలో భాగం లేదా ప్రాథమిక లక్షణం.
తరగతిని నిర్వచించడం:
తరగతిని నిర్వచించడం కోసం, మీరు సింటాక్స్ను అనుసరించాలి మరియు మీ తరగతికి అనుగుణంగా రీసెట్ చేయాలి. 'తరగతి' అనే కీవర్డ్ తరగతిని నిర్వచించడానికి ఉపయోగించబడుతుంది మరియు అన్ని ఇతర డేటా సభ్యులు మరియు ఫంక్షన్లు కర్లీ బ్రాకెట్లలో క్లాస్ నిర్వచనంతో నిర్వచించబడతాయి.
తరగతి పేరుOfClass
{
యాక్సెస్ స్పెసిఫైయర్ :
డేటా సభ్యులు ;
డేటా సభ్యుల విధులు ( ) ;
} ;
డిక్లేరింగ్ వస్తువులు:
తరగతిని నిర్వచించిన వెంటనే, తరగతి ద్వారా పేర్కొన్న ఫంక్షన్లను యాక్సెస్ చేయడానికి మరియు నిర్వచించడానికి మేము ఆబ్జెక్ట్లను సృష్టించాలి. దాని కోసం, మేము డిక్లరేషన్ కోసం క్లాస్ పేరు మరియు ఆపై వస్తువు పేరు రాయాలి.
డేటా సభ్యులను యాక్సెస్ చేస్తోంది:
ఫంక్షన్లు మరియు డేటా సభ్యులు సాధారణ డాట్ ‘.’ ఆపరేటర్ సహాయంతో యాక్సెస్ చేయబడతాయి. పబ్లిక్ డేటా సభ్యులు కూడా ఈ ఆపరేటర్తో యాక్సెస్ చేయబడతారు, అయితే ప్రైవేట్ డేటా సభ్యుల విషయంలో, మీరు వాటిని నేరుగా యాక్సెస్ చేయలేరు. డేటా సభ్యుల యాక్సెస్ ప్రైవేట్, పబ్లిక్ లేదా రక్షిత యాక్సెస్ మాడిఫైయర్ల ద్వారా వారికి అందించబడిన యాక్సెస్ నియంత్రణలపై ఆధారపడి ఉంటుంది. సాధారణ తరగతి, డేటా సభ్యులు మరియు విధులను ఎలా ప్రకటించాలో ప్రదర్శించే దృశ్యం ఇక్కడ ఉంది.
ఉదాహరణ:
ఈ ఉదాహరణలో, మేము కొన్ని ఫంక్షన్లను నిర్వచించబోతున్నాము మరియు ఆబ్జెక్ట్ల సహాయంతో క్లాస్ ఫంక్షన్లు మరియు డేటా మెంబర్లను యాక్సెస్ చేస్తాము.
మొదటి దశలో, మేము లైబ్రరీని ఏకీకృతం చేస్తున్నాము, దాని తర్వాత మేము సహాయక డైరెక్టరీలను చేర్చాలి. కాల్ చేయడానికి ముందు తరగతి స్పష్టంగా నిర్వచించబడింది ప్రధాన () ఫంక్షన్. ఈ తరగతిని 'వాహనం' అని పిలుస్తారు. డేటా సభ్యులు 'వాహనం యొక్క పేరు మరియు ఆ వాహనం యొక్క 'ఐడి', ఇది వరుసగా స్ట్రింగ్ మరియు పూర్ణాంక డేటాటైప్ కలిగి ఉన్న ఆ వాహనం యొక్క ప్లేట్ నంబర్. ఈ ఇద్దరు డేటా సభ్యుల కోసం రెండు విధులు ప్రకటించబడ్డాయి. ది id() ఫంక్షన్ వాహనం యొక్క ఐడిని ప్రదర్శిస్తుంది. తరగతిలోని డేటా సభ్యులు పబ్లిక్గా ఉన్నందున, మేము వారిని తరగతి వెలుపల కూడా యాక్సెస్ చేయవచ్చు. అందువల్ల, మేము పిలుస్తున్నాము పేరు() తరగతి వెలుపల పని చేసి, ఆపై వినియోగదారు నుండి 'వాహన పేరు' కోసం విలువను తీసుకొని తదుపరి దశలో దాన్ని ముద్రించండి. లో ప్రధాన () ఫంక్షన్, మేము క్లాస్ నుండి డేటా మెంబర్లు మరియు ఫంక్షన్లను యాక్సెస్ చేయడంలో సహాయపడే క్లాస్ యొక్క ఆబ్జెక్ట్ను ప్రకటిస్తున్నాము. ఇంకా, మేము వాహనం పేరు మరియు దాని ఐడి కోసం విలువలను ప్రారంభిస్తున్నాము, వినియోగదారు వాహనం పేరుకు విలువను ఇవ్వకపోతే మాత్రమే.
ఇది వినియోగదారుడు వాహనం కోసం తన పేరును ఇచ్చినప్పుడు అందుకున్న అవుట్పుట్ మరియు నంబర్ ప్లేట్లు దానికి కేటాయించిన స్టాటిక్ విలువ.
సభ్యుల ఫంక్షన్ల నిర్వచనం గురించి మాట్లాడేటప్పుడు, తరగతి లోపల ఫంక్షన్ను నిర్వచించడం ఎల్లప్పుడూ తప్పనిసరి కాదని అర్థం చేసుకోవాలి. మీరు పై ఉదాహరణలో చూడగలిగినట్లుగా, డేటా సభ్యులు పబ్లిక్గా ప్రకటించబడినందున మేము తరగతి వెలుపల తరగతి యొక్క పనితీరును నిర్వచిస్తున్నాము మరియు ఇది పేరుతో పాటు '::'గా చూపబడిన స్కోప్ రిజల్యూషన్ ఆపరేటర్ సహాయంతో చేయబడుతుంది తరగతి మరియు ఫంక్షన్ పేరు.
C++ కన్స్ట్రక్టర్లు మరియు డిస్ట్రక్టర్లు:
ఉదాహరణల సహాయంతో మేము ఈ అంశాన్ని క్షుణ్ణంగా పరిశీలించబోతున్నాము. C++ ప్రోగ్రామింగ్లో ఆబ్జెక్ట్ల తొలగింపు మరియు సృష్టి చాలా ముఖ్యమైనవి. దాని కోసం, మేము తరగతి కోసం ఒక ఉదాహరణను సృష్టించినప్పుడల్లా, మేము స్వయంచాలకంగా కొన్ని సందర్భాల్లో కన్స్ట్రక్టర్ పద్ధతులను కాల్ చేస్తాము.
కన్స్ట్రక్టర్లు:
పేరు సూచించినట్లుగా, ఏదైనా సృష్టిని నిర్దేశించే 'నిర్మాణం' అనే పదం నుండి కన్స్ట్రక్టర్ ఉద్భవించింది. కాబట్టి, క్లాస్ పేరును షేర్ చేసే కొత్తగా సృష్టించబడిన క్లాస్ యొక్క ఉత్పన్నమైన ఫంక్షన్గా కన్స్ట్రక్టర్ నిర్వచించబడింది. మరియు ఇది తరగతిలో చేర్చబడిన వస్తువులను ప్రారంభించడం కోసం ఉపయోగించబడుతుంది. అలాగే, కన్స్ట్రక్టర్కి దానికదే రిటర్న్ వాల్యూ లేదు అంటే దాని రిటర్న్ రకం కూడా శూన్యంగా ఉండదు. వాదనలను అంగీకరించడం తప్పనిసరి కాదు, అయితే అవసరమైతే వాటిని జోడించవచ్చు. క్లాస్ యొక్క ఆబ్జెక్ట్కు మెమరీని కేటాయించడంలో మరియు మెంబర్ వేరియబుల్స్కు ప్రారంభ విలువను సెట్ చేయడంలో కన్స్ట్రక్టర్లు ఉపయోగపడతాయి. ఆబ్జెక్ట్ ప్రారంభించబడిన తర్వాత ప్రారంభ విలువను ఆర్గ్యుమెంట్ల రూపంలో కన్స్ట్రక్టర్ ఫంక్షన్కు పంపవచ్చు.
సింటాక్స్:
పేరుOfTheClass ( ){
//నిర్మాణకర్త యొక్క శరీరం
}
కన్స్ట్రక్టర్ల రకాలు:
పారామీటర్ కన్స్ట్రక్టర్:
ఇంతకు ముందు చర్చించినట్లుగా, కన్స్ట్రక్టర్కు ఏ పరామితి లేదు కానీ ఒకరు తమకు నచ్చిన పరామితిని జోడించవచ్చు. ఇది సృష్టించబడుతున్నప్పుడు వస్తువు యొక్క విలువను ప్రారంభిస్తుంది. ఈ భావనను బాగా అర్థం చేసుకోవడానికి, ఈ క్రింది ఉదాహరణను పరిగణించండి:
ఉదాహరణ:
ఈ సందర్భంలో, మేము తరగతి యొక్క కన్స్ట్రక్టర్ను సృష్టిస్తాము మరియు పారామితులను ప్రకటిస్తాము.
మేము మొదటి దశలో హెడర్ ఫైల్ని చేర్చుతున్నాము. నేమ్స్పేస్ని ఉపయోగించడం యొక్క తదుపరి దశ ప్రోగ్రామ్కు డైరెక్టరీలను సపోర్టింగ్ చేయడం. ముందుగా, వేరియబుల్స్ పబ్లిక్గా ప్రారంభించబడిన చోట 'అంకెలు' అనే తరగతి ప్రకటించబడుతుంది, తద్వారా అవి ప్రోగ్రామ్ అంతటా అందుబాటులో ఉంటాయి. డేటాటైప్ పూర్ణాంకంతో 'dig1' అనే వేరియబుల్ ప్రకటించబడింది. తర్వాత, మేము క్లాస్ పేరును పోలి ఉండే ఒక కన్స్ట్రక్టర్ని ప్రకటించాము. ఈ కన్స్ట్రక్టర్కి పూర్ణాంక వేరియబుల్ 'n'గా పంపబడింది మరియు క్లాస్ వేరియబుల్ 'dig1' nకి సమానంగా సెట్ చేయబడింది. లో ప్రధాన () ప్రోగ్రామ్ యొక్క ఫంక్షన్, తరగతి 'అంకెలు' కోసం మూడు వస్తువులు సృష్టించబడతాయి మరియు కొన్ని యాదృచ్ఛిక విలువలు కేటాయించబడతాయి. ఈ వస్తువులు స్వయంచాలకంగా ఒకే విలువలతో కేటాయించబడిన క్లాస్ వేరియబుల్స్ని కాల్ చేయడానికి ఉపయోగించబడతాయి.
పూర్ణాంక విలువలు అవుట్పుట్గా స్క్రీన్పై ప్రదర్శించబడతాయి.
కాపీ కన్స్ట్రక్టర్:
ఇది ఆబ్జెక్ట్లను ఆర్గ్యుమెంట్లుగా పరిగణించే కన్స్ట్రక్టర్ రకం మరియు ఒక వస్తువు యొక్క డేటా సభ్యుల విలువలను మరొకదానికి నకిలీ చేస్తుంది. అందువల్ల, ఈ కన్స్ట్రక్టర్లు ఒక వస్తువును మరొకదాని నుండి ప్రకటించడానికి మరియు ప్రారంభించేందుకు ఉపయోగించబడతాయి. ఈ ప్రక్రియను కాపీ ఇనిషియలైజేషన్ అంటారు.
ఉదాహరణ:
ఈ సందర్భంలో, కాపీ కన్స్ట్రక్టర్ ప్రకటించబడుతుంది.
మొదట, మేము లైబ్రరీ మరియు డైరెక్టరీని ఏకీకృతం చేస్తున్నాము. 'న్యూ' అనే తరగతి ప్రకటించబడింది, దీనిలో పూర్ణాంకాలు 'e' మరియు 'o'గా ప్రారంభించబడతాయి. రెండు వేరియబుల్స్కు విలువలు కేటాయించబడినప్పుడు కన్స్ట్రక్టర్ పబ్లిక్ చేయబడుతుంది మరియు ఈ వేరియబుల్స్ క్లాస్లో ప్రకటించబడతాయి. అప్పుడు, ఈ విలువలు సహాయంతో ప్రదర్శించబడతాయి ప్రధాన () రిటర్న్ రకంగా 'int'తో ఫంక్షన్. ది ప్రదర్శన() ఫంక్షన్ అని పిలుస్తారు మరియు స్క్రీన్పై సంఖ్యలు ప్రదర్శించబడిన తర్వాత నిర్వచించబడతాయి. లోపల ప్రధాన () ఫంక్షన్, వస్తువులు తయారు చేయబడ్డాయి మరియు ఈ కేటాయించిన వస్తువులు యాదృచ్ఛిక విలువలతో ప్రారంభించబడతాయి మరియు తరువాత ప్రదర్శన() పద్ధతి ఉపయోగించబడుతుంది.
కాపీ కన్స్ట్రక్టర్ వినియోగం ద్వారా అందుకున్న అవుట్పుట్ దిగువన వెల్లడి చేయబడింది.
డిస్ట్రాయర్లు:
పేరు నిర్వచించినట్లుగా, కన్స్ట్రక్టర్ సృష్టించిన వస్తువులను నాశనం చేయడానికి డిస్ట్రక్టర్లను ఉపయోగిస్తారు. కన్స్ట్రక్టర్లతో పోల్చదగినది, డిస్ట్రక్టర్లు తరగతికి ఒకే పేరుని కలిగి ఉంటాయి కానీ అదనపు టిల్డ్ (~) అనుసరించబడతాయి.
సింటాక్స్:
~కొత్త ( ){
}
డిస్ట్రక్టర్ ఎటువంటి ఆర్గ్యుమెంట్లను తీసుకోడు మరియు ఎటువంటి రిటర్న్ విలువను కూడా కలిగి ఉండడు. ఇకపై అందుబాటులో లేని క్లీన్-అప్ స్టోరేజ్ కోసం ప్రోగ్రామ్ నుండి నిష్క్రమించమని కంపైలర్ పరోక్షంగా విజ్ఞప్తి చేస్తుంది.
ఉదాహరణ:
ఈ దృష్టాంతంలో, మేము ఒక వస్తువును తొలగించడానికి డిస్ట్రక్టర్ని ఉపయోగిస్తున్నాము.
ఇక్కడ 'షూస్' క్లాస్ తయారు చేయబడింది. ఒక కన్స్ట్రక్టర్ సృష్టించబడింది, ఇది తరగతికి సమానమైన పేరును కలిగి ఉంటుంది. కన్స్ట్రక్టర్లో, వస్తువు సృష్టించబడిన చోట సందేశం ప్రదర్శించబడుతుంది. కన్స్ట్రక్టర్ తర్వాత, డిస్ట్రక్టర్ తయారు చేయబడింది, ఇది కన్స్ట్రక్టర్తో సృష్టించబడిన వస్తువులను తొలగిస్తుంది. లో ప్రధాన () ఫంక్షన్, 's' పేరుతో పాయింటర్ ఆబ్జెక్ట్ సృష్టించబడుతుంది మరియు ఈ ఆబ్జెక్ట్ను తొలగించడానికి 'తొలగించు' అనే కీవర్డ్ ఉపయోగించబడుతుంది.
డిస్ట్రక్టర్ సృష్టించిన వస్తువును క్లియర్ చేసి నాశనం చేస్తున్న ప్రోగ్రామ్ నుండి మేము అందుకున్న అవుట్పుట్ ఇది.
కన్స్ట్రక్టర్లు మరియు డిస్ట్రక్టర్ల మధ్య వ్యత్యాసం:
కన్స్ట్రక్టర్లు | విధ్వంసకులు |
తరగతి యొక్క ఉదాహరణను సృష్టిస్తుంది. | తరగతి యొక్క ఉదాహరణను నాశనం చేస్తుంది. |
ఇది తరగతి పేరుతో వాదనలను కలిగి ఉంది. | దీనికి వాదనలు లేదా పారామీటర్లు లేవు |
వస్తువు సృష్టించబడినప్పుడు పిలుస్తారు. | వస్తువు నాశనం అయినప్పుడు అంటారు. |
జ్ఞాపకశక్తిని వస్తువులకు కేటాయిస్తుంది. | వస్తువుల జ్ఞాపకశక్తిని డీలాకేట్ చేస్తుంది. |
ఓవర్లోడ్ చేయవచ్చు. | ఓవర్లోడ్ చేయడం సాధ్యం కాదు. |
C++ వారసత్వం:
ఇప్పుడు, మనం C++ వారసత్వం మరియు దాని పరిధి గురించి తెలుసుకుందాం.
వారసత్వం అనేది ఇప్పటికే ఉన్న తరగతి నుండి కొత్త తరగతిని సృష్టించే లేదా సంతరించుకునే పద్ధతి. ప్రస్తుత తరగతిని 'బేస్ క్లాస్' లేదా 'పేరెంట్ క్లాస్' అని కూడా పిలుస్తారు మరియు సృష్టించబడిన కొత్త తరగతిని 'ఉత్పన్న తరగతి' అని పిలుస్తారు. పిల్లల తరగతి మాతృ తరగతి నుండి వారసత్వంగా పొందిందని మేము చెప్పినప్పుడు, మాతృ తరగతి యొక్క అన్ని లక్షణాలను పిల్లవాడు కలిగి ఉంటాడని అర్థం.
వారసత్వం అనేది ఒక (ఒక) సంబంధాన్ని సూచిస్తుంది. రెండు తరగతుల మధ్య 'is-a' ఉపయోగించినట్లయితే మనం ఏదైనా సంబంధాన్ని వారసత్వం అంటాము.
ఉదాహరణకి:
- చిలుక ఒక పక్షి.
- కంప్యూటర్ ఒక యంత్రం.
సింటాక్స్:
C++ ప్రోగ్రామింగ్లో, మేము ఈ క్రింది విధంగా వారసత్వాన్ని ఉపయోగిస్తాము లేదా వ్రాస్తాము:
తరగతి < ఉద్భవించింది - తరగతి >: < యాక్సెస్ - స్పెసిఫైయర్ >< బేస్ - తరగతి >C++ వారసత్వ రీతులు:
వారసత్వం తరగతులను వారసత్వంగా పొందడానికి 3 మోడ్లను కలిగి ఉంటుంది:
- ప్రజా: ఈ మోడ్లో, చైల్డ్ క్లాస్ డిక్లేర్ చేయబడితే, పేరెంట్ క్లాస్లోని సభ్యులు మాతృ తరగతిలో అదే విధంగా చైల్డ్ క్లాస్ ద్వారా వారసత్వంగా పొందబడతారు.
- రక్షిత: I ఈ మోడ్లో, మాతృ తరగతిలోని పబ్లిక్ సభ్యులు చైల్డ్ క్లాస్లో రక్షిత సభ్యులు అవుతారు.
- ప్రైవేట్ : ఈ మోడ్లో, మాతృ తరగతిలోని సభ్యులందరూ పిల్లల తరగతిలో ప్రైవేట్గా మారతారు.
C++ వారసత్వ రకాలు:
C++ వారసత్వం యొక్క రకాలు క్రిందివి:
1. ఒకే వారసత్వం:
ఈ రకమైన వారసత్వంతో, తరగతులు ఒక బేస్ క్లాస్ నుండి ఉద్భవించాయి.
సింటాక్స్:
తరగతి M{
శరీరం
} ;
తరగతి N : పబ్లిక్ M
{
శరీరం
} ;
2. బహుళ వారసత్వం:
ఈ విధమైన వారసత్వంలో, ఒక తరగతి వివిధ బేస్ తరగతుల నుండి సంతరించుకోవచ్చు.
సింటాక్స్:
తరగతి M{
శరీరం
} ;
తరగతి N
{
శరీరం
} ;
తరగతి O : పబ్లిక్ M , పబ్లిక్ ఎన్
{
శరీరం
} ;
3. బహుళస్థాయి వారసత్వం:
ఒక చైల్డ్ క్లాస్ ఈ వారసత్వ రూపంలో మరొక చైల్డ్ క్లాస్ నుండి వచ్చింది.
సింటాక్స్:
తరగతి M{
శరీరం
} ;
తరగతి N : పబ్లిక్ M
{
శరీరం
} ;
తరగతి O : పబ్లిక్ ఎన్
{
శరీరం
} ;
4. క్రమానుగత వారసత్వం:
ఈ వారసత్వ పద్ధతిలో ఒక బేస్ క్లాస్ నుండి అనేక ఉపవర్గాలు సృష్టించబడతాయి.
సింటాక్స్:
తరగతి M{
శరీరం
} ;
తరగతి N : పబ్లిక్ M
{
శరీరం
} ;
తరగతి O : పబ్లిక్ M
{
} ;
5. హైబ్రిడ్ వారసత్వం:
ఈ రకమైన వారసత్వంలో, బహుళ వారసత్వాలు మిళితం చేయబడతాయి.
సింటాక్స్:
తరగతి M{
శరీరం
} ;
తరగతి N : పబ్లిక్ M
{
శరీరం
} ;
తరగతి O
{
శరీరం
} ;
తరగతి పి : పబ్లిక్ ఎన్ , పబ్లిక్ O
{
శరీరం
} ;
ఉదాహరణ:
C++ ప్రోగ్రామింగ్లో మల్టిపుల్ ఇన్హెరిటెన్స్ భావనను ప్రదర్శించడానికి మేము కోడ్ని అమలు చేయబోతున్నాము.
మేము ప్రామాణిక ఇన్పుట్-అవుట్పుట్ లైబ్రరీతో ప్రారంభించినందున, మేము బేస్ క్లాస్ పేరు ‘బర్డ్’ని ఇచ్చాము మరియు దాని సభ్యులను యాక్సెస్ చేయడానికి వీలుగా పబ్లిక్గా చేసాము. అప్పుడు, మాకు బేస్ క్లాస్ 'రెప్టైల్' ఉంది మరియు మేము దానిని పబ్లిక్ చేసాము. అప్పుడు, అవుట్పుట్ను ప్రింట్ చేయడానికి మనకు 'కౌట్' ఉంది. దీని తర్వాత, మేము చైల్డ్ క్లాస్ 'పెంగ్విన్'ని సృష్టించాము. లో ప్రధాన () ఫంక్షన్ మేము క్లాస్ పెంగ్విన్ 'p1' యొక్క వస్తువును చేసాము. మొదట, 'బర్డ్' క్లాస్ ఎగ్జిక్యూట్ చేస్తుంది, ఆపై 'రెప్టైల్' క్లాస్.
C++లో కోడ్ని అమలు చేసిన తర్వాత, మేము బేస్ క్లాస్ల 'బర్డ్' మరియు 'రెప్టైల్' అవుట్పుట్ స్టేట్మెంట్లను పొందుతాము. పెంగ్విన్ ఒక పక్షి మరియు సరీసృపాలు అయినందున 'పెంగ్విన్' అనే తరగతి 'బర్డ్' మరియు 'రెప్టైల్' అనే ప్రాథమిక తరగతుల నుండి ఉద్భవించిందని దీని అర్థం. ఇది ఎగరడంతోపాటు క్రాల్ చేయగలదు. అందువల్ల బహుళ వారసత్వాలు అనేక ప్రాథమిక తరగతుల నుండి ఒక పిల్లల తరగతిని పొందవచ్చని నిరూపించాయి.
ఉదాహరణ:
ఇక్కడ మేము బహుళస్థాయి వారసత్వాన్ని ఎలా ఉపయోగించాలో చూపించడానికి ఒక ప్రోగ్రామ్ను అమలు చేస్తాము.
మేము ఇన్పుట్-అవుట్పుట్ స్ట్రీమ్లను ఉపయోగించడం ద్వారా మా ప్రోగ్రామ్ను ప్రారంభించాము. అప్పుడు, మేము పబ్లిక్గా సెట్ చేయబడిన పేరెంట్ క్లాస్ 'M'ని ప్రకటించాము. మేము పిలిచాము ప్రదర్శన() ఫంక్షన్ మరియు ప్రకటనను ప్రదర్శించడానికి 'cout' కమాండ్. తర్వాత, మేము చైల్డ్ క్లాస్ 'N'ని సృష్టించాము, అది పేరెంట్ క్లాస్ 'M' నుండి తీసుకోబడింది. మేము చైల్డ్ క్లాస్ 'N' నుండి కొత్త చైల్డ్ క్లాస్ 'O'ని కలిగి ఉన్నాము మరియు రెండు ఉత్పన్నమైన తరగతుల శరీరం ఖాళీగా ఉంది. చివరికి, మేము పిలుస్తాము ప్రధాన () ఫంక్షన్లో మనం క్లాస్ 'O' యొక్క ఆబ్జెక్ట్ను ప్రారంభించాలి. ది ప్రదర్శన() ఆబ్జెక్ట్ యొక్క ఫంక్షన్ ఫలితాన్ని ప్రదర్శించడానికి ఉపయోగించబడుతుంది.
ఈ చిత్రంలో, మాతృ తరగతి అయిన 'M' తరగతి ఫలితాన్ని కలిగి ఉన్నాము ఎందుకంటే మనకు a ఉంది ప్రదర్శన() దానిలో పని చేస్తుంది. కాబట్టి, 'N' తరగతి మాతృ తరగతి 'M' నుండి మరియు క్లాస్ 'O' మాతృ తరగతి 'N' నుండి తీసుకోబడింది, ఇది బహుళస్థాయి వారసత్వాన్ని సూచిస్తుంది.
C++ పాలిమార్ఫిజం:
'పాలిమార్ఫిజం' అనే పదం రెండు పదాల సమాహారాన్ని సూచిస్తుంది 'పాలీ' మరియు ' మార్ఫిజం' . 'పాలీ' అనే పదం 'అనేక'ని సూచిస్తుంది మరియు 'మార్ఫిజం' అనేది 'రూపాలను' సూచిస్తుంది. పాలీమార్ఫిజం అంటే ఒక వస్తువు వివిధ పరిస్థితులలో భిన్నంగా ప్రవర్తించవచ్చు. ఇది ప్రోగ్రామర్ని కోడ్ని మళ్లీ ఉపయోగించుకోవడానికి మరియు పొడిగించడానికి అనుమతిస్తుంది. ఒకే కోడ్ పరిస్థితిని బట్టి భిన్నంగా పనిచేస్తుంది. ఆబ్జెక్ట్ను అమలు చేసే సమయంలో అమలు చేయవచ్చు.
పాలిమార్ఫిజం యొక్క వర్గాలు:
పాలిమార్ఫిజం ప్రధానంగా రెండు పద్ధతులలో జరుగుతుంది:
- టైమ్ పాలిమార్ఫిజమ్ను కంపైల్ చేయండి
- రన్ టైమ్ పాలిమార్ఫిజం
వివరిస్తాము.
6. కంపైల్ టైమ్ పాలిమార్ఫిజం:
ఈ సమయంలో, నమోదు చేయబడిన ప్రోగ్రామ్ ఎక్జిక్యూటబుల్ ప్రోగ్రామ్గా మార్చబడుతుంది. కోడ్ యొక్క విస్తరణకు ముందు, లోపాలు గుర్తించబడతాయి. ఇందులో ప్రధానంగా రెండు వర్గాలు ఉన్నాయి.
- ఫంక్షన్ ఓవర్లోడింగ్
- ఆపరేటర్ ఓవర్లోడింగ్
ఈ రెండు వర్గాలను మనం ఎలా ఉపయోగించుకుంటామో చూద్దాం.
7. ఫంక్షన్ ఓవర్లోడింగ్:
ఒక ఫంక్షన్ వివిధ పనులను చేయగలదని దీని అర్థం. ఒకే పేరుతో అనేక విధులు ఉన్నప్పటికీ విభిన్న వాదనలు ఉన్నప్పుడు ఫంక్షన్లను ఓవర్లోడ్ అని పిలుస్తారు.
ముందుగా, మేము లైబ్రరీ
ఆపరేటర్ ఓవర్లోడింగ్:
ఆపరేటర్ యొక్క బహుళ కార్యాచరణలను నిర్వచించే ప్రక్రియను ఆపరేటర్ ఓవర్లోడింగ్ అంటారు.
పై ఉదాహరణ
8. రన్ టైమ్ పాలిమార్ఫిజం:
ఇది కోడ్ రన్ అయ్యే సమయ వ్యవధి. కోడ్ యొక్క ఉపాధి తర్వాత, లోపాలను గుర్తించవచ్చు.
ఫంక్షన్ ఓవర్రైడింగ్:
ఉత్పన్నమైన తరగతి, బేస్ క్లాస్ మెంబర్ ఫంక్షన్లలో ఒకటిగా ఒకే విధమైన ఫంక్షన్ డెఫినిషన్ని ఉపయోగించినప్పుడు ఇది జరుగుతుంది.
మొదటి లైన్లో, ఇన్పుట్ మరియు అవుట్పుట్ ఆపరేషన్లను అమలు చేయడానికి మేము లైబ్రరీ
C++ స్ట్రింగ్స్:
ఇప్పుడు, C++లో స్ట్రింగ్ను ఎలా డిక్లేర్ చేయాలో మరియు ప్రారంభించాలో మేము కనుగొంటాము. ప్రోగ్రామ్లోని అక్షరాల సమూహాన్ని నిల్వ చేయడానికి స్ట్రింగ్ ఉపయోగించబడుతుంది. ఇది ప్రోగ్రామ్లో ఆల్ఫాబెటిక్ విలువలు, అంకెలు మరియు ప్రత్యేక రకం చిహ్నాలను నిల్వ చేస్తుంది. ఇది C++ ప్రోగ్రామ్లో అక్షరాలను శ్రేణిగా రిజర్వ్ చేసింది. C++ ప్రోగ్రామింగ్లో సేకరణ లేదా అక్షరాల కలయికను రిజర్వ్ చేయడానికి శ్రేణులు ఉపయోగించబడతాయి. శ్రేణిని ముగించడానికి శూన్య అక్షరం అని పిలువబడే ప్రత్యేక చిహ్నం ఉపయోగించబడుతుంది. ఇది ఎస్కేప్ సీక్వెన్స్ (\0) ద్వారా సూచించబడుతుంది మరియు ఇది స్ట్రింగ్ ముగింపును పేర్కొనడానికి ఉపయోగించబడుతుంది.
'cin' ఆదేశాన్ని ఉపయోగించి స్ట్రింగ్ను పొందండి:
స్ట్రింగ్ వేరియబుల్లో ఖాళీ స్థలం లేకుండా ఇన్పుట్ చేయడానికి ఇది ఉపయోగించబడుతుంది. ఇచ్చిన సందర్భంలో, 'cin' ఆదేశాన్ని ఉపయోగించి వినియోగదారు పేరును పొందే C++ ప్రోగ్రామ్ను మేము అమలు చేస్తాము.
మొదటి దశలో, మేము
వినియోగదారు 'అహ్మద్ చౌద్రీ' పేరును నమోదు చేస్తారు. కానీ మనకు పూర్తి “అహ్మద్ చౌద్రీ” కంటే అవుట్పుట్గా “అహ్మద్” మాత్రమే వస్తుంది ఎందుకంటే ‘cin’ కమాండ్ ఖాళీ స్థలంతో స్ట్రింగ్ను నిల్వ చేయదు. ఇది స్థలం ముందు విలువను మాత్రమే నిల్వ చేస్తుంది.
cin.get() ఫంక్షన్ని ఉపయోగించడం ద్వారా స్ట్రింగ్ను పొందండి:
ది పొందండి() సిన్ కమాండ్ యొక్క ఫంక్షన్ ఖాళీ ఖాళీలను కలిగి ఉండే కీబోర్డ్ నుండి స్ట్రింగ్ను పొందడానికి ఉపయోగించబడుతుంది.
పై ఉదాహరణలో ఇన్పుట్ మరియు అవుట్పుట్ కార్యకలాపాలను నిర్వహించడానికి
'నా పేరు అలీ' అనే స్ట్రింగ్ వినియోగదారు ద్వారా నమోదు చేయబడింది. cin.get() ఫంక్షన్ ఖాళీ ఖాళీలను కలిగి ఉన్న స్ట్రింగ్లను అంగీకరిస్తుంది కాబట్టి మేము 'మై నేమ్ ఈజ్ అలీ' అనే పూర్తి స్ట్రింగ్ను ఫలితంగా పొందుతాము.
2D (రెండు డైమెన్షనల్) స్ట్రింగ్స్ శ్రేణిని ఉపయోగించడం:
ఈ సందర్భంలో, మేము 2D శ్రేణి స్ట్రింగ్లను ఉపయోగించడం ద్వారా వినియోగదారు నుండి ఇన్పుట్ (మూడు నగరాల పేరు) తీసుకుంటాము.
ముందుగా, మేము హెడర్ ఫైల్
ఇక్కడ, వినియోగదారు మూడు వేర్వేరు నగరాల పేరును నమోదు చేస్తారు. ప్రోగ్రామ్ మూడు స్ట్రింగ్ విలువలను పొందడానికి అడ్డు వరుస సూచికను ఉపయోగిస్తుంది. ప్రతి విలువ దాని స్వంత వరుసలో ఉంచబడుతుంది. మొదటి స్ట్రింగ్ మొదటి వరుసలో మరియు మొదలైన వాటిలో నిల్వ చేయబడుతుంది. అడ్డు వరుస సూచికను ఉపయోగించడం ద్వారా ప్రతి స్ట్రింగ్ విలువ అదే విధంగా ప్రదర్శించబడుతుంది.
C++ ప్రామాణిక లైబ్రరీ:
C++ లైబ్రరీ అనేది అనేక విధులు, తరగతులు, స్థిరాంకాలు మరియు అన్ని సంబంధిత అంశాల యొక్క క్లస్టర్ లేదా సమూహంగా ఉంటుంది, ఇది దాదాపు ఒక సరైన సెట్లో జతచేయబడి, ఎల్లప్పుడూ ప్రామాణిక హెడర్ ఫైల్లను నిర్వచిస్తుంది మరియు ప్రకటిస్తుంది. వీటి అమలులో
స్టాండర్డ్ లైబ్రరీ ప్రోగ్రామింగ్ చేస్తున్నప్పుడు సూచనలను తిరిగి వ్రాయడం యొక్క హస్ల్ను తొలగిస్తుంది. దీని లోపల అనేక లైబ్రరీలు ఉన్నాయి, ఇవి అనేక ఫంక్షన్ల కోసం కోడ్ను నిల్వ చేస్తాయి. ఈ లైబ్రరీలను సద్వినియోగం చేసుకోవడానికి, వాటిని హెడర్ ఫైల్ల సహాయంతో లింక్ చేయడం తప్పనిసరి. మేము ఇన్పుట్ లేదా అవుట్పుట్ లైబ్రరీని దిగుమతి చేసినప్పుడు, మేము ఆ లైబ్రరీలో నిల్వ చేయబడిన మొత్తం కోడ్ను దిగుమతి చేసుకుంటున్నామని దీని అర్థం మరియు మీరు అవసరం లేని అన్ని అంతర్లీన కోడ్ను దాచడం ద్వారా దానిలో జతచేయబడిన ఫంక్షన్లను కూడా మేము ఉపయోగించవచ్చు. చూడండి.
C++ ప్రామాణిక లైబ్రరీ క్రింది రెండు రకాలకు మద్దతు ఇస్తుంది:
- C++ ISO ప్రమాణం ద్వారా వివరించబడిన అన్ని ముఖ్యమైన ప్రామాణిక లైబ్రరీ హెడర్ ఫైల్లను అందించే హోస్ట్ చేసిన అమలు.
- ప్రామాణిక లైబ్రరీ నుండి హెడర్ ఫైల్లలో కొంత భాగం మాత్రమే అవసరమయ్యే స్వతంత్ర అమలు. తగిన ఉపసమితి:
<అణువు> (కనీసం ప్రకటించడం Atomic_signed_lock_free మరియు atomic-unsigned_lock_free) |
|
<పరిధులు> |
<బిట్> | |
<నిష్పత్తి> |
|
<మినహాయింపు> | |
|
<ఫంక్షనల్> | |
<పోల్చండి> | |
|
<భావనలు> | <ఇటరేటర్> | |
<కోరూటిన్> | <పరిమితులు> | <ఉపయోగం> |
<కొత్త> |
| |
|
<జ్ఞాపకం> | <వెర్షన్> |
గత 11 C++ వచ్చినప్పటి నుండి కొన్ని హెడర్ ఫైల్లు విచారించబడ్డాయి: అవి
హోస్ట్ చేయబడిన మరియు ఫ్రీస్టాండింగ్ ఇంప్లిమెంటేషన్ల మధ్య తేడాలు క్రింద ఉదహరించబడ్డాయి:
- హోస్ట్ చేసిన ఇంప్లిమెంటేషన్లో, మనం ప్రధాన విధి అయిన గ్లోబల్ ఫంక్షన్ని ఉపయోగించాలి. ఫ్రీస్టాండింగ్ ఇంప్లిమెంటేషన్లో ఉన్నప్పుడు, యూజర్ తనంతట తానుగా ప్రారంభ మరియు ముగింపు ఫంక్షన్లను ప్రకటించవచ్చు మరియు నిర్వచించవచ్చు.
- హోస్టింగ్ అమలులో సరిపోలే సమయంలో ఒక థ్రెడ్ తప్పనిసరి అమలులో ఉంటుంది. అయితే, ఫ్రీస్టాండింగ్ ఇంప్లిమెంటేషన్లో, ఇంప్లిమెంటర్లు తమ లైబ్రరీలో కాకరెంట్ థ్రెడ్ మద్దతు అవసరమా అని నిర్ణయించుకుంటారు.
రకాలు:
ఫ్రీస్టాండింగ్ మరియు హోస్ట్ రెండింటికీ C++ మద్దతు ఉంది. హెడర్ ఫైల్లు క్రింది రెండుగా విభజించబడ్డాయి:
- Iostream భాగాలు
- C++ STL భాగాలు (ప్రామాణిక లైబ్రరీ)
మేము C++లో ఎగ్జిక్యూషన్ కోసం ప్రోగ్రామ్ను వ్రాస్తున్నప్పుడల్లా, ఇప్పటికే STL లోపల అమలు చేయబడిన ఫంక్షన్లను మేము ఎల్లప్పుడూ పిలుస్తాము. గుర్తించబడిన ఆపరేటర్లను సమర్థతతో ఉపయోగించి ఇన్పుట్ మరియు డిస్ప్లే అవుట్పుట్ని ఈ తెలిసిన ఫంక్షన్లు తీసుకుంటాయి.
చరిత్రను పరిశీలిస్తే, STLని మొదట్లో స్టాండర్డ్ టెంప్లేట్ లైబ్రరీ అని పిలిచేవారు. అప్పుడు, STL లైబ్రరీ యొక్క భాగాలు ఈ రోజుల్లో ఉపయోగించబడుతున్న C++ యొక్క ప్రామాణిక లైబ్రరీలో ప్రమాణీకరించబడ్డాయి. వీటిలో ISO C++ రన్టైమ్ లైబ్రరీ మరియు బూస్ట్ లైబ్రరీ నుండి కొన్ని ఇతర ముఖ్యమైన కార్యాచరణలు ఉన్నాయి. అప్పుడప్పుడు STL అనేది C++ స్టాండర్డ్ లైబ్రరీ యొక్క కంటైనర్లను లేదా మరింత తరచుగా అల్గారిథమ్లను సూచిస్తుంది. ఇప్పుడు, ఈ STL లేదా స్టాండర్డ్ టెంప్లేట్ లైబ్రరీ పూర్తిగా తెలిసిన C++ స్టాండర్డ్ లైబ్రరీ గురించి మాట్లాడుతుంది.
std నేమ్స్పేస్ మరియు హెడర్ ఫైల్లు:
ఫంక్షన్లు లేదా వేరియబుల్స్ యొక్క అన్ని డిక్లరేషన్లు వాటి మధ్య సమానంగా పంపిణీ చేయబడిన హెడర్ ఫైల్ల సహాయంతో ప్రామాణిక లైబ్రరీలో చేయబడతాయి. మీరు హెడర్ ఫైల్లను చేర్చకపోతే డిక్లరేషన్ జరగదు.
ఎవరైనా జాబితాలు మరియు స్ట్రింగ్లను ఉపయోగిస్తున్నారని అనుకుందాం, అతను క్రింది హెడర్ ఫైల్లను జోడించాలి:
##
- చేర్చండి
ఈ కోణీయ బ్రాకెట్లు '<>' అనేది నిర్వచించబడిన మరియు చేర్చబడిన డైరెక్టరీలో ఈ నిర్దిష్ట హెడర్ ఫైల్ను తప్పక చూడాలని సూచిస్తుంది. ఈ లైబ్రరీకి ఎవరైనా '.h' పొడిగింపును కూడా జోడించవచ్చు, ఇది అవసరమైతే లేదా కావాలనుకుంటే చేయబడుతుంది. మనం ‘.h’ లైబ్రరీని మినహాయిస్తే, ఈ హెడర్ ఫైల్ C లైబ్రరీకి చెందినదని సూచించే విధంగా, ఫైల్ పేరు ప్రారంభానికి ముందు మనకు అదనంగా ‘c’ అవసరం. ఉదాహరణకు, మీరు వ్రాయవచ్చు (#include
నేమ్స్పేస్ గురించి చెప్పాలంటే, మొత్తం C++ స్టాండర్డ్ లైబ్రరీ ఈ నేమ్స్పేస్లో stdగా సూచించబడుతుంది. ప్రామాణిక లైబ్రరీ పేర్లను వినియోగదారులు సమర్థంగా నిర్వచించడానికి ఇది కారణం. ఉదాహరణకి:
Std :: కోట్ << 'ఇది దాటిపోతుంది !/ n' ;C++ వెక్టర్స్:
C++లో డేటా లేదా విలువలను నిల్వ చేయడానికి అనేక మార్గాలు ఉన్నాయి. కానీ ప్రస్తుతానికి, మేము C++ భాషలో ప్రోగ్రామ్లను వ్రాసేటప్పుడు విలువలను నిల్వ చేయడానికి సులభమైన మరియు అత్యంత సౌకర్యవంతమైన మార్గం కోసం చూస్తున్నాము. కాబట్టి, వెక్టర్స్ అనేవి శ్రేణి నమూనాలో సరిగ్గా సీక్వెన్స్ చేయబడిన కంటైనర్లు, దీని పరిమాణం ఎలిమెంట్ల చొప్పించడం మరియు తగ్గింపుపై ఆధారపడి అమలు సమయంలో మారుతూ ఉంటుంది. ప్రోగ్రామ్ అమలు సమయంలో ప్రోగ్రామర్ తన కోరిక ప్రకారం వెక్టర్ పరిమాణాన్ని మార్చగలడని దీని అర్థం. అవి శ్రేణులను పోలి ఉంటాయి, అవి వాటి చేర్చబడిన మూలకాల కోసం సమాచార నిల్వ స్థానాలను కూడా కలిగి ఉంటాయి. వెక్టర్స్ లోపల ఉన్న విలువలు లేదా మూలకాల సంఖ్యను తనిఖీ చేయడానికి, మనం 'ని ఉపయోగించాలి. std::కౌంట్' ఫంక్షన్. వెక్టర్స్ C++ యొక్క స్టాండర్డ్ టెంప్లేట్ లైబ్రరీలో చేర్చబడ్డాయి కాబట్టి ఇది ఒక ఖచ్చితమైన హెడర్ ఫైల్ను కలిగి ఉంది, అది ముందుగా చేర్చాల్సిన అవసరం ఉంది:
#ప్రకటన:
వెక్టర్ యొక్క డిక్లరేషన్ క్రింద చూపబడింది.
Std :: వెక్టర్ < DT > పేరు ఆఫ్ వెక్టర్ ;ఇక్కడ, వెక్టర్ అనేది ఉపయోగించిన కీవర్డ్, DT అనేది వెక్టార్ యొక్క డేటా రకాన్ని చూపుతోంది, దీనిని Int, float, char లేదా ఏదైనా ఇతర సంబంధిత డేటాటైప్లతో భర్తీ చేయవచ్చు. పై డిక్లరేషన్ని ఇలా తిరిగి వ్రాయవచ్చు:
వెక్టర్ < తేలుతుంది > శాతం ;వెక్టార్ యొక్క పరిమాణం పేర్కొనబడలేదు ఎందుకంటే అమలు సమయంలో పరిమాణం పెరగవచ్చు లేదా తగ్గవచ్చు.
వెక్టర్స్ ప్రారంభించడం:
వెక్టర్స్ ప్రారంభానికి, C++లో ఒకటి కంటే ఎక్కువ మార్గాలు ఉన్నాయి.
సాంకేతికత సంఖ్య 1:
వెక్టర్ < int > v1 = { 71 , 98 , 3. 4 , 65 } ;వెక్టర్ < int > v2 = { 71 , 98 , 3. 4 , 65 } ;
ఈ విధానంలో, మేము రెండు వెక్టర్లకు నేరుగా విలువలను కేటాయిస్తున్నాము. రెండింటికి కేటాయించిన విలువలు సరిగ్గా సమానంగా ఉంటాయి.
సాంకేతికత సంఖ్య 2:
వెక్టర్ < int > v3 ( 3 , పదిహేను ) ;ఈ ప్రారంభ ప్రక్రియలో, 3 అనేది వెక్టర్ యొక్క పరిమాణాన్ని నిర్దేశిస్తుంది మరియు 15 అనేది దానిలో నిల్వ చేయబడిన డేటా లేదా విలువ. 15 విలువను నిల్వ చేసే 3 యొక్క ఇవ్వబడిన పరిమాణంతో డేటాటైప్ 'int' యొక్క వెక్టర్ సృష్టించబడుతుంది అంటే వెక్టర్ 'v3' కింది వాటిని నిల్వ చేస్తుంది:
వెక్టర్ < int > v3 = { పదిహేను , పదిహేను , పదిహేను } ;ప్రధాన కార్యకలాపాలు:
వెక్టర్ క్లాస్ లోపల వెక్టర్స్పై మేము అమలు చేయబోయే ప్రధాన కార్యకలాపాలు:
- విలువను జోడిస్తోంది
- విలువను యాక్సెస్ చేస్తోంది
- విలువను మార్చడం
- విలువను తొలగిస్తోంది
చేరిక మరియు తొలగింపు:
వెక్టార్ లోపల మూలకాల జోడింపు మరియు తొలగింపు క్రమపద్ధతిలో జరుగుతుంది. చాలా సందర్భాలలో, వెక్టార్ కంటైనర్ల ముగింపులో మూలకాలు చొప్పించబడతాయి, అయితే మీరు కోరుకున్న స్థలంలో విలువలను కూడా జోడించవచ్చు, ఇది చివరికి ఇతర మూలకాలను వాటి కొత్త స్థానాలకు మారుస్తుంది. అయితే, తొలగింపులో, చివరి స్థానం నుండి విలువలు తొలగించబడినప్పుడు, అది స్వయంచాలకంగా కంటైనర్ పరిమాణాన్ని తగ్గిస్తుంది. కానీ కంటైనర్లోని విలువలు నిర్దిష్ట స్థానం నుండి యాదృచ్ఛికంగా తొలగించబడినప్పుడు, కొత్త స్థానాలు స్వయంచాలకంగా ఇతర విలువలకు కేటాయించబడతాయి.
ఉపయోగించిన విధులు:
వెక్టార్ లోపల నిల్వ చేయబడిన విలువలను మార్చడానికి లేదా మార్చడానికి, మాడిఫైయర్లు అని పిలువబడే కొన్ని ముందే నిర్వచించబడిన ఫంక్షన్లు ఉన్నాయి. అవి క్రింది విధంగా ఉన్నాయి:
- ఇన్సర్ట్(): ఇది ఒక నిర్దిష్ట ప్రదేశంలో వెక్టార్ కంటైనర్ లోపల విలువను జోడించడానికి ఉపయోగించబడుతుంది.
- ఎరేస్(): ఇది ఒక నిర్దిష్ట ప్రదేశంలో వెక్టార్ కంటైనర్లోని విలువను తీసివేయడం లేదా తొలగించడం కోసం ఉపయోగించబడుతుంది.
- Swap(): ఇది అదే డేటా రకానికి చెందిన వెక్టార్ కంటైనర్లోని విలువల స్వాప్ కోసం ఉపయోగించబడుతుంది.
- కేటాయించండి(): ఇది వెక్టార్ కంటైనర్లో గతంలో నిల్వ చేసిన విలువకు కొత్త విలువను కేటాయించడానికి ఉపయోగించబడుతుంది.
- ప్రారంభం(): ఇది మొదటి మూలకం లోపల వెక్టర్ యొక్క మొదటి విలువను సూచించే లూప్ లోపల ఇటరేటర్ను తిరిగి ఇవ్వడానికి ఉపయోగించబడుతుంది.
- క్లియర్(): ఇది వెక్టార్ కంటైనర్లో నిల్వ చేయబడిన అన్ని విలువలను తొలగించడానికి ఉపయోగించబడుతుంది.
- పుష్_బ్యాక్(): ఇది వెక్టార్ కంటైనర్ ముగింపులో విలువను జోడించడానికి ఉపయోగించబడుతుంది.
- Pop_back(): ఇది వెక్టార్ కంటైనర్ ముగింపులో విలువను తొలగించడానికి ఉపయోగించబడుతుంది.
ఉదాహరణ:
ఈ ఉదాహరణలో, వెక్టర్ల వెంట మాడిఫైయర్లు ఉపయోగించబడతాయి.
ముందుగా, మేము
అవుట్పుట్ క్రింద చూపబడింది.
C++ ఫైల్స్ ఇన్పుట్ అవుట్పుట్:
ఫైల్ అనేది పరస్పర సంబంధం ఉన్న డేటా యొక్క అసెంబ్లేజ్. C++లో, ఫైల్ అనేది కాలక్రమానుసారం కలిసి సేకరించబడిన బైట్ల శ్రేణి. చాలా ఫైల్లు డిస్క్లో ఉన్నాయి. కానీ మాగ్నెటిక్ టేప్లు, ప్రింటర్లు మరియు కమ్యూనికేషన్ లైన్లు వంటి హార్డ్వేర్ పరికరాలు కూడా ఫైల్లలో చేర్చబడ్డాయి.
ఫైల్లలోని ఇన్పుట్ మరియు అవుట్పుట్ మూడు ప్రధాన తరగతుల ద్వారా వర్గీకరించబడతాయి:
- ఇన్పుట్ తీసుకోవడానికి 'istream' క్లాస్ ఉపయోగించబడుతుంది.
- అవుట్పుట్ని ప్రదర్శించడానికి 'ఓస్ట్రీమ్' క్లాస్ ఉపయోగించబడింది.
- ఇన్పుట్ మరియు అవుట్పుట్ కోసం, 'iostream' తరగతిని ఉపయోగించండి.
ఫైల్లు C++లో స్ట్రీమ్లుగా నిర్వహించబడతాయి. మేము ఫైల్లో లేదా ఫైల్ నుండి ఇన్పుట్ మరియు అవుట్పుట్ తీసుకుంటున్నప్పుడు, ఈ క్రింది తరగతులు ఉపయోగించబడతాయి:
- ఆఫ్స్ట్రీమ్: ఇది ఫైల్లో వ్రాయడానికి ఉపయోగించే స్ట్రీమ్ క్లాస్.
- Ifstream: ఇది ఫైల్ నుండి కంటెంట్ను చదవడానికి ఉపయోగించబడే స్ట్రీమ్ క్లాస్.
- స్ట్రీమ్: ఇది ఫైల్లో లేదా ఫైల్ నుండి చదవడం మరియు వ్రాయడం రెండింటికీ ఉపయోగించే స్ట్రీమ్ క్లాస్.
'ఇస్ట్రీమ్' మరియు 'ఓస్ట్రీమ్' తరగతులు పైన పేర్కొన్న అన్ని తరగతులకు పూర్వీకులు. ఈ ఫైల్ స్ట్రీమ్లను ఇతర ఫైల్లకు అనుబంధించడంలో తేడాతో ఫైల్ స్ట్రీమ్లు 'సిన్' మరియు 'కౌట్' కమాండ్ల వలె ఉపయోగించడానికి సులభమైనవి. 'fstream' తరగతి గురించి క్లుప్తంగా అధ్యయనం చేయడానికి ఒక ఉదాహరణ చూద్దాం:
ఉదాహరణ:
ఈ సందర్భంలో, మేము ఫైల్లో డేటాను వ్రాస్తున్నాము.
మేము మొదటి దశలో ఇన్పుట్ మరియు అవుట్పుట్ స్ట్రీమ్ను ఏకీకృతం చేస్తున్నాము. మేము ఫైల్ నుండి డేటాను వ్రాయడానికి మరియు చదవబోతున్నందున హెడర్ ఫైల్
ఫైల్ 'ఉదాహరణ' వ్యక్తిగత కంప్యూటర్ నుండి తెరవబడుతుంది మరియు ఫైల్పై వ్రాసిన టెక్స్ట్ పైన చూపిన విధంగా ఈ టెక్స్ట్ ఫైల్లో ముద్రించబడుతుంది.
ఫైల్ను తెరవడం:
ఫైల్ తెరిచినప్పుడు, అది స్ట్రీమ్ ద్వారా సూచించబడుతుంది. మునుపటి ఉదాహరణలో New_File సృష్టించబడినట్లుగా ఫైల్ కోసం ఒక వస్తువు సృష్టించబడింది. స్ట్రీమ్లో చేసిన అన్ని ఇన్పుట్ మరియు అవుట్పుట్ ఆపరేషన్లు ఫైల్కు స్వయంచాలకంగా వర్తించబడతాయి. ఫైల్ తెరవడానికి, ఓపెన్() ఫంక్షన్ ఇలా ఉపయోగించబడుతుంది:
తెరవండి ( NameOfFile , మోడ్ ) ;ఇక్కడ, మోడ్ తప్పనిసరి కాదు.
ఫైల్ను మూసివేయడం:
అన్ని ఇన్పుట్ మరియు అవుట్పుట్ ఆపరేషన్లు పూర్తయిన తర్వాత, ఎడిటింగ్ కోసం తెరిచిన ఫైల్ను మనం మూసివేయాలి. మేము aని నియమించుకోవాలి దగ్గరగా() ఈ పరిస్థితిలో పని చేయండి.
కొత్త_ఫైల్. దగ్గరగా ( ) ;ఇది పూర్తయినప్పుడు, ఫైల్ అందుబాటులో ఉండదు. ఏదైనా సందర్భంలో ఆబ్జెక్ట్ నాశనమైతే, ఫైల్కి లింక్ చేయబడినప్పటికీ, డిస్ట్రక్టర్ ఆకస్మికంగా క్లోజ్() ఫంక్షన్కి కాల్ చేస్తుంది.
టెక్స్ట్ ఫైల్స్:
వచనాన్ని నిల్వ చేయడానికి టెక్స్ట్ ఫైల్లు ఉపయోగించబడతాయి. కాబట్టి, టెక్స్ట్ ఎంటర్ చేసినా లేదా ప్రదర్శించబడినా దానికి కొన్ని ఫార్మాటింగ్ మార్పులు ఉంటాయి. టెక్స్ట్ ఫైల్ లోపల వ్రాత ఆపరేషన్ మనం 'cout' కమాండ్ను అమలు చేసినట్లే ఉంటుంది.
ఉదాహరణ:
ఈ దృష్టాంతంలో, మేము మునుపటి ఉదాహరణలో ఇప్పటికే రూపొందించిన టెక్స్ట్ ఫైల్లో డేటాను వ్రాస్తున్నాము.
ఇక్కడ, మేము New_File() ఫంక్షన్ని ఉపయోగించి 'ఉదాహరణ' అనే ఫైల్లో డేటాను వ్రాస్తున్నాము. మేము 'ఉదాహరణ' ఫైల్ని ఉపయోగించడం ద్వారా తెరుస్తాము ఓపెన్() పద్ధతి. ఫైల్కి డేటాను జోడించడానికి 'ఆఫ్స్ట్రీమ్' ఉపయోగించబడుతుంది. ఫైల్ లోపల అన్ని పనులు చేసిన తర్వాత, అవసరమైన ఫైల్ను ఉపయోగించడం ద్వారా మూసివేయబడుతుంది దగ్గరగా() ఫంక్షన్. ఫైల్ తెరవకపోతే 'ఫైల్ సపోర్ట్ లేదు, ఫైల్ను లోడ్ చేస్తున్నప్పుడు ఎర్రర్' అనే ఎర్రర్ మెసేజ్ చూపబడుతుంది.
ఫైల్ తెరుచుకుంటుంది మరియు టెక్స్ట్ కన్సోల్లో ప్రదర్శించబడుతుంది.
టెక్స్ట్ ఫైల్ చదవడం:
ఫైల్ యొక్క రీడింగ్ తదుపరి ఉదాహరణ సహాయంతో చూపబడుతుంది.
ఉదాహరణ:
ఫైల్ లోపల నిల్వ చేయబడిన డేటాను చదవడానికి 'ifstream' ఉపయోగించబడుతుంది.
ఉదాహరణలో మొదటి ప్రధాన శీర్షిక ఫైల్లు
టెక్స్ట్ ఫైల్ లోపల నిల్వ చేయబడిన మొత్తం సమాచారం చూపిన విధంగా స్క్రీన్పై ప్రదర్శించబడుతుంది.
ముగింపు
పై గైడ్లో, మేము C++ భాష గురించి వివరంగా తెలుసుకున్నాము. ఉదాహరణలతో పాటు, ప్రతి అంశం ప్రదర్శించబడుతుంది మరియు వివరించబడింది మరియు ప్రతి చర్య విశదీకరించబడింది.