看来我在编程语言设计中得到了调用栈的概念.但我找不到(可能,我只是不够努力搜索)任何堆栈帧的正确解释.

所以我想请一个人用几句话向我解释.

我正在准备C中的一些培训材料,我希望我的示例适合典型的堆栈模型.

C堆栈在Linux,Windows,Mac OSX(PPC和x86),Solaris和最新的Unix中的发展方向是什么？

出于某种原因,我的第二个字符数组(var2)与第一个字符数组(var1)合并.这是我的代码:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main()     
{
  char var1[5] = "Hello";
  char var2[5] = "World";

  printf("This program can write:\t%s\t%s\n", var1, var2);
  getch();
  return 0;
}

在编译之后,我得到了以下打印:

这个程序可以写:Hello WorldHello

当我更改代码时,printf("This program can write:\t%s\n", var2);我得到以下打印:

这个程序可以写:WorldHello

所以很明显var1正在与var2合并.

这是某种编译错误吗？如果是这样,我该如何解决？我尝试重新安装MINGW,但我仍然得到相同的结果.

非常感谢

为什么返回的指针地址的十六进制值总是按降序排列？例如在这里int a被宣布之前int d,所以它的地址总是出来是大于d,和同为&b,&e和&c,&f我想知道,这是一个固定的行为,或者是这个编译器相关的？我正在使用gcc version 4.4.5 (Ubuntu/Linaro 4.4.4-1)

#include<stdio.h>

int main(void){
    int a=1;
    int d=1;
    char b='a' ;
    char e='a';
    float c=1.0;
    float f=1.0;
    printf("a=%p\nd=%p\nb=%p\ne=%p\nc=%p\nf=%p\n",&a,&d,&b,&e,&c,&f);
   if (&a>&d)
        printf("&a>&d\n");
    else
    {printf("&a<&d");
    }
   if (&a>&d && &b>&e && &c>&f)
       printf("addresses are in descending order");
   else{
       printf("false");
   }

  return 0;

}

输出:

a=0xbfc6bd98         //a>d
d=0xbfc6bd94         
b=0xbfc6bd9f         //b>e
e=0xbfc6bd9e
c=0xbfc6bd90         //c>f
f=0xbfc6bd8c
&a>&d 
addresses are in descending order

PS:我是c的新手

据我所知,堆栈假设向下增长.

我试着运行这段代码:

#include<stdio.h>

void func(char* a1, int a2, int a3) {

    char b1[10];
    int b2;
    int b3;

    printf("a3 address is: %p\n", &a3);
    printf("a2 address is: %p\n", &a2);
    printf("a1 address is: %p\n", &a1);
    printf("-----------------------\n");
    printf("b1 address is: %p\n", &b1);
    printf("b2 address is: %p\n", &b2);
    printf("b3 address is: %p\n", &b3);
}


int main() {
    func("string",2,3);
    return 0;
}

结果不像我预期的那样:

a3 address is: 0x7fff68473190
a2 address is: 0x7fff68473194
a1 address is: 0x7fff68473198
-----------------------
b1 address is: 0x7fff684731b0
b2 address is: 0x7fff684731a8
b3 address …

我试图深入学习指针的概念.在下面的代码中,我创建了一个数组,创建了一个指向每个元素的指针.

int bucky[5];
int *bp0 = &bucky[0];
int *bp1 = &bucky[1];
int *bp2 = &bucky[2];

cout<<"bp0 is at memory address:"<<bp0<<endl;
cout<<"bp1 is at memory address:"<<bp1<<endl;
cout<<"bp2 is at memory address:"<<bp2<<endl;

这些是给予数组元素的内存分配.

bp0在内存地址:0x0018ff3c
bp1在内存地址:0x0018ff40
bp2在内存地址:0x0018ff44

由于我对c ++的了解有限,我知道内存是连续分配给一个数组的.但仔细观察输出,bp0看起来不合适.

据我说bp0应该在0x0018ff36.或者是0x0018ff3c , 0x0018ff40 , 0x0018ff44CPU 中的位置是连续的？

那么有可能在一个进程中没有分配两个连续的内存分配吗？

我试图得到堆栈的概念,我有困惑,我试图找到答案,但找不到.

好的,所以值只从顶部存储在堆栈中意味着它随着值位置逐渐增长而增长,这意味着增长方向应该向上,如图所示:

堆栈向上增长的例子

但Stack如上所述向下增长.怎么样？？

如果我理解正确的话:

当值存储在堆栈中时,它占用空间,因此它意味着堆栈不会增长,因为它的内存正在减少,但是当值从堆栈返回时,堆栈会增长,因为存储在堆栈中是空闲的.还有一个关于stackoverflow的答案说堆栈的发光方向与发光的方向相反 我是否正确？如果没有请解释

我发现很奇怪的是，当你在 Rust 中创建静态分配的变量时，它似乎随着堆栈指针的增加而增加。我知道情况并非如此，因为堆栈指针随着内存分配而减少。

如果我在 C 中做同样的事情，我会看到堆栈指针随着我创建更多变量而减少。

为什么会这样呢？Rust 编译器是否从下到上而不是从上到下分配它们？

fn main() {
    let i1 = 1;
    let i2 = 1;
    let i3 = 1;
    println!("i1 : {:?}", &i1 as *const i32);
    println!("i2 : {:?}", &i2 as *const i32);
    println!("i3 : {:?}", &i3 as *const i32);
}

当我运行这个程序时，我收到以下信息：

fn main() {
    let i1 = 1;
    let i2 = 1;
    let i3 = 1;
    println!("i1 : {:?}", &i1 as *const i32);
    println!("i2 : {:?}", &i2 as *const i32);
    println!("i3 : {:?}", &i3 as …

堆栈是使用C程序增加还是减少？

可能的重复:
堆栈增长方向
堆栈是向上还是向下增长？

大家好,

我怎样才能知道机器的堆栈是否在C内存中增长或减少.更重要的是,哪个更好:堆栈增长的系统还是堆栈增长的系统？

以下逻辑工作???

void sub(int *a) 
{
int b;

if (&b > a) {
printf("Stack grows up.");
}
else  
{
printf("Stack grows down.");
}
}
main ()
{
int a;
sub(&a);
}

我的意思是这个表达式在C中有效

if (&b > a)