谁定义了堆栈指针地址
堆栈指针地址是由编程语言和计算机体系结构共同定义的。具体来说，堆栈指针地址是指向当前函数的堆栈帧的指针地址，用于管理函数的局部变量、参数以及函数调用的返回地址。
在编程语言中，堆栈指针地址的定义通常是由编译器和运行时环境来处理的。编译器负责在编译阶段分配和管理堆栈空间，并生成相应的机器代码。运行时环境则负责在程序执行过程中跟踪和更新堆栈指针地址。
在计算机体系结构中，堆栈指针地址的定义与操作系统和处理器架构有关。操作系统负责在程序执行时为每个线程分配堆栈空间，并管理堆栈指针地址的分配和释放。处理器架构则定义了堆栈指针地址的具体使用方式，如寄存器中保存堆栈指针的地址。
堆栈指针地址在程序中具有重要的作用。它不仅用于访问和操作函数的局部变量和参数，还用于控制函数的执行流程，包括函数调用和返回。
在云计算领域，堆栈指针地址的概念同样适用。云计算平台提供的服务和工具可以帮助开发人员在云环境中进行应用程序的开发、部署和管理。在云计算中，开发人员可以利用堆栈指针地址来实现函数调用、参数传递和返回值处理等功能。
对于堆栈指针地址的优势和应用场景，可以总结如下：
- 内存管理：堆栈指针地址的使用可以有效管理内存空间，包括局部变量、函数参数和返回地址等，提高内存利用率和程序执行效率。
- 函数调用：堆栈指针地址用于实现函数的调用和返回过程，确保程序的正确执行顺序和流程。
- 参数传递：堆栈指针地址可用于传递函数的参数值，使函数能够接收和处理外部传入的数据。
- 局部变量：堆栈指针地址用于分配和管理函数的局部变量，保证变量的作用域和生命周期。
- 异常处理：堆栈指针地址在异常处理中起到重要作用，包括函数调用栈的回溯和错误信息的定位等。
针对云计算领域，腾讯云提供了一系列相关产品和服务，可以帮助开发人员在云环境中进行堆栈指针地址的管理和应用，其中包括：
- 腾讯云函数（云原生/无服务器计算服务）：腾讯云函数是一种基于事件驱动的计算服务，可实现函数的自动化运行，支持灵活的堆栈指针地址管理和使用方式。了解更多：腾讯云函数
- 腾讯云容器服务（容器化部署服务）：腾讯云容器服务提供了一种高度可扩展和可管理的容器化部署环境，可支持开发人员在云环境中灵活管理和使用堆栈指针地址。了解更多：腾讯云容器服务
- 腾讯云弹性伸缩（自动化扩展服务）：腾讯云弹性伸缩可以根据负载情况自动调整云资源的数量和配置，帮助开发人员实现高效的堆栈指针地址管理和优化。了解更多：腾讯云弹性伸缩
总结而言，堆栈指针地址是由编程语言和计算机体系结构共同定义的，在云计算领域中具有重要作用。腾讯云提供了一系列相关产品和服务，可支持开发人员在云环境中管理和使用堆栈指针地址。
相关·内容
__cdecl的调用约定是:调用者清理堆栈。
__stdcall调用约定是这样说的:被调用者清理堆栈。
所以我试着测试下面的代码：
#include <...>
char *callee()
{
char str[] = "abcd";
return str;
}
int main()
{
char *str;
str = callee();
printf("%s\n", str);
return 0;
}
根据上面的两个调用约定，我认为：
__cdecl堆栈清理由调用者执行，因此printf(
浏览 2提问于2011-03-04得票数 7
回答已采纳
我想知道是什么定义了内存对象的起始地址比对象的结尾更低或更高。例如：
char buffer[10];
char* p = &buffer[0];
printf("%p\n",p); //0x7fff064a6276
p = &buffer[9];
printf("%p\n",p); //0x7fff064a627f
在本例中，对象的起始地址低于结束地址。即使堆栈朝着较低的地址增长。
为什么布局与堆栈增长的方向相反？
是什么定义了这个方向？语言？奥斯？编译器？CPU架构？
对象的结尾总是在一个比开头更高的地址上吗？
浏览 1提问于2016-10-08得票数 0
回答已采纳
对于RISC-V，堆栈指针是指向堆栈上的最后一个数据，还是堆栈的下一个空闲地址位置？
当堆栈指针在程序开始时被初始化(例如crt.S) (即堆栈是空的)，是否应该初始化堆栈指针以指向第一个单词将被推送的内存位置或前面的地址？(例如，假设堆栈的第一个元素将在4092被推送。那么，堆栈指针是从4096还是4092开始的呢？)
我们将非常感谢指向这个定义的指针。
浏览 2提问于2021-08-04得票数 2
2回答
我定义了一个结构的静态全局数组，其中有些元素被定义为指针。此数组将由我在项目中使用的静态库填充和管理。我发现这个数组被库正确地填充了。几秒钟后，这个数组中的一些值会被覆盖到其他地方。调试后，我发现stack指针(SP)指向保存数组某些成员的同一内存位置，因此，当调用函数并将其本地值保存在堆栈中时，当推送到堆栈时，将覆盖该值。
我的问题是:是什么原因导致堆栈指针指向另一个变量占用的内存位置？如何进一步调试此问题？
我知道我的问题是一般性的，但不幸的是，我不能提供一个最小的代码来重现问题，因为它是一个大项目，而且我也不知道代码的哪一部分会导致这样的问题。
浏览 8提问于2022-06-09得票数 -1
5回答
我在上读了这一章，发现了这句话：
您将使用指针来处理堆上分配的变量。(您可以使用指针来处理堆栈变量，但在大多数情况下，这是不必要的)。
我知道如何使用指针来处理堆上分配的变量。但我无法想象如何使用它来处理堆栈变量。由于当函数退出(即变量被从堆栈中推开)时，堆栈变量会自动被释放，那么在不使用类似于free系统调用的东西的情况下，如何才能对指针(如上面引用的文本所暗示的)进行同样的分配？这有可能吗？
浏览 10提问于2015-10-18得票数 0
回答已采纳
我目前正在读CSAPP，我偶然发现了这个数字，但有些事情我就是搞不懂。
在第1行中，堆栈指针减少16，两个8字节数字分别存储在相对于堆栈指针的堆栈0和8字节中，但在第7行中，swap_add的返回地址被推到堆栈上，因此堆栈现在应该如下所示：
我的问题是:为什么在第8行和第9行，堆栈指针仍然能够从偏移量0和8中检索正确的值？据我所知，堆栈指针现在指向返回地址，因此为了返回值，应该是(%rsp)、%rsi和16(%rsp)、%rdx，还是不将返回地址推送到堆栈上？请给我解释一下为什么会这样，谢谢
浏览 5提问于2021-08-03得票数 1
回答已采纳
1回答
堆栈指针和基指针
、、
嗨，我想问一下在程序执行期间EBP和ESP寄存器是如何初始化和更新的。
下面有一张图片，作者解释说，当进入一个新函数时，首先将参数推到黄色区域所示的堆栈上，然后更新基指针EBP并存储前一个函数的基指针，然后堆栈为局部变量和返回地址分配更多的资源。
我想知道，在进入新函数时简单地更新基指针，然后为前一个函数的基指针寄存器地址分配内存，然后再分配参数、局部变量和返回值，不是更容易吗？而不是将EBP放在函数的栈帧中间。
我的另一个问题是，返回地址值在前一个函数中到底指向哪里，是在前一个函数的结尾，还是在前一个函数的开始处？
我的另一个问题是，如果你已经存储了前一个函数的返回地址，那么存储前一个函数的
浏览 3提问于2021-07-06得票数 0
1回答
堆栈溢出进入操作码推送(ASM)
、、、、
我试图通过来理解asm和堆栈溢出。正如我所理解的，常规堆栈溢出将堆栈边界之外的推入内存中。我的问题是，如果堆栈溢出超出了内存边界，会发生什么情况。
在模拟器中，如果您有一个具有以下代码的程序：
PUSH 53 ; 53 or 0x35 is opcode for PUSH
JMP 0 ; loop it
该程序覆盖自身，将堆栈推到RAM之外，堆栈指针指向-1。在一个真实的场景中，真正的程序会发生什么？
浏览 2提问于2016-07-20得票数 1
1回答
有多少不同的东西被称为“堆栈”，它们之间有什么关系？如果有人说“堆栈”，我能合理地假设他们指的是其中之一吗?或者我只能从上下文中找出答案？
但首先，我想概述一下我在这一点上的理解。
编程中似乎有很多模糊相关的东西，它们都被称为“堆栈”、“堆栈”，或者类似的东西。除了数据结构之外，我甚至不确定这个词是指同一事物还是不同的事物。
基于，看起来“堆栈”甚至不是堆栈数据结构。当你只把东西放在上面的时候，你可以访问堆栈中的任何元素，而不必弹出它之前的所有元素。除非我完全误解了数据结构。在我阅读这篇文章之前，使用堆栈作为变量的数据结构的想法似乎是一个非常糟糕的决定。
还有“堆栈”、调用堆栈和硬件堆栈的问题
浏览 4提问于2016-03-13得票数 2
回答已采纳
8回答
更正：
我混淆了指针地址的概念和指针指向的地址，因此修改了下面的代码。现在它打印出我想要的，变量a，c，i，j，k，p在堆栈上，变量b，d在堆上。静态变量和全局变量位于另一个部分。非常感谢你们所有人！
好吧，我知道这两个概念是深深的discussed...but --我仍然对以下代码有疑问：
#include <iostream>
using namespace std;
class A {
};
int N = 10;
void f(int p) {
int j = 1;
float k = 2.0;
A c;
A* d = new A(
浏览 7提问于2010-08-19得票数 8
回答已采纳
void func()
{
int arr[5]={1,2,3,4,5};
int variable = arr[1]; //variable will be set to 2
}
在执行此程序时，将在虚拟地址空间的堆栈区域分配相当于5个整数的连续内存，如下所示，用于5个整数数组。
+---+
| | a[0]
+---+
| | a[1]
+---+
| | a[2]
+---+
| | a[3]
+---+
| | a[4]
+---+
在虚拟地址空间(代码/数据/堆栈/堆段)中
浏览 0提问于2018-01-21得票数 0
2回答
我正在读一本非常流行的斯坦福文件*关于C中的链接列表，其中有一个简单的函数，它用三个成员构建一个简单的LL。我唯一不明白和困惑的是，它说它将head指针存储在一个“局部级堆栈变量”中。但是head指针是在堆中分配的！请看一看代码，并帮助我理解为什么它是一个局部级堆栈变量？
/*
Build the list {1, 2, 3} in the heap and store
its head pointer in a local stack variable.
Returns the head pointer to the caller.
*/
struct node* BuildOneTw
浏览 10提问于2017-01-30得票数 1
回答已采纳
4回答
程序栈的增长方向究竟是什么？
、、、、
我正在阅读理查德·布鲁姆( Richard )的专业汇编语言( Professional Assembly )，我对书中的不一致感到困惑，我想知道程序堆栈的增长方向究竟是什么？这是312页的图片，它表明程序堆栈正在成长。
但是当我到达322页时，我看到了另一个版本，它表明程序堆栈向下扩展。
还有这个
浏览 2提问于2013-12-08得票数 2
回答已采纳
例如，对于8位CPU，堆栈大小预期为8位宽，16位CPU与16位堆栈宽度，以及32位、64位CPU等等。所有的架构都是这样吗？
浏览 1提问于2009-08-21得票数 4
3回答
下面的两个函数之间有什么不同吗?不是在两种情况下都返回局部变量的地址，而是使用f1() fn返回正确的值4，而不是f2()。同样，在第三种情况下，字符串常量没有存储在堆栈中，所以当我们返回指针时，它会工作得很好。那么字符串常量存储在哪里呢？
int* f1()
{
int* a=(int*)4;
return a;
}
int* f2()
{
int a=4;
return &a;
}
char* f3()
{
char* p="abcd";
return p;
}
浏览 0提问于2012-05-07得票数 0
回答已采纳
4回答
此程序访问堆栈下面的内存。
当超出堆栈界限时，我会假设得到一个分段错误或者仅仅是nul，但是我看到了实际的数据。(这是假设堆栈指针下面的100 is超出堆栈边界)
还是系统实际上让我看到堆栈下面的内存？不是应该有内核级的保护来防止这种情况，还是只适用于已分配的内存？
编辑:在char指针下面带有1024*127的随机分段错误或运行，因此堆栈似乎不是固定的8MB，而且似乎也有一些随机。
#include <stdio.h>
int main(){
char * x;
int a;
for( x = (char *)&x-1024*127; x<(char
浏览 6提问于2014-03-15得票数 4
回答已采纳
2回答
我有一个指向某些已分配内存的唯一指针，我可以通过这个指针在代码中获得堆栈跟踪吗？
我知道如何从一个方法获取堆栈跟踪，但是如果我在另一个方法中捕获到异常怎么办-我可以获得堆栈跟踪吗？
浏览 0提问于2020-06-07得票数 0
1回答
我试着做这样的事
#include <iostream>
using namespace std;
void foo () {
void (*fooptr) (void) = foo;
cout << fooptr << endl;
}
int main () {
void (*fooptr) (void) = foo;
foo ();
return 0;
}
我的目的是看到函数指针的值。如果我在main ()函数中查找任何函数的地址，就会发现函数没有被调用，它可能没有被分配到函数调用堆栈中的内存。但是当我调用函数并尝试查看指针的值
浏览 0提问于2014-04-17得票数 2
回答已采纳
3回答
你好，堆栈溢出社区，我在C++中学习指针。我在golang和python方面有一点背景，但没有C或C++背景，所以请原谅我的理解有缺陷。让我张贴一段代码，这是工作良好，并给予分段错误。
1
这个打印5
int var = 5;
int *p = &var;
cout << *p << endl;
2
这张也印了5
int *p;
p = &var;
cout << *p << endl;
打印5 (因为p是int的指针，var的地址是int的指针)。)。
然而，
3.
这一段错了。
int *p
浏览 2提问于2018-05-27得票数 0
回答已采纳
我定义了一个指向char数组的全局指针(我相信在堆栈上？)作为：
char *history[BUFFER_SIZE];
在一个方法中，我只想：
strncpy(history[0], str, length);
它会堵塞断层。这对我来说毫无意义，因为：
history[0] = "a string"
不会有错的。
我的问题：
因为我是像这样定义char数组的数组，所以我不应该做任何类型的malloc或初始化，对吗？
为什么会有断层？
浏览 3提问于2017-10-27得票数 0
回答已采纳
3回答
现在，我正在尝试学习x86系统上的汇编语言。因此，我正在准备“从头编程”一书。(免费提供)
在第53页中，解释了计算机堆栈的工作方式：
这台计算机的堆栈位于内存的最上层地址。您可以通过一个名为pushl的指令将值推到堆栈的顶部。..。嗯，我们说它是顶部，但是堆栈的“顶部”实际上是堆栈内存的底部。..。在内存中，堆栈从内存的顶部开始，由于体系结构的考虑而向下增长。因此，当我们提到“堆栈的顶部”时，请记住它位于堆栈内存的底部。
那部分我明白了。假设堆栈的内存从地址0开始，以地址11结束(包括在内)。这意味着当前堆栈上有三个单词(每块4个字节)。根据我的理解，堆栈“顶部”上的单词目前占据地址
浏览 5提问于2013-10-26得票数 1
回答已采纳
4回答
所以我在某个地方读到过，如果我们有一个指针p，一些值i和j一个接一个地定义，那么堆栈上的值将是一个接一个，但是对我来说至少不是这样。
int i = 10;
int j = 20;
int *p = &i;
p++;
(*p) = 30;
std::cout << i << " " << j << " " << (*p) << "\n" ;
相反，它将打印这些值，如果我在10 20 30中注释了(*p) = 30;，那么*p内部将是一个空地址。
我认为在这种情况下，+
浏览 0提问于2019-06-04得票数 5
回答已采纳
2回答
我正在写下面的代码，它将能够改变函数调用的堆栈。但它总是在printf上遇到segfault。我用汇编语言调试了代码，堆栈切换成功。是printf语句创建了segfault，但不确定原因。有没有人知道我应该往哪个方向看？
谢谢。
char stack[4000000*4];
void foo(int ad) {
int i = 100;
int sum = i*i + ad;
printf("stack changed to %X\n", stack);
}
/* in this example, foo (and its decendents)
浏览 0提问于2013-07-24得票数 1
1回答
线程内存布局
、、、
我了解进程内存布局的样子(代码、数据、堆、堆栈)。
然而，我不明白一个具有多个线程的程序的内存布局到底是什么样子的。
毕竟，进程只有一个堆栈，所以我假设所有线程都以某种方式共享相同的堆栈。但这似乎并不正确，因为每个线程都有自己的堆栈，而线程并不保证按照它们被调用的顺序执行，因此将它们逐个放到进程堆栈上对我来说意义不大。
我在网上看到了这张图片：
在这里，看起来每个线程都有自己的堆栈，这是有意义的，也有自己的内核堆栈。
这是否意味着我有(使用图片)3个“进程”？(假设一个进程的地址空间是4 4GB，那么3个线程就是12 4GB？我不这么认为。。)
我想了解每个线程的堆栈在内存中的位置。
我知道
浏览 0提问于2015-12-09得票数 7
现在我正在读罗伯特·洛夫的书“LinuxKernelDevelopment3D版”。在这里，他介绍了thread_info结构，它包含指向task_struct结构的指针，据我所知，它位于进程内核堆栈的底部或顶部(取决于体系结构)。直到最近，我才熟悉Linux内核API，也不知道当前()方法的存在。书中有一段摘录，内容涉及当前()方法的实际工作方式：
在x86上，电流是通过屏蔽堆栈指针中最不重要的13位来获得的，thread_info structure.This是由current_thread_info() function.The程序集完成的: movl $- 8192，%eax和l %
浏览 3提问于2012-08-14得票数 5
回答已采纳
我在一家使用自定义DSL的公司工作，我的工作是将VM移植到C++。
我试图按照C++11标准来实现这一点，所以我在适当的时候使用auto，新的语法等等。但是我在试图“移植”代码中使用原始指针到新的智能指针的一部分时遇到了问题。
在这个DSL中，每个对象都是从一个名为MObject的基类派生出来的，例如，数字由这个类处理：
class MNumber : public MObject {
...
}
负责处理VM内存的类如下所示：
class Mallocator {
...
std::vector<MObject*> memory; //where all objects go..
浏览 0提问于2014-11-29得票数 2
回答已采纳
1回答
C语言中的函数顶层栈实现
、、、
为了学习目的，我在C中实现了一个通用堆栈。这是它的pop功能：
void* StackPop(Stack *s) {
assert(s != NULL);
assert(s->logicalLen > 0); // there must be at least on element
void *object = (char*) s->elems + (s->logicalLen--) * s->elemSize; // decrement logical length
浏览 2提问于2016-07-11得票数 0
回答已采纳
新手来了。我正在从我的个人OpenStack环境中进行一些测试，我成功地部署了一个包含2个实例的基本堆栈。
openstack stack create --template heat_vnf.yaml StackTest
现在，由于我必须在我的办公环境中执行此操作，所以我只尝试重新部署一个实例。所以，删除一个实例，然后重新部署它，而不触及另一个实例。我知道这是可能的，因为我的同事已经这么做了，不幸的是他离开了公司，所以我不能问他过去是怎么做到的。
有人能建议我如何在不破坏整个堆栈的情况下从堆栈重新部署一个实例并从头开始吗？
我试图删除一个实例，然后：
openstack stack upda
浏览 6提问于2022-09-16得票数 0
回答已采纳
堆栈是遵循LIFO规则的数据结构。在汇编语言中，当我们调用一个函数时，我们需要使用" push“指令将参数推到堆栈上。但是为什么我们需要堆栈清理代码来删除参数呢？大多数堆栈清理代码看起来像
add esp N
如何从堆栈中删除参数？
浏览 2提问于2015-08-30得票数 1
回答已采纳
我是C++的新手。我在我的PC上测试了一个唯一的指针:我以为它会被分配到堆上，但它显示在堆栈上。这把我搞糊涂了。唯一指针是否在堆或堆栈上分配内存？
#include <memory>
#include <stdio.h>
void RawPointer()
{
int *raw = new int;// create a raw pointer on the heap
printf("raw address: %p\n", raw);
*raw = 1; // assign
浏览 0提问于2020-05-16得票数 2
1回答
因此，我目前正在学习C，并尝试实现自己的基于数组的堆栈。下面是代码：
#include <stdio.h>
#include <stdbool.h>
#define MAX_STACK_SIZE 255
typedef struct
{
int array[MAX_STACK_SIZE];
unsigned int count;
unsigned int max;
} Stack;
void initialize(Stack*);
void push(Stack*, int value);
int* pop(Stack*);
bool is
浏览 3提问于2014-09-10得票数 1
回答已采纳
3回答
在调用堆栈上，我们有一个帧指针，它给出了指向过程的参数的位置和指向前一个帧的指针的地址。我们还有回信地址。为什么要寄回地址？我们能不能不只是跟着帧指针回到堆栈，在我们走的时候从堆栈帧中弹出？返回地址只是一个优化吗？
浏览 0提问于2016-05-29得票数 2
回答已采纳
11回答
有人知道一种“技术”来发现智能指针造成的内存泄漏吗？目前，我正在编写一个用C++编写的大型项目，该项目大量使用带有引用计数的智能指针。显然，我们有一些由智能指针引起的内存泄漏，这些指针仍然在代码中的某个地方引用，这样它们的内存就不会被释放。很难找到带有“不必要”引用的代码行，这会导致相应的对象不被释放(尽管它不再使用了)。
我在网上找到了一些建议，建议收集引用计数器的增量/递减操作的呼叫堆栈。这给了我一个很好的提示，是哪段代码导致了引用计数器的增加或减少。
但我需要的是一种算法，将相应的“增减调用堆栈”组合在一起。在删除这些对调用堆栈之后，我希望(至少)还剩下一个“增加调用堆栈”，这将显示带有
浏览 11提问于2008-09-15得票数 19
回答已采纳
2回答
我试图完全理解函数调用的堆栈增长机制，我感到有点困惑。为了更好地理解，我编写了以下简单的程序：
#include <stdio.h>
#include <stdint.h>
void callee(uint32_t* p)
{
uint32_t tmp = 9;
printf("callee - tmp is located at address location:%p and p is:%p \n", &tmp, p);
}
void caller()
{
uint32_t tmp1 = 12;
printf
浏览 1提问于2018-10-28得票数 3
回答已采纳
3回答
假设我想编写一个函数，它以数组为参数，并返回指向该数组的指针。我可以这样写；
int *foo(int var[])
{
return var;
}
现在假设我在代码的其他地方调用这个函数；
int a[] = {1, 2, 3};
int *pa = foo(a);
调用函数foo时，在堆栈上创建一个int上的新指针，该指针就是foo中的名称"var“所引用的指针。我的问题是:在哪个块中创建了指针？
如果它是foo块的一部分，那么当函数退出时它将被释放，因此pa将指向一个未分配的内存地址。但是，这段代码编译时没有警告，而下面的代码是这样做的；
int *foo(int var
浏览 1提问于2021-05-06得票数 0
回答已采纳
2回答
在堆栈上分配std::string (自动存储持续时间)，并将其分配给指针。则指针将被设置为null。
std::string* myString = &std::string("");
myString = nullptr;
是否在第二条指令后立即释放myString，或者仅在对象被销毁后作为成员的函数返回后才释放。
浏览 22提问于2016-09-18得票数 0
3回答
在下面的代码中，我尝试在二叉树中打印从根到叶的所有路径。如果我按以下方式编写递归函数：
void printPath(BinaryTreeNode * n, int path[],int pathlen)
{
//assume base case and initializations taken care of
path[pathlen++] = n->data;
printPath(root->left,path,pathlen);
printPath(root->right,path,pathle
浏览 1提问于2014-06-06得票数 4
回答已采纳
4回答
我有下面这段代码
Stack& Stack:: operator=(const Stack& stack){
if(this == &stack){
return *this
}
}
在这里我定义了运算符=，但我不能理解，如果我通过引用堆栈接收，为什么它在this == &stack中应该是&而不是this == stack，以及为什么我们在return *this中返回*而不是this，提前感谢您的帮助
浏览 3提问于2010-05-28得票数 4
回答已采纳
5回答
谁负责C++中的堆栈和堆？
、、、、
这不是一个他们的目的是什么的问题。相反，这是一个谁或什么对堆栈和堆的发明负责的问题？
这些是C++编译器的发明吗？
操作系统是否在RAM中指定了“堆栈”和“堆”中的内存部分？
我很肯定它们不是内置在硬件中的，但我可能错了。
此外，编译器是否负责生成程序集代码，指定哪些本地或函数数据将存储在堆栈和CPU寄存器上？
浏览 0提问于2015-12-31得票数 11
回答已采纳
我正在做一个编程练习，尝试用不同的方式做同样的事情。(我碰巧在第四节把两个元素向量相加在一起)。在我的一个修订版中，我使用返回堆栈存储临时值(因此我使用该特性)，除此之外，我还考虑使用未分配的内存作为临时存储。
我创建了两个单词来访问这个内存：
: front! here + ! ;
: front@ here + @ ;
我在我的实验中尝试了它，它似乎对我正在做的事情起了作用。在我的例程完成后，我不打算使用这个内存。我生活在字典里，其中的记忆已经被赋予了程序。
但是，我的直觉仍然告诉我，这是一件坏事。这是件坏事吗？
如果有关系，我使用的是。
浏览 4提问于2014-12-03得票数 3
回答已采纳
2回答
背景:我正在使用getcontext(3) / makecontext(3) / setcontext(3) (ucontext.h；SUSv2，POSIX.1-2001)系列函数分配自己的机器上下文和堆栈。
当我使用gdb (Version6.1.1)检查一个堆栈时，当线程处于我分配的这些上下文中之一时，gdb似乎不知道堆栈的结尾(逻辑底部)在哪里。例如，下面是x86 FreeBSD的一个堆栈：
#0 0x2872d79f in poll () from /lib/libc.so.7
#1 0x28646e23 in poll () from /lib/libthr.so.3
#2 0
浏览 4提问于2012-04-05得票数 6
回答已采纳
2回答
一段时间前(2-3年前)，在我的大学里，我们正在编写MC68HC11微控制器的程序，我们的讲师告诉我们，堆栈是内存的一部分，它具有以下功能：
存储中断程序的状态
在转换到子程序时存储回调地址
该堆栈也可用于程序员的需要。
我从来不知道如何才能过渡到一个子程序。实际上，我知道有PC (程序计数器)，它从当前正在执行的程序中指向当前字节，即指向到达执行程序的位置。有人能举个例子吗?堆栈什么时候会拉，什么时候会弹出一些东西(可能是JMP在代码上面，但我不认为它会起作用)。堆栈拉动和pops是否自动执行(不包括程序员的需要)？我是否需要在内存中编写两个程序，然后从另一个调用其中一个
浏览 4提问于2015-12-04得票数 0
回答已采纳
5回答
好吧，我知道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);
}
结果是：
浏览 1提问于2012-07-17得票数 1
回答已采纳
3回答
关于下面的代码片段，我有一个问题：
double d = 20.1;
double* pd = new double;
...
pd = &d;
delete pd;
最后一行在Visual C++ 2015中抛出错误。这是否意味着指针"pd“指向"d”的堆栈地址，并且它在堆中的原始指向地址(第二行等号右侧)已经泄漏？
浏览 0提问于2020-01-09得票数 0
4回答
我是C++的新手，目前正在学习堆和堆栈。在我们的课堂上，我们有这样一个有问题的函数
int* Problematic(int capacity) {
int data[capacity];
// do something
return data;
}
我知道这只会返回一个悬空的指针(是吗？)因为堆栈将在函数完成执行时释放函数中的所有内容。我的问题来了：
如果所有函数的返回类型都是指针，但它们在堆栈上运行，那么会发生这个问题吗？(因为它们只返回一个地址并在函数运行结束时删除所有东西)？除了将堆栈连接到堆(比如指向堆上的地址)之外，还有什么其他事情可以做吗?据我理解，
浏览 5提问于2022-03-06得票数 1
回答已采纳
当函数执行结束时，函数调用的堆栈框架“弹出”堆栈时，我一直试图了解函数内部的局部变量是如何被释放的。
我编写了一些代码来测试这一点：
int* func1(void){
int a = 10;
return &a;
}
int main(void){
int* h = func1();
printf("%d \n", *h);
return 0;
}
这导致了一个“分段错误. "，这是我所期望的，因为at &a现在是空闲的。
然而，我感到困惑的是，当我在func1中创建指向"a“并返回该指针的指
浏览 2提问于2021-04-15得票数 0
回答已采纳
在下面的代码片段中，我得到了gcc编译器的警告：“从不兼容的指针类型传递initArr的参数1(&堆栈，2)”和注释：“预期的'struct *‘，但是参数是'struct *’类型，这对我来说非常有意义。
然而，正如许多SO post所建议的那样，从对initArr(&stack, 2)的调用中删除符号会导致另一个警告：“‘堆栈’在此函数中被统一使用:init(堆栈，2);”以及在运行时立即出现分段错误。
我做错什么了？
我还尝试在malloc相当大的调用中使用struct，正如预期的那样，没有改变。
#include<stdio.h>
#
浏览 15提问于2016-04-08得票数 0
回答已采纳
12回答
首先，我对堆栈和堆不是很熟悉。
在很多程序中，我看到指针会被检查是否有NULL。但这并不能阻止像0x002011这样的疯狂地址被传递。
我的问题是:在取消引用指针之前，是否存在“安全”的地址间隔，我可以检查指针所属的地址间隔，并合理地确定它是有效的？
浏览 0提问于2011-07-19得票数 2
10回答
C中触发叠底流
、、
我想在C函数中触发堆栈下溢，以测试我的系统中的安全措施。我可以用内联汇编程序来完成这个任务。但C会更便携。但是，我想不出一种使用C来激发堆栈下溢的方法，因为堆栈内存在这方面是由语言安全处理的。
那么，是否有一种方法可以使用C(而不使用内联汇编程序)来激发堆栈下流？
如注释中所述:堆栈下流意味着让堆栈指针指向堆栈开头以下的地址(对于堆栈从低到高的体系结构，“下面”)。
浏览 14提问于2017-11-07得票数 26
回答已采纳
4回答
我对C语言的指针很陌生。我理解指针从内存中存储地址，而不是值。
如果我用一个值初始化一个常规变量，该值将被存储在我的内存中。然而，系统必须存储我的价值所在，对吗？那么，系统不是也有指向该变量的指针吗？
int b = 3;
如果我访问b，系统必须知道"3“的地址，对吗？还是我搞错了？
我知道变量在堆栈上，指针可以指向堆/堆栈。
浏览 2提问于2019-11-17得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
