क्या ढेर ऊपर या नीचे बढ़ता है?

Question 1

मेरे पास c में यह कोड है:

int q = 10;
int s = 5;
int a[3];

printf("Address of a: %d\n",    (int)a);
printf("Address of a[1]: %d\n", (int)&a[1]);
printf("Address of a[2]: %d\n", (int)&a[2]);
printf("Address of q: %d\n",    (int)&q);
printf("Address of s: %d\n",    (int)&s);

आउटपुट है:

Address of a: 2293584
Address of a[1]: 2293588
Address of a[2]: 2293592
Address of q: 2293612
Address of s: 2293608

तो, मुझे लगता है कि से aकरने के लिए a[2], 4 से स्मृति पतों बढ़ जाती है प्रत्येक बाइट्स। लेकिन से qकरने के लिए s, स्मृति पतों 4 बाइट से कम हो।

मुझे आश्चर्य है 2 चीजें:

क्या ढेर ऊपर या नीचे बढ़ता है? (यह मुझे इस मामले में दोनों की तरह दिखता है)
क्या बीच हो a[2]और qस्मृति पतों? वहाँ एक बड़े स्मृति अंतर क्यों हैं? (20 बाइट्स)।

नोट: यह होमवर्क का सवाल नहीं है। मैं इस बात पर उत्सुक हूं कि स्टैक कैसे काम करता है। किसी भी मदद के लिए धन्यवाद।

Question 2

स्टैक का व्यवहार (बड़ा होना या बढ़ना) आवेदन बाइनरी इंटरफेस (एबीआई) और कॉल स्टैक (उर्फ सक्रियण रिकॉर्ड) पर निर्भर करता है।

अपने पूरे जीवनकाल में एक कार्यक्रम ओएस जैसे अन्य कार्यक्रमों के साथ संवाद करने के लिए बाध्य है। एबीआई निर्धारित करता है कि एक कार्यक्रम दूसरे कार्यक्रम के साथ कैसे संवाद कर सकता है।

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

उदाहरण के लिए, यदि आप MIPS ABI लेते हैं, तो कॉल स्टैक को नीचे के रूप में परिभाषित किया गया है।

आइए उस फ़ंक्शन को 'fn1' कॉल 'fn2' पर विचार करें। अब 'fn2' द्वारा देखा गया स्टैक फ्रेम निम्नानुसार है:

direction of     |                                 |
  growth of      +---------------------------------+ 
   stack         | Parameters passed by fn1(caller)|
from higher addr.|                                 |
to lower addr.   | Direction of growth is opposite |
      |          |   to direction of stack growth  |
      |          +---------------------------------+ <-- SP on entry to fn2
      |          | Return address from fn2(callee) | 
      V          +---------------------------------+ 
                 | Callee saved registers being    | 
                 |   used in the callee function   | 
                 +---------------------------------+
                 | Local variables of fn2          |
                 |(Direction of growth of frame is |
                 | same as direction of growth of  |
                 |            stack)               |
                 +---------------------------------+ 
                 | Arguments to functions called   |
                 | by fn2                          |
                 +---------------------------------+ <- Current SP after stack 
                                                        frame is allocated

अब आप देख सकते हैं कि ढेर नीचे की ओर बढ़ता है। इसलिए, यदि चर फ़ंक्शन के स्थानीय फ्रेम में आवंटित किए जाते हैं, तो चर के पते वास्तव में नीचे की ओर बढ़ते हैं। संकलनकर्ता मेमोरी आवंटन के लिए चर के आदेश पर निर्णय ले सकता है। (आपके मामले में यह या तो 'q' या 's' हो सकता है जो पहले स्टैक मेमोरी को आवंटित किया गया है। लेकिन, आमतौर पर कंपाइलर वेरिएबल की घोषणा के आदेश के अनुसार मेमोरी एलोकेशन को स्टैक करता है)।

लेकिन सरणियों के मामले में, आवंटन में केवल एकल सूचक होता है और आवंटित की जाने वाली मेमोरी को वास्तव में एकल सूचक द्वारा इंगित किया जाएगा। स्मृति को किसी सरणी के लिए सन्निहित होना चाहिए। तो, हालांकि ढेर नीचे की ओर बढ़ता है, सरणियों के लिए ढेर बढ़ता है।

Question 3

यह वास्तव में दो प्रश्न हैं। एक वह तरीका है जिसके बारे में स्टैक बढ़ता है जब एक फ़ंक्शन दूसरे को कॉल करता है (जब एक नया फ्रेम आवंटित किया जाता है), और दूसरा इस बारे में है कि किसी विशेष फ़ंक्शन के फ्रेम में चर कैसे रखे जाते हैं।

न तो सी मानक द्वारा निर्दिष्ट किया गया है, लेकिन उत्तर थोड़े अलग हैं:

जब एक नया फ्रेम आवंटित किया जाता है तो कौन सा तरीका बढ़ता है - यदि फ़ंक्शन च () कॉल फ़ंक्शन जी () है, तो क्या fफ़्रेम फ़्रेम पॉइंटर अधिक से अधिक या कम होगा g? यह किसी भी तरह से जा सकता है - यह विशेष संकलक और वास्तुकला ("कॉलिंग कन्वेंशन" देखें) पर निर्भर करता है, लेकिन यह हमेशा किसी दिए गए प्लेटफ़ॉर्म (कुछ विचित्र अपवादों के साथ, टिप्पणियों को देखें) के अनुरूप है । नीचे की ओर अधिक आम है; यह x86, PowerPC, MIPS, SPARC, EE और सेल SPUs में मामला है।
किसी फ़ंक्शन के स्थानीय चर को उसके स्टैक फ्रेम के अंदर कैसे रखा जाता है? यह अनिर्दिष्ट और पूरी तरह से अप्रत्याशित है; संकलक अपने स्थानीय चरों को व्यवस्थित करने के लिए स्वतंत्र है, हालांकि यह सबसे कुशल परिणाम प्राप्त करना पसंद करता है।

Question 4

दिशा है जो ढेर हो जाना वास्तुकला विशिष्ट है। उस ने कहा, मेरी समझ यह है कि बहुत कम हार्डवेयर आर्किटेक्चर के पास ढेर होते हैं जो बड़े होते हैं।

वह दिशा जो एक स्टैक बढ़ता है वह एक व्यक्तिगत वस्तु के लेआउट से स्वतंत्र है। इसलिए जब स्टैक बड़ा हो सकता है, तो सरणियाँ नहीं होंगी (अर्थात & सरणी [n] हमेशा रहेगी <& array [n + 1]);

Question 5

मानक में ऐसा कुछ भी नहीं है जो यह बताता है कि स्टैक पर चीजों को कैसे व्यवस्थित किया जाता है। वास्तव में, आप एक अनुरूप संकलक का निर्माण कर सकते हैं जो स्टैक पर सन्निहित तत्वों में सरणी तत्वों को संग्रहीत नहीं करता है, बशर्ते कि यह अभी भी सरणी तत्व अंकगणित को ठीक से करने के लिए हो (ताकि यह जानता हो, उदाहरण के लिए, कि 1 था 1K दूर [0] और इसके लिए समायोजित किया जा सकता है)।

हो सकता है कि आपको अलग-अलग परिणाम मिल रहे हों, क्योंकि स्टैक "ऑब्जेक्ट्स" को जोड़ने के लिए नीचे बढ़ सकता है, सरणी एकल "ऑब्जेक्ट" है और इसमें विपरीत क्रम में आरोही तत्व हो सकते हैं। लेकिन यह उस व्यवहार पर भरोसा करने के लिए सुरक्षित नहीं है क्योंकि दिशा बदल सकती है और चर को विभिन्न कारणों से चारों ओर स्वैप किया जा सकता है, लेकिन इसके लिए सीमित है:

अनुकूलन।
संरेखण।
संकलक का हिस्सा प्रबंधन के व्यक्ति की सनक।

स्टैक दिशा पर मेरे उत्कृष्ट ग्रंथ के लिए यहाँ देखें :-)

आपके विशिष्ट प्रश्नों के उत्तर में:

क्या ढेर ऊपर या नीचे बढ़ता है?
यह बिल्कुल भी मायने नहीं रखता (मानक के संदर्भ में) लेकिन, जब से आपने पूछा था, यह कार्यान्वयन के आधार पर स्मृति में ऊपर या नीचे बढ़ सकता है ।
[2] और q स्मृति पतों के बीच क्या होता है? वहाँ एक बड़े स्मृति अंतर क्यों हैं? (20 बाइट्स)?
यह बिल्कुल भी मायने नहीं रखता (मानक के संदर्भ में)। संभावित कारणों के लिए ऊपर देखें।

Question 6

एक x86 पर, स्टैक फ्रेम की मेमोरी "आवंटन" में स्टैक पॉइंटर से बाइट्स की आवश्यक संख्या को घटाना होता है (मेरा मानना है कि अन्य आर्किटेक्चर समान हैं)। इस अर्थ में, मुझे लगता है कि स्टैक ग्रोन्स "डाउन" है, जिसमें आप उत्तरोत्तर छोटे हो जाते हैं क्योंकि आप स्टैक में अधिक गहराई से कॉल करते हैं (लेकिन मैं हमेशा स्मृति को ऊपर बाईं ओर 0 से शुरू करने और आपके द्वारा चलते हुए बड़े पते प्राप्त करने के रूप में कल्पना करता हूं। दाईं ओर और नीचे लिपटे, इसलिए मेरी मानसिक छवि में ढेर बढ़ता जाता है ...)। घोषित किए जा रहे चरों के क्रम का उनके पतों पर कोई असर नहीं हो सकता है - मेरा मानना है कि मानक कंपाइलर को उन्हें फिर से चालू करने की अनुमति देता है, जब तक कि इससे साइड इफेक्ट्स न हों (कोई मुझे गलत होने पर सही करने की कृपा करे) । वे'

सरणी के चारों ओर गैप कुछ प्रकार की पैडिंग हो सकती है, लेकिन यह मेरे लिए रहस्यमय है।

Question 7

सबसे पहले, मेमोरी में अप्रयुक्त स्थान की इसकी 8 बाइट्स (इसके 12 नहीं, याद रखें स्टैक नीचे की ओर बढ़ता है, इसलिए जो स्थान आवंटित नहीं किया गया है वह 604 से 597 तक है)। और क्यों?। क्योंकि प्रत्येक डेटा प्रकार अपने आकार द्वारा विभाज्य पते से शुरू होने वाली मेमोरी में जगह लेता है। हमारे मामले में 3 पूर्णांकों की सरणी मेमोरी स्पेस के 12 बाइट्स लेती है और 604 12. से विभाज्य नहीं है। इसलिए यह खाली जगहों को छोड़ देता है जब तक कि यह एक मेमोरी एड्रेस का सामना नहीं करता है जो 12 से विभाज्य है, यह 596 है।

तो सरणी को आवंटित स्मृति स्थान 596 से 584 तक है। लेकिन सरणी आवंटन निरंतरता में है, इसलिए सरणी का पहला तत्व 584 पते से शुरू होता है, 596 से नहीं।

Question 8

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

#include <stdio.h>
int f(int *x)
{
  int a;
  return x == NULL ? f(&a) : &a - x;
}

int main(void)
{
  printf("stack grows %s!\n", f(NULL) < 0 ? "down" : "up");
  return 0;
}

Question 9

मुझे नहीं लगता कि यह इस तरह निर्धारक है। एक सरणी "बढ़ने" लगती है, क्योंकि उस मेमोरी को आकस्मिक रूप से आवंटित किया जाना चाहिए। हालाँकि, क्यू और एस एक दूसरे से संबंधित नहीं हैं, कंपाइलर उनमें से प्रत्येक को स्टैक के भीतर एक मनमानी मुक्त मेमोरी लोकेशन में चिपका देता है, शायद वही जो पूर्णांक आकार में सबसे अच्छा फिट होते हैं।

[2] और q के बीच जो हुआ वह यह है कि q के स्थान के आसपास का स्थान काफी बड़ा नहीं था (यानी, १२ बाइट्स से बड़ा नहीं था) एक ३ पूर्णांक सरणी आवंटित करने के लिए।

Question 10

मेरा ढेर कम संख्या वाले पतों की ओर बढ़ा हुआ प्रतीत होता है।

अगर मैं एक अलग कंपाइलर आह्वान का उपयोग करता हूं, तो यह दूसरे कंप्यूटर पर या मेरे अपने कंप्यूटर पर भी अलग हो सकता है। ... या संकलक म्यूगट एक स्टैक का उपयोग नहीं करने का विकल्प चुनता है (सब कुछ इनलाइन करें (यदि मैं इनका पता नहीं लगाता तो कार्य और चर))।

$ cat stack.c
#include <stdio.h>

int stack(int x) {
  printf("level %d: x is at %p\n", x, (void*)&x);
  if (x == 0) return 0;
  return stack(x - 1);
}

int main(void) {
  stack(4);
  return 0;
}

$ / usr / bin / gcc -Wall -Wextra -std = c89 -pedative stack.c

$ ./a.out
स्तर 4: x 0x7fff7781190c पर है
स्तर 3: x 0x7fff778118ec पर है
स्तर 2: x 0x7fff778118cc पर है
स्तर 1: x 0x7fff778118ac पर है
स्तर 0: x 0x7fff7781188c पर है

Question 11

स्टैक नीचे बढ़ता है (x86 पर)। हालाँकि, फ़ंक्शन लोड होने पर स्टैक को एक ब्लॉक में आवंटित किया जाता है, और आपके पास स्टैक पर आइटम क्या होंगे, इसकी गारंटी नहीं है।

इस मामले में, इसने स्टैक पर दो ints और तीन-इंट सरणी के लिए स्थान आवंटित किया। यह भी सरणी के बाद एक अतिरिक्त 12 बाइट्स आवंटित किया, तो यह इस तरह दिखता है:

[१२ बाइट्स]
पैडिंग (?) [१२ बाइट्स]
s [४ बाइट्स]
q [४ बाइट्स]

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

यदि आप यह जानना चाहते हैं कि कोड को असेंबली भाषा में क्यों संकलित किया गया है, तो मेरा मानना है कि यह MS-C कंपाइलर पर gcc और / S पर है। यदि आप उस फ़ंक्शन के शुरुआती निर्देशों को देखते हैं, तो आप पुराने स्टैक पॉइंटर को सहेजते हुए देखेंगे और फिर उसमें से 32 (या कुछ और) घटाए जाएंगे। वहां से, आप देख सकते हैं कि कैसे कोड 32-बाइट मेमोरी को ब्लॉक करता है और यह पता लगाता है कि आपका कंपाइलर क्या कर रहा है। फ़ंक्शन के अंत में, आप स्टैक पॉइंटर को पुनर्स्थापित किया जा सकता है।

Question 12

यह आपके ऑपरेटिंग सिस्टम और आपके कंपाइलर पर निर्भर करता है।

Question 13

ढेर बढ़ता जाता है। तो f (g (h (h))), h के लिए आवंटित किया गया स्टैक लोअर एड्रेस पर शुरू होगा फिर g और g का कम होगा फिर f-a होगा। लेकिन स्टैक के भीतर चर को सी विनिर्देश का पालन करना पड़ता है,

http://c0x.coding-guidelines.com/6.5.8.html

1206 यदि इंगित की गई वस्तुएं समान एग्रीगेट ऑब्जेक्ट की सदस्य हैं, तो बाद में घोषित किए गए स्ट्रक्चर मेंबर्स के लिए पॉइंटर्स स्ट्रक्चर में पहले घोषित किए गए सदस्यों की तुलना में अधिक पॉइंटर्स की तुलना करते हैं, और बड़े सबस्क्रिप्ट वैल्यू वाले एलिमेंट्स की तुलना पॉइंटर्स से ज्यादा करने वाले पॉइंटर्स की तुलना करते हैं। कम सबस्क्रिप्ट मानों के साथ सरणी।

& [0] <& a [१], हमेशा सच होना चाहिए, भले ही 'ए' आवंटित किया गया हो

Question 14

यह नीचे की ओर बढ़ता है और इसकी वजह यह है कि मेमोरी में डेटा के सेट के लिए थोड़ा एंडियन बाइट ऑर्डर मानक है।

यदि आप इसे देख सकते हैं, तो यह है कि स्टैक ऊपर की ओर बढ़ता है, यदि आप 0 से मेमोरी देखते हैं, तो नीचे से ऊपर और अधिकतम से।

स्टैक के नीचे की ओर बढ़ने का कारण स्टैक या बेस पॉइंटर के परिप्रेक्ष्य से डीरेफेरेंस करने में सक्षम होना है।

याद रखें कि किसी भी प्रकार की dereferencing निम्नतम से उच्चतम पते तक बढ़ जाती है। चूंकि स्टैक नीचे की ओर बढ़ता है (उच्चतम से निम्नतम पता) यह आपको स्टैक को डायनामिक मेमोरी की तरह व्यवहार करने देता है।

यह एक कारण है कि इतनी सारी प्रोग्रामिंग और स्क्रिप्टिंग भाषाएं रजिस्टर-आधारित के बजाय स्टैक-आधारित वर्चुअल मशीन का उपयोग करती हैं।

Question 15

यह आर्किटेक्चर पर निर्भर करता है। अपने स्वयं के सिस्टम की जांच करने के लिए, GeeksForGeeks से इस कोड का उपयोग करें :

// C program to check whether stack grows 
// downward or upward. 
#include<stdio.h> 

void fun(int *main_local_addr) 
{ 
    int fun_local; 
    if (main_local_addr < &fun_local) 
        printf("Stack grows upward\n"); 
    else
        printf("Stack grows downward\n"); 
} 

int main() 
{ 
    // fun's local variable 
    int main_local; 

    fun(&main_local); 
    return 0; 
}