శ్రేణి మరియు పాయింటర్ మధ్య వ్యత్యాసం
విషయము
శ్రేణి మరియు పాయింటర్ మధ్య సన్నిహిత సంబంధం ఉంది. పాయింటర్ శ్రేణి మూలకాలను ప్రాప్యత చేయడానికి ఉపయోగించవచ్చు, పాయింటర్ అంకగణితాన్ని ఉపయోగించి మొత్తం శ్రేణిని ప్రాప్యత చేస్తుంది, ప్రాప్యతను వేగంగా చేస్తుంది. పాయింటర్ మరియు శ్రేణి మధ్య ప్రాథమిక వ్యత్యాసం ఉంది, అంటే శ్రేణి అనేది సారూప్య డేటా రకం యొక్క వేరియబుల్స్ యొక్క సమాహారం, అయితే పాయింటర్ మరొక వేరియబుల్ యొక్క చిరునామాను నిల్వ చేసే వేరియబుల్. పోలిక చార్టులో క్రింద చర్చించబడిన శ్రేణి మరియు పాయింటర్ మధ్య కొన్ని ఇతర తేడాలు ఉన్నాయి.
- పోలిక చార్ట్
- నిర్వచనం
- కీ తేడాలు
- ముగింపు
పోలిక చార్ట్
| పోలిక కోసం ఆధారం | అమరిక | పాయింటర్ |
|---|---|---|
| ప్రకటన | // సి ++ లో var_name టైప్ చేయండి; // జావాలో. var-name టైప్ చేయండి; var_name = క్రొత్త రకం; | // సి ++ లో రకం * var_name; |
| వర్కింగ్ | సజాతీయ డేటాటైప్ యొక్క వేరియబుల్ విలువను నిల్వ చేస్తుంది. | పాయింటర్ వేరియబుల్స్ డేటాటైప్ వలె అదే డేటాటైప్ యొక్క మరొక వేరియబుల్ యొక్క చిరునామాను నిల్వ చేయండి. |
| జనరేషన్ | పాయింటర్ల శ్రేణిని సృష్టించవచ్చు. | శ్రేణికి పాయింటర్ సృష్టించబడుతుంది. |
| జావా మద్దతు | శ్రేణి యొక్క భావనకు మద్దతు ఇవ్వండి. | పాయింటర్లకు మద్దతు ఇవ్వదు. |
| నిల్వ | ఒక సాధారణ శ్రేణి వేరియబుల్ యొక్క విలువలను నిల్వ చేస్తుంది మరియు పాయింటర్ శ్రేణి వేరియబుల్స్ యొక్క చిరునామాను నిల్వ చేస్తుంది. | పాయింటర్లు వేరియబుల్స్ చిరునామాను నిల్వ చేయడానికి ప్రత్యేకంగా రూపొందించబడ్డాయి. |
| కెపాసిటీ | శ్రేణి వేరియబుల్ యొక్క పరిమాణంలో పేర్కొన్న మూలకాల సంఖ్యను నిల్వ చేయవచ్చు. | పాయింటర్ వేరియబుల్ ఒకేసారి ఒక వేరియబుల్ యొక్క చిరునామాను మాత్రమే నిల్వ చేయగలదు. |
అర్రే యొక్క నిర్వచనం
శ్రేణి అంటే ఒకే డేటాటైప్ యొక్క మూలకాల సమాహారం, మరియు ఈ మూలకాలన్నీ ఒక సాధారణ పేరుతో సూచించబడతాయి, ఇది శ్రేణి వేరియబుల్ పేరు. ఆ మూలకం నిల్వ చేయబడిన ఆ శ్రేణి యొక్క నిర్దిష్ట సూచికను యాక్సెస్ చేయడం ద్వారా ఒక నిర్దిష్ట శ్రేణి మూలకాన్ని ప్రాప్తి చేయవచ్చు.అరేలు ఒక డైమెన్షనల్ అర్రే, రెండు డైమెన్షనల్ అర్రే లేదా మల్టీ డైమెన్షనల్ అర్రే కావచ్చు. పాయింటర్ల శ్రేణిని కూడా సృష్టించవచ్చు, అనగా అన్ని వేరియబుల్‌ను పాయింటర్ వేరియబుల్‌గా కలిగి ఉన్న శ్రేణి. ‘సి ++’ లో శ్రేణులు స్థిరంగా కేటాయించబడతాయి, అయితే ‘జావా’ లో శ్రేణులు డైనమిక్‌గా కేటాయించబడతాయి.
// సి ++ రకం var_name; // జావాలో. var-name టైప్ చేయండి; var_name = క్రొత్త రకం;
ఇక్కడ 'రకం' శ్రేణి వేరియబుల్ యొక్క డేటా రకాన్ని సూచిస్తుంది, 'var_name' శ్రేణి వేరియబుల్‌కు ఇచ్చిన పేరును సూచిస్తుంది, 'పరిమాణం' శ్రేణి వేరియబుల్ యొక్క సామర్థ్యాన్ని సూచిస్తుంది, అంటే ఆ శ్రేణి వేరియబుల్‌లో 'రకం' యొక్క ఎన్ని అంశాలను నిల్వ చేయవచ్చు . శ్రేణిని ప్రాప్తి చేయడానికి రెండు పద్ధతులు ఉన్నాయి, మొదటి ‘పాయింటర్ అంకగణితం’ మరియు రెండవ ‘శ్రేణి సూచిక’, వీటిలో ‘పాయింటర్ అంకగణితం’ వేగంగా ఉంటుంది.
// పాయింటర్ అంకగణిత Void display_array (int * S) {ను ఉపయోగించి యాక్సెస్ (* లు) {cout (<< "విలువ" << * s); * S ++; }}
‘అర్రే ఇండెక్సింగ్’ తో పోలిస్తే ‘పాయింటర్ అంకగణితం’ ఉపయోగించడం వేగంగా పని చేస్తుంది, అనగా అర్రే వేరియబుల్‌ను దాని ఇండెక్స్ ఉపయోగించి యాక్సెస్ చేస్తుంది. మీరు ఒక ఫంక్షన్‌లోకి పాయింటర్ల శ్రేణిని పాస్ చేయవలసి వస్తే, మీరు ఒక సాధారణ శ్రేణిని పాస్ చేయడానికి ఉపయోగించే అదే పద్ధతిని ఉపయోగించడం ద్వారా చేయవచ్చు, అనగా ఫంక్షన్‌ను ఏ ఇండెక్స్ లేకుండా నేరుగా అర్రే పేరుతో కాల్ చేయండి.
దానిని ఉదాహరణతో అర్థం చేసుకుందాం
// పాయింటర్ల శ్రేణిని ప్రకటించడం. int * p;
ఇక్కడ, ఇది ‘p’ అనేది పూర్ణాంక రకం యొక్క శ్రేణి అని చూపిస్తుంది, ఇది పూర్ణాంక రకం యొక్క 10 వేరియబుల్ యొక్క చిరునామాను కలిగి ఉంటుంది. పై పాయింటర్ శ్రేణిని ఫంక్షన్ డిస్ప్లే () లోకి పాస్ చేద్దాం.
ప్రదర్శన (p); // ఫంక్షన్ డిస్ప్లేకి కాల్ చేయండి. శూన్య ప్రదర్శన (int * d) {// పాయింటర్ శ్రేణిని స్వీకరించే ఫంక్షన్. (int i = 0; i <10; i ++) {cout << ("index" <
ఈ ఫంక్షన్ వేరియబుల్స్లో ఉన్న విలువలను ప్రదర్శిస్తుంది, దీని చిరునామాలు ఈ పాయింటర్ శ్రేణిలో వరుసగా నిల్వ చేయబడతాయి.
పాయింటర్ యొక్క నిర్వచనం
పాయింటర్ మరొక వేరియబుల్ యొక్క మెమరీ చిరునామాను కలిగి ఉన్న వేరియబుల్. రెండింటి యొక్క డేటాటైప్, పాయింటర్ వేరియబుల్ మరియు పాయింటర్ వేరియబుల్‌కు చిరునామా కేటాయించబడుతున్న వేరియబుల్ ఒకే విధంగా ఉండాలి. పాయింటర్ వేరియబుల్ ఫాలోగా ప్రకటించబడింది.
// సి ++ రకం * పేరులో ప్రకటన;
ఇక్కడ, ‘రకం’ అనేది డేటాటైప్, ‘పేరు’ అనేది పాయింటర్ వేరియబుల్ పేరు. పాయింటర్ వేరియబుల్‌లో ఏ రకమైన వేరియబుల్ చిరునామాను నిల్వ చేయవచ్చో ‘రకం’ నిర్వచిస్తుంది. ఉదాహరణకు, పూర్ణాంక పాయింటర్ పూర్ణాంక వేరియబుల్ యొక్క చిరునామాను నిల్వ చేస్తుంది. ‘*’ మరియు ‘&’ అనే రెండు పాయింటర్ ఆపరేటర్లు ఉన్నారు. ఆపరేటర్ ‘*’ చిరునామా వద్ద ఉన్న విలువను తిరిగి ఇస్తుంది, ఇది వేరియబుల్‌లో నిల్వ చేయబడుతుంది, తరువాత ‘*’ గుర్తు ఉంటుంది. ‘&’ ఆపరేటర్ వేరియబుల్ యొక్క చిరునామాను తిరిగి ‘&’ గుర్తును అందిస్తుంది.
// ఉదాహరణకు int b = 10 int a = & b; // ఇక్కడ b యొక్క చిరునామా వేరియబుల్ a లో నిల్వ చేయబడుతుంది. // b యొక్క చిరునామా 2000 అని అనుమతిస్తుంది, కాబట్టి ఇప్పుడు a = 2000. int c = * a; // ఇక్కడ, పూర్ణాంక పాయింటర్ వేరియబుల్ * a .ie లో నిల్వ చేసిన చిరునామా వద్ద ఉన్న విలువను తిరిగి ఇస్తుంది. c = 10.
మీరు పాయింటర్లలో ఉపయోగించగల రెండు అంకగణిత ఆపరేటర్లు మాత్రమే ఉన్నారు, అనగా అదనంగా మరియు వ్యవకలనం. మీరు పూర్ణాంక పాయింటర్ వేరియబుల్‌పై ఇంక్రిమెంట్‌ను వర్తింపజేస్తే, అది డేటాటైప్ పరిమాణం ద్వారా పెరుగుతుంది, అనగా 2 బైట్‌ల ద్వారా, ఇది పూర్ణాంక పాయింటర్ కాబట్టి, ఇంక్రిమెంట్‌పై అది తదుపరి పూర్ణాంక వేరియబుల్‌ను సూచించాల్సి ఉంటుంది. క్షీణత విషయంలో కూడా అదే.
// p అనేది పూర్ణాంక పాయింటర్ కాంటాయింగ్ విలువ 2000. p ++; // ఇప్పుడు p = 2002. p--; // ఇప్పుడు p మళ్ళీ రెండు బైట్లు తగ్గినట్లు 2000 ను కలిగి ఉంది.
- ఒక శ్రేణి సారూప్య డేటా రకాలను వేరియబుల్స్ నిల్వ చేస్తుంది మరియు వేరియబుల్స్ యొక్క డేటా రకాలు శ్రేణి రకానికి సరిపోలాలి. మరోవైపు, పాయింటర్ వేరియబుల్ ఒక రకమైన పాయింటర్ వేరియబుల్ రకానికి సమానమైన ఒక వేరియబుల్ యొక్క చిరునామాను నిల్వ చేస్తుంది.
- మేము పాయింటర్ల శ్రేణిని సృష్టించవచ్చు, అనగా శ్రేణి దీని వేరియబుల్స్ పాయింటర్ వేరియబుల్స్. మరోవైపు, మేము శ్రేణిని సూచించే పాయింటర్‌ను సృష్టించవచ్చు.
- జావా శ్రేణికి మద్దతు ఇస్తుంది, కానీ ఇది పాయింటర్లకు మద్దతు ఇవ్వదు.
- శ్రేణి పరిమాణం అది నిల్వ చేయగల వేరియబుల్స్ సంఖ్యను నిర్ణయిస్తుంది; పాయింటర్ వేరియబుల్ వేరియబుల్ యొక్క చిరునామాను మాత్రమే నిల్వ చేస్తుంది
గమనిక:
జావా పాయింటర్లకు మద్దతు ఇవ్వదు లేదా ఖచ్చితంగా నివారించదు.
ముగింపు:
సారూప్య డేటా రకం యొక్క డేటా ఎలిమెంట్స్‌పై మనం పని చేయాల్సిన అవసరం వచ్చినప్పుడు, వేరియబుల్స్‌పై విడిగా పనిచేయడానికి బదులుగా, సారూప్య డేటా రకాల వేరియబుల్స్ యొక్క శ్రేణిని సృష్టించవచ్చు మరియు దానిపై పనిచేయవచ్చు. కొన్ని ప్రోగ్రామ్‌కు పాయింటర్లు అవసరం, ఇది విపరీతమైన శక్తిని ఇస్తుంది, కానీ దురదృష్టవశాత్తు, ఒక పాయింటర్ తప్పు విలువను కలిగి ఉంటే, అది కనుగొనడం చాలా కష్టమైన బగ్ అవుతుంది.
