好吧,我知道main()自动局部变量存储在堆栈中,也是任何函数自动局部变量,但是当我在gcc版本4.6.3上尝试了以下代码时:
#include <stdio.h>
int main(int argc, char *argv[]) {
int var1;
int var2;
int var3;
int var4;
printf("%p\n%p\n%p\n%p\n",&var1,&var2,&var3,&var4);
}
结果是:
0xbfca41e0
0xbfca41e4
0xbfca41e8
0xbfca41ec
根据堆栈顶部的var4和堆栈底部的var1以及堆栈指针现在指向var1地址下面的地址....但是为什么var4位于堆栈顶部而var1位于底部. ..在var1之后声明,所以我认为逻辑上var1应该在堆栈的顶部,var1之后声明的任何变量应该在内存中低于它...所以在我的例子中这样:
>>var1 at 0xbfca41ec
>>var2 at 0xbfca41e8
>>var3 at 0xbfca41e4
>>var4 at 0xbfca41e0
>>and stack pointer pointing here
..
编辑1:
在阅读@AusCBloke的评论后,我尝试了以下代码:
#include <stdio.h>
void fun(){
int var1;
int var2;
printf("inside the function\n");
printf("%p\n%p\n",&var1,&var2);
}
int main(int argc, char *argv[]) {
int var1;
int var2;
int var3;
int var4;
printf("inside the main\n");
printf("%p\n%p\n%p\n%p\n",&var1,&var2,&var3,&var4);
fun();
return …好的,下面的代码是完全废弃的,我编写的无意义代码; 但是我觉得奇怪的是我可以从qwerty()函数访问变量"b",而b只是在里面声明了......我想我只能在某种程度上以全局方式声明它才能访问它？
x = 14
while (x > 10):
b = 3
b += 3
print(b)
x -= 1
def qwerty():
if b == 6:
print("b can be accessed elsewhere?")
input("")
运行此代码,"b可以在其他地方访问吗？" 将打印...即使b == 6引用在单独的while()函数中声明的变量b.
我想我仍然对python中全局变量和局部变量的属性感到困惑.谁能解释为什么会发生这种情况？
在这段代码,为什么在我的测试结果总是1,2和3？
#include <stdio.h>
void test() {
int a;
a++;
printf("%d",a);
}
int main(int argc, char *argv[]) {
test();
test();
test();
}
我认为变量test()是静态的,不是吗？为什么？
我正在从C ++迁移到Java，并且在理解数组如何在Java中如何在其创建方法之外持久存在一个问题。请看下面的简单代码：
public static int[] arrayMethod(){
int[] tempArray = {1, 2, 3, 4};
return tempArray;
}
public static void main(String[] args){
int arr[] = arrayMethod();
for(int i : arr){
System.out.println(i);
}
}
在C ++中，除非使用new操作符动态分配数组，否则在调用后该数组将不存在，因为它是在方法中本地创建的。据我了解，Java总是按值传递，而数组是引用类型，因此我的c ++逻辑会告诉我，我正在返回对本地创建的数组的引用。我想念什么？
嗨,我想知道是否有人可以向我解释为什么用以下代码编写的地图函数是按照其编写的方式编写的.具体来说,我们需要做什么
results = letters.map do |letter| encrypted_letter = encrypt_letter(letter)
而不只是做
results = letters.map do |letter| encrypt_letter(letter)
class Encryptor
def cipher
{"a" => "n", "b" => "o", 'c' => 'p', 'd' => 'q',
'e' => 'r', 'f' => 's', 'g' => 't', 'h' => 'u',
'i' => 'v', 'j' => 'w', 'k' => 'x', 'l' => 'y',
'm' => 'z', 'n' => 'a', 'o' => 'b', 'p' => 'c',
'q' => 'd', 'r' => 'e', 's' => 'f', 't' => 'g', …我正在浏览ruby Kernel doc并看到了这个方法:
a = 2
local_variables # => [:a, :_]
它为什么会回归:a而不是？我认为":"是为符号保留的,但是符号:a不指向变量a也不指向它的赋值,2.
此外,我将如何通过此方法访问实际变量？如在b = local_variables.first(将是2,但是:a).
这种行为背后有原因,它是什么？
谢谢/
我之前问过这个问题,但我得不到合适的答案.
如果非最终字段的值可以更改,那么如何在匿名类类中使用它们？
class Foo{
private int i;
void bar(){
i = 10
Runnable runnable = new Runnable (){
public void run (){
System.out.println(i); //works fine
}//end method run
}//end Runnable
}//end method bar
}//end class Foo
如果在匿名类中使用的局部变量必须final使编译器能够在匿名类代码中内联它们的值,如下所示:
之前:
public class Access1 {
public void f() {
final int i = 3;
Runnable runnable = new Runnable() {
public void run() {
System.out.println(i);
}//end method run
};//end anonymous class
}//end method f
}//end class Access1
后:
public class Access1 …我是编程新手.当我注意到一些奇怪的行为时,我试图将等式的总和加到前一个值上.
如果我int result在里面声明int main ()然后我得到一个空白答案,但如果我int result在外面声明,int main ()那么我得到这些值:6,11,16 ... 91,96,101.这对我没有意义,因为我没有其他功能.
为什么会这样？
#include<iostream>
using namespace std;
int main ()
{
int y =1;
int result;
while (result <100)
{
result = y +5;
cout << result << ",";
y = result;
}
}
假设我们有以下代码：
void foo() {
char buffer[100];
}
在foo（）返回之前，C语言中是否有一种（最好是可移植的）方式从运行时堆栈中释放缓冲区（又称添加esp，在程序集中为100 ）？
c memory-management local-variables static-allocation stack-pointer