c++ - हमारे पास पॉइंटर्स के कितने स्तर हो सकते हैं?




pointers (10)

2004 के एमआईएसआरए सी मानक के नियम 17.5 सूचक संकेत के 2 से अधिक स्तरों पर प्रतिबंध लगाता है।

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

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

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

इसी प्रकार हम कर सकते हैं

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

और इसी तरह।

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

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

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

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

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

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

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

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


जांच करने के लिए मजेदार लगता है।

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

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

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

(केवल एक परिवर्तनीय घोषणा के साथ परीक्षण किया)


जैसा कि लोगों ने कहा है, "सिद्धांत में" कोई सीमा नहीं है। हालांकि, ब्याज से मैंने इसे जी ++ 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;
}

प्रत्येक सी ++ डेवलपर को (इन) प्रसिद्ध तीन सितारा प्रोग्रामर के बारे में सुना होगा

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

सी 2 से उद्धरण:

तीन सितारा प्रोग्रामर

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


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

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


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

#include <cstdio>

typedef void (*FuncType)();

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

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

जैसा कि here बताया गया here यह देता है:

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

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


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

5.2.4.1 अनुवाद सीमाएं

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

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

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


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

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

एक पॉइंटर के लिए एक सूचक भी एक चर है जिसमें एक और सूचक का पता होता है।

int **q = &p;

यहां q पॉइंटर को सूचकांक है जो p के पते को धारण कर रहा है जो पहले से ही पते का पता लगा रहा a

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

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

की अनुमति है।


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

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

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

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

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

सी 99 मानक 5.2.4.1 अनुवाद सीमाएं:

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

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

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







pointers