पॉइंटर्स के कितने स्तर हो सकते हैं?

Question

*एक चर में कितने पॉइंटर्स ( ) की अनुमति है?

आइए निम्नलिखित उदाहरण पर विचार करें।

int a = 10;
int *p = &a;

इसी तरह हम हो सकते हैं

int **q = &p;
int ***r = &q;

और इसी तरह।

उदाहरण के लिए,

int ****************zz;

Comments

यदि वह कभी भी आपके लिए एक वास्तविक मुद्दा बन जाता है, तो आप कुछ गलत कर रहे हैं।

— ThiefMaster

जब तक आपका मस्तिष्क फट नहीं जाता या कंपाइलर पिघल नहीं जाता - जो भी जल्द होता है, तो आप पॉइंटर्स का स्तर जोड़ सकते हैं।

— जेरेमीपीप

चूंकि एक पॉइंटर को पॉइंटर फिर से, ठीक है, सिर्फ एक पॉइंटर है, इसलिए कोई सैद्धांतिक सीमा नहीं होनी चाहिए। हो सकता है कि संकलक कुछ हास्यास्पद उच्च सीमा से परे इसे संभाल नहीं पाएंगे, लेकिन अच्छी तरह से ...

— क्रिश्चियन राऊ

नवीनतम c ++ के साथ आपको कुछ का उपयोग करना चाहिए जैसेstd::shared_ptr<shared_ptr<shared_ptr<...shared_ptr<int>...>>>

— josefx

@josefx - यह C ++ मानक में एक समस्या दिखाता है - स्मार्ट पॉइंटर्स को शक्तियों को बढ़ाने का कोई तरीका नहीं है। हमें तुरंत (pow (std::shared_ptr, -0.3))<T> x;अप्रत्यक्ष स्तर के -0.3 स्तरों जैसे समर्थन के लिए विस्तार की मांग करनी चाहिए ।

— स्टीव 314

Answer 1

Cमानक निर्दिष्ट निचली सीमा:

5.2.4.1 अनुवाद सीमा

276 कार्यान्वयन कम से कम एक प्रोग्राम का अनुवाद और क्रियान्वयन करने में सक्षम होगा, जिसमें निम्न में से हर एक सीमा का कम से कम एक उदाहरण शामिल है: […]

२ ९ - १२ सूचक, सरणी, और फ़ंक्शन घोषणाकर्ता (किसी भी संयोजन में) एक घोषणा में एक अंकगणितीय, संरचना, संघ, या शून्य प्रकार को संशोधित करना

ऊपरी सीमा कार्यान्वयन विशिष्ट है।

Comments

C ++ मानक "अनुशंसा करता है" कि एक कार्यान्वयन समर्थन कम से कम 256। (पठनीयता अनुशंसा करती है कि आप 2 या 3 से अधिक न हों, और फिर भी: एक से अधिक असाधारण होना चाहिए।)

— जेम्स कांज़

यह सीमा एक घोषणा में कितने के बारे में है; यह एक ऊपरी सीमा नहीं लगाता है कि आप कितने typedefएस के माध्यम से अप्रत्यक्ष रूप से प्राप्त कर सकते हैं ।

— काज

@ काज़ - हाँ, यह सच है। लेकिन चूंकि युक्ति एक अनिवार्य निचली सीमा को निर्दिष्ट करती है (कोई सज़ा नहीं है), यह प्रभावी ऊपरी सीमा है सभी युक्ति-संगत संकलकों को समर्थन की आवश्यकता होती है। यह निश्चित रूप से विक्रेता-विशिष्ट ऊपरी सीमा से कम हो सकता है। अलग-अलग तरीके से (ओपी के प्रश्न के साथ इसे संरेखित करने के लिए), यह ऐनक द्वारा अनुमत अधिकतम अनुमति है (कुछ और विक्रेता-विशिष्ट होगा।) स्पर्शरेखा से थोड़ा दूर, प्रोग्रामर को (कम से कम सामान्य मामले में) उनके जैसा ही व्यवहार करना चाहिए। ऊपरी सीमा (जब तक उनके पास विक्रेता-विशिष्ट ऊपरी सीमा पर भरोसा करने का एक वैध कारण नहीं है) ... मुझे लगता है।

— luis.espinal

एक और नोट पर, मैं खुद को काटना शुरू कर दूंगा अगर मुझे उस कोड के साथ काम करना था जिसमें लंबे समय तक गधा डेरेफ़रिंग चेन थी (विशेषकर जब उदारता से सभी जगह

— पेप्पर्ड हो

@beryllium: आमतौर पर ये संख्या पूर्व-मानकीकरण सॉफ़्टवेयर का सर्वेक्षण करने से आती है। इस मामले में संभवतया वे आम सी कार्यक्रमों और विद्यमान सी संकलक को देखते हैं, और कम से कम एक संकलक पाया गया है जो 12 से अधिक और / या कोई भी कार्यक्रम से परेशान नहीं होगा जो अगर आपने इसे 12 तक सीमित कर दिया है

Answer 2

दरअसल, C प्रोग्राम आमतौर पर अनंत पॉइंटर अप्रत्यक्ष का उपयोग करते हैं। एक या दो स्थिर स्तर आम हैं। ट्रिपल अप्रत्यक्ष दुर्लभ है। लेकिन अनंत बहुत आम है।

निश्चित रूप से एक संरचना की मदद से अनंत सूचक अप्रत्यक्षता प्राप्त की जाती है, प्रत्यक्ष घोषणाकर्ता के साथ नहीं, जो असंभव होगा। और एक संरचना की आवश्यकता है ताकि आप इस संरचना में अन्य डेटा को विभिन्न स्तरों पर शामिल कर सकें जहां यह समाप्त हो सकता है।

struct list { struct list *next; ... };

अब आपके पास हो सकता है list->next->next->next->...->next। यह वास्तव में सिर्फ कई सूचक अप्रत्यक्ष हैं *(*(..(*(*(*list).next).next).next...).next).next:। और .nextजब यह संरचना का पहला सदस्य है, तो मूल रूप से एक नूप है, इसलिए हम इसकी कल्पना कर सकते हैं ***..***ptr।

इस पर वास्तव में कोई सीमा नहीं है क्योंकि लिंक को इस तरह की विशाल अभिव्यक्ति के बजाय एक लूप के साथ ट्रेस किया जा सकता है, और इसके अलावा, संरचना को आसानी से गोलाकार बनाया जा सकता है।

इस प्रकार, दूसरे शब्दों में, लिंक की गई सूची एक समस्या को हल करने के लिए अप्रत्यक्ष के दूसरे स्तर को जोड़ने का अंतिम उदाहरण हो सकती है, क्योंकि आप इसे हर पुश ऑपरेशन के साथ गतिशील रूप से कर रहे हैं। :)

Comments

यह एक पूरी तरह से अलग मुद्दा है, हालांकि - एक संरचना जिसमें एक अन्य संरचना के लिए एक सूचक होता है, एक सूचक-सूचक की तुलना में बहुत अलग है। एक अंतर ***** एक विशिष्ट प्रकार से एक अंतर **** है।

— शराबी

यह "बहुत" अलग नहीं है। अंतर शराबी है। यह शब्दार्थ की तुलना में वाक्य रचना के अधिक निकट है। एक पॉइंटर पॉइंटर का पॉइंटर, या किसी स्ट्रक्चर ऑब्जेक्ट का पॉइंटर जिसमें पॉइंटर होता है? यह उसी तरह की बात है। किसी सूची के दसवें तत्व को प्राप्त करना अप्रत्यक्ष को संबोधित करने का दस स्तर है। (बेशक, एक अनंत संरचना को व्यक्त करने की क्षमता उस संरचना प्रकार पर निर्भर करती है जो अपूर्ण संरचना प्रकार के माध्यम से खुद को इंगित करने में सक्षम होती है ताकि list->nextऔर list->next->nextएक ही प्रकार हो; अन्यथा हमें एक अनंत प्रकार का निर्माण करना होगा।)

— काज

जब मैंने "शराबी" शब्द का इस्तेमाल किया तो मुझे होश नहीं आया कि आपका नाम शराबी है। अवचेतन प्रभाव? लेकिन मुझे यकीन है कि मैंने पहले भी इस तरह से इस शब्द का इस्तेमाल किया है।

— काज

यह भी याद रखें कि मशीन की भाषा में, आप बस कुछ पर जैसे LOAD R1, [R1]कि R1 हर कदम पर एक वैध सूचक है, पर पुनरावृति कर सकते हैं । "शब्द जो एक पता रखता है" के अलावा अन्य प्रकार शामिल नहीं हैं। घोषित प्रकार हैं या नहीं, यह अप्रत्यक्ष और कितने स्तरों पर है यह निर्धारित नहीं करता है।

— काज

नहीं अगर संरचना परिपत्र है। यदि R1किसी स्थान का पता चलता है जो खुद को इंगित करता है तो LOAD R1, [R1]उसे अनंत लूप में निष्पादित किया जा सकता है।

— कज़

Answer 3

सैद्धांतिक रूप से:

आप जितने चाहें उतने स्तर के अप्रत्यक्ष कर सकते हैं।

व्यावहारिक रूप से:

बेशक, मेमोरी का उपभोग करने वाला कुछ भी अनिश्चित नहीं हो सकता है, मेजबान वातावरण पर उपलब्ध संसाधनों के कारण सीमाएं होंगी। इसलिए व्यावहारिक रूप से एक अधिकतम सीमा है कि कोई कार्यान्वयन क्या समर्थन कर सकता है और कार्यान्वयन इसे उचित रूप से दस्तावेज करेगा। तो ऐसी सभी कलाकृतियों में, मानक अधिकतम सीमा को निर्दिष्ट नहीं करता है, लेकिन यह निचली सीमा को निर्दिष्ट करता है।

यहाँ संदर्भ है:

C99 मानक 5.2.4.1 अनुवाद सीमाएँ:

- 12 पॉइंटर, ऐरे, और फंक्शन डिक्लेयटर (किसी भी संयोजन में) एक घोषणा में एक अंकगणित, संरचना, संघ, या शून्य प्रकार को संशोधित करते हैं।

यह निचली सीमा को निर्दिष्ट करता है जिसे हर कार्यान्वयन को समर्थन करना चाहिए । ध्यान दें कि एक फुटनोट में मानक आगे कहता है:

18) जब भी संभव हो, कार्यान्वयन को निश्चित अनुवाद सीमाओं को लागू करने से बचना चाहिए।

Comments

अप्रत्यक्ष किसी भी ढेर से अधिक नहीं है!

— बेसिल स्टारीनेवविच

सही है, मुझे यह पढ़ने और उत्तर देने की भावना थी कि समारोह में पास होने वाले मापदंडों की सीमा के रूप में क्यू का जवाब देना। मुझे पता नहीं क्यों ?!

— आलोक सेव

@basile - मुझे उम्मीद है कि पार्सर में स्टैक-डेप्थ एक मुद्दा होगा। कई औपचारिक पार्सिंग एल्गोरिदम में एक प्रमुख घटक के रूप में एक स्टैक होता है। अधिकांश C ++ कंपाइलर संभवतः पुनरावर्ती वंश के एक संस्करण का उपयोग करते हैं, लेकिन यहां तक ​​कि प्रोसेसर स्टैक पर निर्भर करता है (या, संभवतः, भाषा अभिनय पर जैसे कि प्रोसेसर स्टैक होता है)। व्याकरण के नियमों के अधिक घोंसले के शिकार का मतलब एक गहरा ढेर है।

— स्टीव 314

अप्रत्यक्ष किसी भी ढेर से अधिक नहीं है! -> नहीं! पार्सर स्टैक ओवरफ्लो हो सकता है। कैसे सूचक सूचक अप्रत्यक्ष से संबंधित है? पार्सर स्टैक!

— पवन मंजूनाथ

यदि *एक पंक्ति में कई वर्गों के लिए अतिभारित है, और प्रत्येक अधिभार पंक्ति में अन्य प्रकार की एक वस्तु लौटाता है, तो इस तरह के जंजीर फ़ंक्शन कॉल के लिए स्टैकओवरफ़्लो हो सकता है।

— नवाज

Answer 4

जैसा कि लोगों ने कहा है, "सिद्धांत में" कोई सीमा नहीं है। हालाँकि, ब्याज से बाहर मैंने इसे g ++ 4.1.2 के साथ चलाया, और इसने 20,000 तक के आकार के साथ काम किया। हालांकि संकलन बहुत धीमा था, इसलिए मैंने अधिक प्रयास नहीं किया। इसलिए मुझे लगता है कि जी ++ किसी भी सीमा को लागू नहीं करता है। ( size = 10यदि यह तुरंत स्पष्ट नहीं है तो ptr.cpp में सेटिंग और देखने का प्रयास करें ।)

g++ create.cpp -o create ; ./create > ptr.cpp ; g++ ptr.cpp -o ptr ; ./ptr

create.cpp

#include <iostream>

int main()
{
    const int size = 200;
    std::cout << "#include <iostream>\n\n";
    std::cout << "int main()\n{\n";
    std::cout << "    int i0 = " << size << ";";
    for (int i = 1; i < size; ++i)
    {
        std::cout << "    int ";
        for (int j = 0; j < i; ++j) std::cout << "*";
        std::cout << " i" << i << " = &i" << i-1 << ";\n";
    }
    std::cout << "    std::cout << ";
    for (int i = 1; i < size; ++i) std::cout << "*";
    std::cout << "i" << size-1 << " << \"\\n\";\n";
    std::cout << "    return 0;\n}\n";
    return 0;
}

Comments

जब मैंने कोशिश की तो मुझे 98242 से ज्यादा नहीं मिले। (मैंने पायथन में स्क्रिप्ट की, *जब तक कि मैं एक असफल हो गया, और पास होने वाली संख्या को दोगुना कर दिया; मैंने तब उस अंतराल पर एक द्विआधारी खोज की जो असफल रही। चलाने के लिए।)

— जेम्स कांजे

Answer 5

चेक करने में मज़ा आता है।

• विजुअल स्टूडियो 2010 (विंडोज 7 पर), इस त्रुटि को प्राप्त करने से पहले आपके पास 1011 स्तर हो सकते हैं:

  घातक त्रुटि C1026: पार्सर स्टैक ओवरफ्लो, प्रोग्राम बहुत जटिल है

• जीसीसी (उबंटू), *एक दुर्घटना के बिना 100k + ! मुझे लगता है कि हार्डवेयर यहाँ की सीमा है।

(सिर्फ एक चर घोषणा के साथ परीक्षण किया गया)

Comments

दरअसल, यूनिरी ऑपरेटर्स के लिए प्रोडक्शंस सही-पुनरावर्ती होते हैं, जिसका अर्थ है कि शिफ्ट-कम पार्सर *स्टैक पर सभी नोड्स को शिफ्ट करने में सक्षम होगा, जिससे वह कमी कर सके।

— कज़

Answer 6

कोई सीमा नहीं है, उदाहरण देखें यहाँ ।

इसका उत्तर इस बात पर निर्भर करता है कि आप "बिंदुओं के स्तर" से क्या मतलब है। यदि आपका मतलब है "आप एक ही घोषणा में कितने स्तर के अप्रत्यक्ष कर सकते हैं?" जवाब है "कम से कम 12."

int i = 0;

int *ip01 = & i;

int **ip02 = & ip01;

int ***ip03 = & ip02;

int ****ip04 = & ip03;

int *****ip05 = & ip04;

int ******ip06 = & ip05;

int *******ip07 = & ip06;

int ********ip08 = & ip07;

int *********ip09 = & ip08;

int **********ip10 = & ip09;

int ***********ip11 = & ip10;

int ************ip12 = & ip11;

************ip12 = 1; /* i = 1 */

यदि आपका मतलब है कि "प्रोग्राम को पढ़ने में मुश्किल होने से पहले आप कितने स्तर के पॉइंटर का उपयोग कर सकते हैं," यह स्वाद का मामला है, लेकिन एक सीमा है। अप्रत्यक्ष के दो स्तर (कुछ करने के लिए एक सूचक का सूचक) होना आम है। इससे अधिक कोई भी आसानी से सोचने के लिए थोड़ा कठिन हो जाता है; ऐसा न करें जब तक कि विकल्प बदतर नहीं होगा।

यदि आपका मतलब है कि "आप कितने समय तक सूचक अप्रत्यक्ष स्तर पर चल सकते हैं," इसकी कोई सीमा नहीं है। यह बिंदु विशेष रूप से परिपत्र सूचियों के लिए महत्वपूर्ण है, जिसमें प्रत्येक नोड अगले पर इंगित करता है। आपका कार्यक्रम हमेशा के लिए संकेत का पालन कर सकता है।

Comments

लगभग निश्चित रूप से एक सीमा है, क्योंकि संकलक को स्मृति की सीमित मात्रा में जानकारी का ट्रैक रखना पड़ता है। ( g++मेरी मशीन पर 98242 पर एक आंतरिक त्रुटि के साथ गर्भपात होता है। मुझे उम्मीद है कि वास्तविक सीमा मशीन और लोड पर निर्भर करेगी। मैं भी वास्तविक कोड में इस समस्या की उम्मीद नहीं करता हूं।)

— जेम्स कांज़

हाँ @ मैथ्यूएमएम। : मैं सिर्फ सैद्धांतिक रूप से विचार करता हूं :) जवाब पूरा करने के लिए धन्यवाद जेम्स

— नंदकुमार टेकले

खैर, लिंक्ड लिस्ट वास्तव में एक पॉइंटर के लिए पॉइंटर नहीं हैं, वे एक ऐसी संरचना के लिए एक पॉइंटर हैं जिसमें एक पॉइंटर होता है (या तो या आप बहुत सारी अनावश्यक कास्टिंग करते हैं)

— रैंडम 832

@ Random832: नंद ने कहा 'अगर आपका मतलब है "आप कितने समय तक सूचक अप्रत्यक्ष रूप से रनटाइम पर हो सकते हैं," तो वह स्पष्ट रूप से पॉइंटर्स टू पॉइंटर्स (* n) के बारे में बात करने के प्रतिबंध को हटा रहा था।

— लार्स

मुझे आपकी बात नहीं आती: ' यहाँ कोई सीमा नहीं है, उदाहरण देखें। 'उदाहरण कोई प्रमाण नहीं है कि कोई सीमा नहीं है। यह केवल साबित करता है कि एक 12 स्टार अप्रत्यक्ष संभव है। न तो circ_listओपी के प्रश्न के बारे में कुछ भी उदाहरण से साबित होता है : तथ्य यह है कि आप एक बिंदु सूची को पार कर सकते हैं इसका मतलब यह नहीं है कि कंपाइलर एक एन-स्टार अप्रत्यक्ष रूप से संकलित कर सकता है।

— अल्बर्टो

Answer 7

यह वास्तव में कार्यों के लिए सूचक के साथ भी मजेदार है।

#include <cstdio>

typedef void (*FuncType)();

static void Print() { std::printf("%s", "Hello, World!\n"); }

int main() {
  FuncType const ft = &Print;
  ft();
  (*ft)();
  (**ft)();
  /* ... */
}

जैसा कि यहाँ सचित्र है:

नमस्ते दुनिया!
नमस्ते दुनिया!
नमस्ते दुनिया!

और इसमें कोई रनटाइम ओवरहेड शामिल नहीं है, इसलिए आप संभवतः उन्हें जितना चाहें उतना स्टैक कर सकते हैं ... जब तक आपका कंपाइलर फ़ाइल पर चोक नहीं करता।

Answer 8

नहीं है कोई सीमा नहीं । एक सूचक स्मृति का एक हिस्सा है जिसकी सामग्री एक पता है।
जैसा कि आपने कहा

int a = 10;
int *p = &a;

पॉइंटर का पॉइंटर भी एक वैरिएबल होता है जिसमें दूसरे पॉइंटर का एड्रेस होता है।

int **q = &p;

यहाँ qपॉइंटर से लेकर पॉइंटर तक का पता है pजिसका पता पहले से ही हैa ।

एक पॉइंटर को पॉइंटर के बारे में कुछ विशेष नहीं है।
इसलिए पॉनीटर्स की श्रृंखला की कोई सीमा नहीं है जो किसी अन्य पॉइंटर के पते को पकड़े हुए हैं।
अर्थात।

 int **************************************************************************z;

की अनुमति है।

Answer 9

हर C ++ डेवलपर को प्रसिद्ध (में) के बारे में सुना होना चाहिए थ्री स्टार प्रोग्रामर के

और वहाँ वास्तव में कुछ जादू "सूचक बाधा" लगता है जिसे छलावरण करना पड़ता है

C2 से उद्धरण:

थ्री स्टार प्रोग्रामर

सी-प्रोग्रामर के लिए एक रेटिंग प्रणाली। आपके सूचक जितने अधिक अप्रत्यक्ष होंगे (यानी आपके चर से पहले "अधिक" *), आपकी प्रतिष्ठा उतनी ही अधिक होगी। नो-स्टार सी-प्रोग्रामर लगभग गैर-मौजूद हैं, क्योंकि लगभग सभी गैर-तुच्छ कार्यक्रमों में पॉइंटर्स के उपयोग की आवश्यकता होती है। अधिकांश एक-स्टार प्रोग्रामर हैं। पुराने समय में (ठीक है, मैं युवा हूं, इसलिए ये मेरे लिए कम से कम पुराने समय की तरह दिखते हैं), एक कभी-कभार एक थ्री-स्टार प्रोग्रामर द्वारा किया गया कोड का एक टुकड़ा मिलेगा और विस्मय के साथ कांप जाएगा। कुछ लोगों ने यह भी दावा किया कि उन्होंने तीन-स्टार कोड को फ़ंक्शन पॉइंटर्स के साथ शामिल किया है, जो कि एक से अधिक स्तर पर अप्रत्यक्ष है। मेरे लिए यूएफओ के रूप में असली लग रहा था।

Comments

github.com/psi4/psi4public/blob/master/src/lib/libdpd/… और जैसा 4-स्टार प्रोग्रामर द्वारा लिखा गया था। वह मेरा एक दोस्त भी है और यदि आप कोड को पर्याप्त रूप से पढ़ते हैं, तो आप इसका कारण समझेंगे कि यह 4 सितारों के योग्य क्यों है।

— जेफ

Answer 10

ध्यान दें कि यहां दो संभावित प्रश्न हैं: कितने प्रकार के सूचक अप्रत्यक्ष रूप से हम एक सी प्रकार में प्राप्त कर सकते हैं, और कितने स्तर के सूचक अप्रत्यक्ष रूप से हम एक एकल घोषणाकर्ता में सामान कर सकते हैं।

सी मानक अधिकतम को पूर्व में लगाए जाने की अनुमति देता है (और उसके लिए एक न्यूनतम मूल्य देता है)। लेकिन इसे कई टाइपराइफ घोषणाओं के माध्यम से देखा जा सकता है:

typedef int *type0;
typedef type0 *type1;
typedef type1 *type2; /* etc */

तो आखिरकार, यह एक कार्यान्वयन मुद्दा है जो इस बात से जुड़ा है कि अस्वीकार किए जाने से पहले C / C को कितना बड़ा और जटिल बनाया जा सकता है, जो बहुत विशिष्ट है।

Answer 11

मैं यह इंगित करना चाहता हूं कि * की मनमानी संख्या के साथ एक प्रकार का उत्पादन कुछ ऐसा है जो टेम्पलेट मेटाप्रोग्रामिंग के साथ हो सकता है। मैं भूल गया कि मैं वास्तव में क्या कर रहा था, लेकिन यह सुझाव दिया गया था कि मैं नए अलग प्रकार का उत्पादन कर सकता हूं जिसमें पुनरावर्ती का उपयोग करके उनके बीच किसी प्रकार का मेटा पैंतरेबाज़ी हो टी * प्रकारों ।

टेम्प्लेट मेटाप्रोग्रामिंग पागलपन में एक धीमी गति से वंश है, इसलिए अप्रत्यक्ष के कई हजार स्तर के साथ एक प्रकार का निर्माण करते समय यह बहाना बनाने के लिए आवश्यक नहीं है। उदाहरण के लिए, एक कार्यात्मक भाषा के रूप में टेम्प्लेट के विस्तार पर, यह केवल मूंगफली पूर्णांक को मैप करने का आसान तरीका है।

Comments

मैं मानता हूं कि मैं आपके उत्तर को पूरी तरह से नहीं समझता, लेकिन मुझे तलाशने के लिए एक नया क्षेत्र दिया गया है। :)

— अंकुश

Answer 12

2004 MISRA C मानक का नियम 17.5 सूचक सूचक के 2 से अधिक स्तरों को प्रतिबंधित करता है।

Comments

बहुत यकीन है कि प्रोग्रामर के लिए एक सिफारिश है, संकलक के लिए नहीं।

— कोल जॉनसन

मैंने दस्तावेज़ को नियम 17.5 के साथ सूचक अप्रत्यक्ष के 2 से अधिक स्तरों के बारे में पढ़ा। और यह जरूरी नहीं कि 2 से अधिक स्तरों पर प्रतिबंध लगा सकता है। यह बताता है कि सत्तारूढ़ का पालन किया जाना चाहिए क्योंकि 2 से अधिक स्तर "non-compliant"उनके मानकों पर है। उनके निर्णय में महत्वपूर्ण शब्द या वाक्यांश "should"इस कथन से शब्द का उपयोग है : Use of more than 2 levels of indirection can seriously impair the ability to understand the behavior of the code, and should therefore be avoided.ये इस संगठन द्वारा निर्धारित दिशानिर्देश हैं जो भाषा मानक द्वारा निर्धारित नियमों के विपरीत हैं।

— फ्रांसिस कुगलर

Answer 13

असली सीमा जैसी कोई चीज नहीं है, लेकिन सीमा मौजूद है। सभी पॉइंटर्स वैरिएबल होते हैं जो आमतौर पर स्टैक में ढेर नहीं होते हैं । स्टैक आमतौर पर छोटा होता है (कुछ लिंकिंग के दौरान इसका आकार बदलना संभव है)। तो मान लें कि आपके पास 4MB स्टैक है, जो कि सामान्य आकार का है। और हम कहते हैं कि हमारे पास सूचक है जो 4 बाइट्स का आकार है (सूचक आकार वास्तुकला, लक्ष्य और संकलक सेटिंग्स के आधार पर समान नहीं हैं)।

इस स्थिति में 4 MB / 4 b = 1024अधिकतम संभव संख्या 1048576 होगी, लेकिन हमें इस तथ्य की अनदेखी नहीं करनी चाहिए कि कुछ अन्य सामान स्टैक में है।

हालाँकि, कुछ कंपाइलरों में सूचक श्रृंखला की अधिकतम संख्या हो सकती है, लेकिन सीमा स्टैक आकार है। इसलिए यदि आप अनन्तता के साथ जुड़ने के दौरान स्टैक का आकार बढ़ाते हैं और अनंत स्मृति के साथ मशीन रखते हैं जो ओएस चलाता है जो उस मेमोरी को संभालता है तो आपके पास असीमित सूचक श्रृंखला होगी।

यदि आप उपयोग करते हैं int *ptr = new int;और अपने पॉइंटर को हीप में डालते हैं, तो यह सामान्य तरीका नहीं है, सीमा ढेर के आकार की होगी, स्टैक की नहीं।

संपादित करें बस एहसास है कि infinity / 2 = infinity। यदि मशीन में अधिक मेमोरी है तो पॉइंटर का आकार बढ़ता है। इसलिए यदि स्मृति अनंत है और सूचक का आकार अनंत है, तो यह बुरी खबर है ... :)

Comments

ए) पॉइंटर्स को ढेर ( new int*) पर संग्रहीत किया जा सकता है । बी) एक int*और एक int**********ही आकार है, कम से कम उचित आर्किटेक्चर पर।

@rightfold ए) हाँ पॉइंटर्स को ढेर में संग्रहीत किया जा सकता है। लेकिन यह कंटेनर बनाने की तरह बहुत अलग बात होगी जो पॉइंटर्स को पकड़ती है जो अगले पिछले पॉइंटर की ओर इशारा करती है। बी) बेशक int*और एक int**********ही आकार है, मैंने यह नहीं कहा कि वे अलग हैं।

— ST3

तब मैं यह नहीं देखता कि स्टैक का आकार कितना दूर तक प्रासंगिक है।

@ राइटफोल्ड मैं डेटा वितरण के सामान्य तरीके के बारे में सोच रहा हूं जब सभी डेटा ढेर में हैं और स्टैक पर यह केवल उस डेटा को इंगित करता है। यह सामान्य तरीका होगा, लेकिन मैं मानता हूं कि पॉइंटर्स को स्टैक में रखना संभव है।

— ST3

"बेशक int * और एक int ********** का आकार एक जैसा है" - मानक इसकी गारंटी नहीं देता है (हालांकि मुझे बिना किसी प्लेटफ़ॉर्म के पता है कि यह कहाँ सच है)।

— मार्टिन बोनर मोनिका

Answer 14

यह उस जगह पर निर्भर करता है जहां आप पॉइंटर्स स्टोर करते हैं। यदि वे ढेर में हैं, तो आपके पास काफी कम सीमा है। यदि आप इसे ढेर में संग्रहीत करते हैं, तो आप सीमा बहुत अधिक है।

इस कार्यक्रम को देखें:

#include <iostream>

const int CBlockSize = 1048576;

int main() 
{
    int number = 0;
    int** ptr = new int*[CBlockSize];

    ptr[0] = &number;

    for (int i = 1; i < CBlockSize; ++i)
        ptr[i] = reinterpret_cast<int *> (&ptr[i - 1]);

    for (int i = CBlockSize-1; i >= 0; --i)
        std::cout << i << " " << (int)ptr[i] << "->" << *ptr[i] << std::endl;

    return 0;
}

यह 1M पॉइंटर्स बनाता है और शो में यह इंगित करता है कि चेन को पहले वेरिएबल पर जाने के लिए क्या कहना आसान है number।

Btw। यह 92Kरैम का उपयोग करता है तो बस कल्पना करें कि आप कितने गहरे जा सकते हैं।