函数在c中返回局部变量的地址

Question

Keep getting an error on my return ret before the main () class (end of process request)

buddy.c: In function `process_request':
buddy.c:89: warning: function returns address of local variable

Error I receive , what I'm trying to do is print the results I get from my process_request to my print near the end of my main() function, help?

//used a flag 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

#define F_SIZE 2
#define A_SIZE 2
#define BUDDY_SIZE 4*1024       // in bytes
            // compile using gcc-o buddy buddy.c -lm

            // block information
struct block_info
{
    char AF_flag;               // flag
    int data;                   // data in the block
};

typedef struct block_info block;

block buddy_block[BUDDY_SIZE];  // entire buddy system to be used in this array
int block_count = 0;            // number of blocks in buddy_block

int get_block_size(int num)
{
    int i = 0;

    for (i = 0; num < pow(2.0, (double)i); ++i);
    return (int)(pow(2.0, (double)i));
}

char *process_request(char *s, int len)
{
    block b;
    block n;
    int i, j, count, block_size = 0;
    int first_buddy_size = 0;
    int second_buddy_size = 0;
    char ret[BUDDY_SIZE] = { 0 };
    char *response[BUDDY_SIZE] = { 0 };

    if (!s)
        return NULL;
    first_buddy_size = buddy_block[0].data;
    second_buddy_size = buddy_block[1].data;
    block_size = get_block_size(atoi(s));
    // get the matching FREE block in the power of 2

    if (*s == 'A')
    {                           // Allocation request
        int i = 0;
        char *buff = NULL;

        // split the block
        char strf[F_SIZE] = { 0 };
        char stra[A_SIZE] = { 0 };
        strf[0] = 'F';
        stra[0] = 'A';
        for (i = 0; block_size <= first_buddy_size / 2; ++i)
        {
            first_buddy_size /= 2;
            sprintf(buff, "%d", first_buddy_size);
            response[i] = strcat(strf, buff);
        }
        sprintf(buff, "%d", block_size);
        response[i] = strcat(stra, buff);

        // update the array
        count = i;
        for (i = 0, j = count; j; --j, ++i)
        {
            char *str = response[j];

            buddy_block[i].AF_flag = *str++;
            while (*str)
                buddy_block[i].data = *str;
        }
    }

    else if (*s == 'F')
    {                           // Free request
        for (i = 1; i < block_count; ++i)
        {                       // traversing through the array
            if (buddy_block[i].data = block_size)
            {                   // b.AF_flag = 'B';
                i << 1;

            }
        }
    }
    // update array
    count = i;
    for (i = 0, j = count; j; --j, ++i)
    {
        char *str = response[j];

        buddy_block[i].AF_flag = *str++;
        while (*str)
            buddy_block[i].data = *str;
    }

    return ret;                 // ------------error: warning functions returns address
                                // of local variable----------
}

int main(int argc)
{
    block t;
    int i;
    char ch;
    char *ret = NULL;
    char line[20];

    t.AF_flag = 'X';            // some junk means memory block not even accessed
    t.data = 0;

    for (i = 0; i < BUDDY_SIZE; i++)
        buddy_block[i] = t;     // initialize with 0 bytes and no information about
                                // Allocation/Free

    // initially there is only one Free block of 4K bytes
    t.AF_flag = 'F';
    t.data = BUDDY_SIZE;
    buddy_block[0] = t;         // started the buddy block to 4096 bytes, all free to be
                                // allocated
    ++block_count;

    while (1)
    {
        // get user input
        char request[5] = { 0 };    // 'F4096' or 'A4096', max 5 chars
        int correct_input = 0;
        char ch;

        for (i = 0, ch = 'X'; ch != '\n'; ++i)
        {
            ch = getchar();
            if ((i == 0) && (ch != 'A' || ch != 'F'))
            {
                printf("Illegal token!!! : should be A or F");
                correct_input = 0;
                break;
            }
            if (ch < '0' && ch > '9')
            {                   // illegal code
                printf("Illegal token!!! : should be 0 and 9");
            }
            correct_input = 1;
            request[i] = ch;
        }
        if (correct_input)
        {
            // process user input
            ret = process_request(request, sizeof(request));
            printf("%d", ret);  // [512](512A)(128A)(128F)(256F)(1024F)(2048F)
                                // //fprintf(stderr, "I am in stderr");
            fflush(stdout);
        }
    }
    return 0;
}

Answer 1

You have allocated ret on the stack. Although it is not forbidden to return an address to that the stack will be reused by any function that is called afterwards thus overwriting whatever was at that address.

You may want to consider moving this data onto the caller's stack or into dynamic memory.

char * foo() {
    char string[] = "Hello world\n";

    return string;
}

int main () {
    printf("%s", foo());
}

Will most likely not print "Hello World!" .

One right way would be:

void foo(char * buffer) {
    memcpy(buffer, "Hello world\n", sizeof("Hello world\n"));
}

int main () {
    char buffer[100];
    foo(&buffer);
    printf("%s", buffer);
}

Or with dynamic memory (prone to memory leaks):

char * foo() {
    char * string = malloc(sizeof("Hello world\n"));
    memcpy(string, "Hello world\n", sizeof("Hello world\n"));

    return string;
}

int main () {
    char * string = foo();
    printf("%s", string);
    free(string);
}

Answer 2

It means exactly what it says. You are doing

char* process_request(char*s, int len) {
    ...
    char ret[BUDDY_SIZE] = {0};
    ...
    return ret;
}

ret is an address to a memory location. The issue is that such memory location points to a local variable. A local variable lies in the stack, and its memory may be (probably will) reused for other variables when you call new functions.

To avoid that, return a pointer to a memory location that has been dynamically allocated (that means malloc and friends).

Answer 3

You are returning a local pointer from a function and that is an undefined value.

char ret[BUDDY_SIZE] = {0};

SO, your compiler is throwing that error. Assign your pointer dynamically and the error should go away.