สแต็กเติบโตขึ้นหรือลง?

ฉันมีรหัสชิ้นนี้ใน 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 อย่าง:

1. สแต็กเติบโตขึ้นหรือลง? (ดูเหมือนทั้งกับฉันในกรณีนี้)
2. เกิดอะไรขึ้นระหว่างa[2]และqที่อยู่หน่วยความจำ? เหตุใดจึงมีความทรงจำที่แตกต่างกันมาก (20 ไบต์)

หมายเหตุ: นี่ไม่ใช่คำถามการบ้าน ฉันอยากรู้ว่าสแต็กทำงานอย่างไร ขอบคุณสำหรับความช่วยเหลือ

พฤติกรรมของสแต็ก (เติบโตขึ้นหรือเติบโตลง) ขึ้นอยู่กับไบนารีอินเทอร์เฟซของแอปพลิเคชัน (ABI) และวิธีจัดระเบียบ call stack (aka activation record)

ตลอดอายุการใช้งานโปรแกรมจะต้องสื่อสารกับโปรแกรมอื่น ๆ เช่น OS ABI กำหนดว่าโปรแกรมสามารถสื่อสารกับโปรแกรมอื่นได้อย่างไร

สแต็กสำหรับสถาปัตยกรรมที่แตกต่างกันสามารถเติบโตได้ทั้งสองวิธี แต่สำหรับสถาปัตยกรรมนั้นจะสอดคล้องกัน กรุณาตรวจสอบนี้เชื่อมโยงวิกิพีเดีย แต่การเติบโตของสแต็กจะถูกกำหนดโดย ABI ของสถาปัตยกรรมนั้น

ตัวอย่างเช่นหากคุณใช้ MIPS ABI call stack จะถูกกำหนดดังต่อไปนี้

ให้เราพิจารณาว่าฟังก์ชัน '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' ที่ได้รับการจัดสรรหน่วยความจำสแต็กก่อน แต่โดยทั่วไปคอมไพลเลอร์จะจัดสรรหน่วยความจำสแตกตามลำดับของการประกาศตัวแปร)

แต่ในกรณีของอาร์เรย์การจัดสรรจะมีตัวชี้เพียงตัวเดียวและต้องมีการจัดสรรหน่วยความจำจะชี้โดยตัวชี้เดียว หน่วยความจำต้องอยู่ติดกันสำหรับอาร์เรย์ ดังนั้นแม้ว่าสแต็กจะลดลง แต่สำหรับอาร์เรย์ที่สแต็กจะเติบโตขึ้น

นี่เป็นคำถามสองข้อ หนึ่งคือวิธีที่สแต็กเติบโตขึ้นเมื่อฟังก์ชันหนึ่งเรียกใช้อีกฟังก์ชันหนึ่ง (เมื่อมีการจัดสรรเฟรมใหม่) และอีกอันเกี่ยวกับการจัดวางตัวแปรในเฟรมของฟังก์ชันหนึ่ง ๆ

มาตรฐาน C ไม่ได้ระบุไว้ แต่คำตอบแตกต่างกันเล็กน้อย:

• สแต็กจะเติบโตไปทางใดเมื่อมีการจัดสรรเฟรมใหม่ - ถ้าฟังก์ชัน f () เรียกใช้ฟังก์ชัน g () fตัวชี้เฟรมจะมากกว่าหรือน้อยกว่าgตัวชี้เฟรม สิ่งนี้สามารถไปได้ทางใดทางหนึ่ง - ขึ้นอยู่กับคอมไพเลอร์และสถาปัตยกรรมเฉพาะ (ค้นหา "การเรียกแบบการประชุม") แต่จะสอดคล้องกันเสมอภายในแพลตฟอร์มที่กำหนด (มีข้อยกเว้นแปลก ๆ เล็กน้อยดูความคิดเห็น) ขาลงเป็นเรื่องปกติมากขึ้น เป็นกรณีใน x86, PowerPC, MIPS, SPARC, EE และ Cell SPU
• ตัวแปรโลคัลของฟังก์ชันถูกจัดวางภายในเฟรมสแต็กอย่างไร สิ่งนี้ไม่ระบุและไม่สามารถคาดเดาได้อย่างสมบูรณ์ คอมไพเลอร์มีอิสระในการจัดเรียงตัวแปรภายในอย่างไรก็ตามต้องการให้ได้ผลลัพธ์ที่มีประสิทธิภาพสูงสุด

ทิศทางที่สแต็กเติบโตเป็นสถาปัตยกรรมเฉพาะ ที่กล่าวว่าความเข้าใจของฉันคือสถาปัตยกรรมฮาร์ดแวร์เพียงไม่กี่ชิ้นเท่านั้นที่มีสแต็กที่เติบโต

ทิศทางที่สแต็กเติบโตขึ้นนั้นไม่ขึ้นอยู่กับโครงร่างของวัตถุแต่ละชิ้น ดังนั้นในขณะที่สแต็กอาจขยายตัวลงอาร์เรย์จะไม่ (กล่าวคือ & array [n] จะเป็น <& array [n + 1]);

ไม่มีสิ่งใดในมาตรฐานที่กำหนดวิธีการจัดระเบียบสิ่งต่างๆบนสแต็กเลย ในความเป็นจริงคุณสามารถสร้างคอมไพเลอร์ที่สอดคล้องกันซึ่งไม่ได้เก็บองค์ประกอบอาร์เรย์ไว้ที่องค์ประกอบที่อยู่ติดกันบนสแต็กเลยหากมีความชาญฉลาดในการคำนวณองค์ประกอบอาร์เรย์อย่างถูกต้อง (เพื่อให้รู้ว่า1คือ 1K ห่างจาก [0] และสามารถปรับได้)

เหตุผลที่คุณอาจได้รับผลลัพธ์ที่แตกต่างกันเนื่องจากในขณะที่สแต็กอาจขยายตัวลงเพื่อเพิ่ม "วัตถุ" เข้าไปอาร์เรย์นั้นเป็น "วัตถุ" เดียวและอาจมีองค์ประกอบอาร์เรย์จากน้อยไปหามากในลำดับที่ตรงกันข้าม แต่ไม่ปลอดภัยที่จะพึ่งพาพฤติกรรมดังกล่าวเนื่องจากทิศทางสามารถเปลี่ยนแปลงได้และตัวแปรสามารถสลับไปมาได้ด้วยเหตุผลหลายประการรวมถึง แต่ไม่ จำกัด เพียง:

• การเพิ่มประสิทธิภาพ
• การจัดตำแหน่ง
• ความต้องการของบุคคลที่เป็นส่วนจัดการสแต็กของคอมไพเลอร์

ดูที่นี่สำหรับบทความที่ดีเยี่ยมของฉันในทิศทางสแต็ค :-)

เพื่อตอบคำถามเฉพาะของคุณ:

1. สแต็กเติบโตขึ้นหรือลง?
   มันไม่สำคัญเลย (ในแง่ของมาตรฐาน) แต่เนื่องจากคุณถามมันสามารถเติบโตขึ้นหรือลงในหน่วยความจำขึ้นอยู่กับการใช้งาน
2. เกิดอะไรขึ้นระหว่างที่อยู่หน่วยความจำ [2] และ q เหตุใดจึงมีความทรงจำที่แตกต่างกันมาก (20 ไบต์)?
   มันไม่สำคัญเลย (ในแง่ของมาตรฐาน) ดูเหตุผลที่เป็นไปได้ด้านบน

บน x86 หน่วยความจำ "การจัดสรร" ของสแต็กเฟรมประกอบด้วยการลบจำนวนไบต์ที่จำเป็นออกจากตัวชี้สแต็ก (ฉันเชื่อว่าสถาปัตยกรรมอื่น ๆ ก็คล้ายกัน) ในแง่นี้ฉันเดาว่าสแต็กคำราม "ลง" เนื่องจากที่อยู่จะเล็กลงเรื่อย ๆ เมื่อคุณเรียกลึกเข้าไปในสแต็กมากขึ้น (แต่ฉันมักจะจินตนาการถึงหน่วยความจำโดยเริ่มต้นด้วย 0 ที่ด้านซ้ายบนและได้รับแอดเดรสที่ใหญ่ขึ้นเมื่อคุณย้าย ไปทางขวาและปิดลงดังนั้นในภาพจิตของฉันสแต็คจึงเติบโตขึ้น ... ) ลำดับของตัวแปรที่ประกาศอาจไม่มีผลต่อที่อยู่ของพวกเขา - ฉันเชื่อว่ามาตรฐานอนุญาตให้คอมไพเลอร์จัดลำดับใหม่ได้ตราบเท่าที่ไม่ก่อให้เกิดผลข้างเคียง (โปรดแก้ไขฉันหากฉันผิด) . พวกเขา '

ช่องว่างรอบอาร์เรย์อาจเป็นช่องว่างบางอย่าง แต่ก็ลึกลับสำหรับฉัน

ก่อนอื่นพื้นที่ 8 ไบต์ที่ไม่ได้ใช้ในหน่วยความจำ (ไม่ใช่ 12 จำสแต็กจะลดลงดังนั้นพื้นที่ที่ไม่ได้รับการจัดสรรคือจาก 604 ถึง 597) และทำไม?. เนื่องจากข้อมูลทุกประเภทใช้พื้นที่ในหน่วยความจำโดยเริ่มจากแอดเดรสหารด้วยขนาด ในกรณีอาร์เรย์ของจำนวนเต็ม 3 จำนวนใช้พื้นที่หน่วยความจำ 12 ไบต์และ 604 หารด้วย 12 ไม่ได้ดังนั้นจึงเว้นช่องว่างไว้จนกว่าจะพบแอดเดรสหน่วยความจำซึ่งหารด้วย 12 ได้เท่ากับ 596

ดังนั้นพื้นที่หน่วยความจำที่จัดสรรให้กับอาร์เรย์จึงอยู่ระหว่าง 596 ถึง 584 แต่เนื่องจากการจัดสรรอาร์เรย์เป็นไปอย่างต่อเนื่องดังนั้นองค์ประกอบแรกของอาร์เรย์จึงเริ่มต้นจาก 584 แอดเดรสไม่ใช่จาก 596

คอมไพเลอร์มีอิสระในการจัดสรรตัวแปรภายใน (อัตโนมัติ) ณ ที่ใด ๆ บนเฟรมสแต็กในเครื่องคุณไม่สามารถสรุปทิศทางการเติบโตของสแต็กได้อย่างน่าเชื่อถือจากสิ่งนั้น คุณสามารถอนุมานทิศทางการเติบโตของสแต็กได้จากการเปรียบเทียบที่อยู่ของเฟรมสแต็กที่ซ้อนกันนั่นคือการเปรียบเทียบที่อยู่ของตัวแปรโลคัลภายในสแต็กเฟรมของฟังก์ชันเทียบกับแคลลี:

#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;
}

ฉันไม่คิดว่ามันจะเป็นแบบนั้น อาร์เรย์ดูเหมือนจะ "เติบโต" เนื่องจากหน่วยความจำนั้นควรได้รับการจัดสรรอย่างต่อเนื่อง อย่างไรก็ตามเนื่องจาก q และ s ไม่เกี่ยวข้องกันเลยคอมไพเลอร์จึงติดแต่ละหน่วยความจำไว้ในตำแหน่งหน่วยความจำที่ว่างโดยพลการภายในสแต็กซึ่งอาจเป็นขนาดที่พอดีกับขนาดจำนวนเต็มดีที่สุด

สิ่งที่เกิดขึ้นระหว่าง [2] และ q คือช่องว่างรอบตำแหน่งของ q ไม่ใหญ่พอ (กล่าวคือไม่ใหญ่กว่า 12 ไบต์) เพื่อจัดสรรอาร์เรย์จำนวนเต็ม 3 ตัว

สแต็กของฉันดูเหมือนจะขยายไปยังที่อยู่ที่มีหมายเลขต่ำกว่า

คอมพิวเตอร์เครื่องอื่นอาจแตกต่างกันหรือแม้แต่ในคอมพิวเตอร์ของฉันเองถ้าฉันใช้การเรียกใช้คอมไพเลอร์ ... หรือคอมไพเลอร์ muigt เลือกที่จะไม่ใช้สแต็กเลย (อินไลน์ทุกอย่าง (ฟังก์ชันและตัวแปรถ้าฉันไม่ได้ใช้ที่อยู่ของพวกเขา))

$ 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 -pedantic stack.c

$ ./a.out
ระดับ 4: x อยู่ที่ 0x7fff7781190c
ระดับ 3: x อยู่ที่ 0x7fff778118ec
ระดับ 2: x อยู่ที่ 0x7fff778118cc
ระดับ 1: x อยู่ที่ 0x7fff778118ac
ระดับ 0: x อยู่ที่ 0x7fff7781188c

สแต็กเติบโตลง (บน x86) อย่างไรก็ตามสแต็กจะถูกจัดสรรในบล็อกเดียวเมื่อฟังก์ชันโหลดขึ้นและคุณไม่มีการรับประกันว่าไอเท็มจะอยู่ในสแต็กลำดับใด

ในกรณีนี้จะจัดสรรพื้นที่สำหรับสอง ints และอาร์เรย์สาม int บนสแต็ก นอกจากนี้ยังจัดสรรอีก 12 ไบต์เพิ่มเติมหลังจากอาร์เรย์ดังนั้นจึงมีลักษณะดังนี้:

ช่องว่างภายใน [12 ไบต์] (?) [12 ไบต์]
s [4 ไบต์]
q [4 ไบต์]

ไม่ว่าด้วยเหตุผลใดคอมไพเลอร์ของคุณจึงตัดสินใจว่าจำเป็นต้องจัดสรร 32 ไบต์สำหรับฟังก์ชันนี้และอาจมากกว่านั้น คุณเป็นโปรแกรมเมอร์ C คุณไม่เข้าใจว่าทำไม

ถ้าคุณอยากรู้ว่าทำไมคอมไพล์โค้ดเป็นภาษาแอสเซมบลีฉันเชื่อว่ามันเป็น -S บน gcc และ / S บนคอมไพเลอร์ C ของ MS หากคุณดูคำแนะนำในการเปิดฟังก์ชันนั้นคุณจะเห็นตัวชี้สแต็กเก่าถูกบันทึกและลบ 32 (หรืออย่างอื่น!) ออกจากฟังก์ชันนั้น จากตรงนั้นคุณสามารถดูว่าโค้ดเข้าถึงบล็อกหน่วยความจำ 32 ไบต์นั้นได้อย่างไรและดูว่าคอมไพเลอร์ของคุณกำลังทำอะไรอยู่ ในตอนท้ายของฟังก์ชันคุณจะเห็นตัวชี้สแต็กถูกเรียกคืน

ขึ้นอยู่กับระบบปฏิบัติการและคอมไพเลอร์ของคุณ

สแต็คเติบโตลง ดังนั้น f (g (h ())) สแต็กที่จัดสรรสำหรับ h จะเริ่มต้นที่ที่อยู่ต่ำกว่าจากนั้น g และ g จะต่ำกว่าตามด้วย f แต่ตัวแปรภายในสแตกต้องเป็นไปตามข้อกำหนด C

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

1206 ถ้าออบเจ็กต์ที่ชี้ไปเป็นสมาชิกของอ็อบเจ็กต์การรวมเดียวกันตัวชี้ไปยังสมาชิกโครงสร้างที่ประกาศในภายหลังจะเปรียบเทียบมากกว่าพอยน์เตอร์ถึงสมาชิกที่ประกาศไว้ก่อนหน้านี้ในโครงสร้างและพอยน์เตอร์ไปยังองค์ประกอบอาร์เรย์ที่มีค่าตัวห้อยมากกว่าจะเปรียบเทียบมากกว่าพอยน์เตอร์กับองค์ประกอบที่เหมือนกัน อาร์เรย์ที่มีค่าตัวห้อยต่ำกว่า

& a [0] <& a [1] ต้องเป็นจริงเสมอไม่ว่าจะจัดสรร "a" อย่างไร

เติบโตลงและนี่เป็นเพราะมาตรฐานคำสั่ง endian byte เล็กน้อยเมื่อพูดถึงชุดข้อมูลในหน่วยความจำ

วิธีหนึ่งที่คุณสามารถดูได้ก็คือสแต็กจะเติบโตขึ้นด้านบนถ้าคุณดูหน่วยความจำจาก 0 จากด้านบนและสูงสุดจากด้านล่าง

สาเหตุที่ทำให้สแต็กเติบโตลดลงคือสามารถหักล้างจากมุมมองของสแต็กหรือตัวชี้ฐานได้

โปรดจำไว้ว่าการยกเลิกการอ้างอิงประเภทใด ๆ จะเพิ่มขึ้นจากที่อยู่ต่ำสุดไปสูงสุด เนื่องจาก Stack ขยายตัวลง (ที่อยู่สูงสุดไปต่ำสุด) จึงช่วยให้คุณปฏิบัติกับสแต็กเหมือนหน่วยความจำแบบไดนามิก

นี่เป็นสาเหตุหนึ่งที่ทำให้การเขียนโปรแกรมและภาษาสคริปต์จำนวนมากใช้เครื่องเสมือนแบบสแต็กแทนที่จะใช้การลงทะเบียน

มันขึ้นอยู่กับสถาปัตยกรรม ในการตรวจสอบระบบของคุณเองให้ใช้รหัสนี้จาก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; 
}