四种方法判断栈的生长方向 Determine the Direction of Stack Growth

最新推荐文章于 2025-01-10 21:54:54 发布

原创最新推荐文章于 2025-01-10 21:54:54 发布 · 2.5k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#C++ #CC++ #C #栈 #笔试面试

C/C++读书笔记专栏收录该内容

96 篇文章

订阅专栏

本文介绍了几种检测程序栈增长方向的方法，包括递归函数、使用函数参数与局部变量比较地址等，并探讨了如何避免编译器优化的影响。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include<cstdio>
#include<cstdlib>
#include<iostream>
using std::cout;
static void find_stack_direction(void);
static int stack_dir;
static void stack_growth_v1(void)
{
    static char *addr = NULL; /* address of first`dummy', once known */
    auto char dummy; /* to get stack address */

    if (addr == NULL)
    { /* initial entry */
        addr = &dummy;
        stack_growth_v1 (); /* recurse once */
    }
    else if (&dummy > addr)/* second entry */
        stack_dir = 1; /* stack grew upward */
    else
        stack_dir = -1; /* stack grew downward */
}
void stack_growth_v2(char *function_parameter)
{
    char local;
    if (&local > function_parameter)
        printf("up\n");
    else
        printf("down\n");
}
void stack_growth_v3(volatile char *function_parameter)
{
    volatile char local [64];
    if (&local [63] > function_parameter)
        printf("up\n");
    else
        printf("down\n");
}
void stack_growth_v4()
{
    char *m1 = (char *)malloc(2);
    char *m2 = (char *)malloc(2);
    if (m2 > m1)
        printf("down\n");
    else
        printf("up\n");
}
int main(void)
{
    cout<<"---------stack_growth_v1----\n";
    stack_growth_v1();
    if(stack_dir==1)
        puts("stack grew upward");
    else
        puts("stack grew downward");

    cout<<"---------stack_growth_v2----\n";
    char c = 'c';
    stack_growth_v2(&c);
    cout<<"---------stack_growth_3----\n";
    volatile char d[64];
    stack_growth_v3(&d[63]);
    cout<<"---------stack_growth_4----\n";
    stack_growth_v4();
    return 0;
}

/***********************
运行结果：
---------stack_growth_v1----
stack grew downward
---------stack_growth_v2----
down
---------stack_growth_3----
down
---------stack_growth_4----
down

Process returned 0 (0x0)   execution time : 0.640 s
Press any key to continue.


************************/

A simple way to determine the direction of stack growth is to compare the address of a function parameter with the address of a local variable in the function. Of course, the main difficulty here is to avoid compiler optimization, such as register variables, function inlining, and so on. So, the first attempt may look like the following function:


void stack_growth(char *function_parameter) {
    char local;
    if (&local > function_parameter)
        printf("up\n");
    else
        printf("down\n");
}

The above code can be called as follows:


char c = 'c'; stack_growth(&c);

This example can be improved by using volatile modifiers and changing scalar variables into arrays:


void stack_growth(volatile char *function_parameter) {
    volatile char local [64];
    if (&local [63] > function_parameter)
        printf("up\n");
    else
        printf("down\n");
}

and calling this function as follows:


volatile char c[64]; stack_growth(&c[63]);

It is also possible to find out the direction of stack growth by noting that it is the opposite of the heap growth direction (stack and heap usually grow towards each other), but this method is not very reliable either. For example, take the following code:


char *m1 = (char *)malloc(2);
char *m2 = (char *)malloc(2);

Whether m1 will be greater than m2 or not depends heavily on the memory allocation method.