{HOMEWORK]Как така работи ?

itonev 22 Точки

{HOMEWORK]Как така работи ?

Здравейте :)

Пиша си аз пета задача със следния код. Очаквах да има проблем с върнатия указател към локланата променлива на функцията обаче си работи нормално независмо, че не е safe :)

/* 
 * File:   create_new_int.c
 * Author: mdv
 *Write a function that declares and initializes and integer on the stack, then returning it. Try creating the function
with two different declarations:
 * Created on October 26, 2015, 7:48 PM
 */

#include <stdio.h>

int new_integer();
int* new_integer_ptr();

int main() {
    int good_var = new_integer();
    printf("Good var is %d\n",good_var);
    int* bad_var = new_integer_ptr();
    printf("Bad var is %d\n",(*bad_var));
    return 0;
}

int new_integer() {
    int stack_var = 1000;
    return stack_var; // here I return copy of local stack var; It's safe
    // Now original stack_var is dead
} 

int* new_integer_ptr() {
    int  stack_var = 1000;
    int* stack_ptr = &stack_var;
    return stack_ptr; // Really bad ! Because now stack_var wil be dead so stack_ptr points to garbage 
    //It's NOT safe
}

Output-ът е


Good var is 1000
Bad var is 1000


RUN FINISHED; exit value 0; real time: 0ms; user: 0ms; system: 0ms

Тагове:

26/10/2015 20:17:37 C Programming

Виж всички отговори

trismagis 0 Точки

а пък според мен return stack_ptr; дереференцира пойнтера преди да го върне, т.е връща копие на съдържанието. За разлика от това:

int* new_integer_ptr() {
    int  stack_var = 1000;
    int* stack_ptr = &stack_var;
    return &stack_ptr;
}

Както и това:

int* new_integer_ptr() {
    int  stack_var = 1000;
    int* stack_ptr = &stack_var;
    return &stack_var; 
}

И в двата случая дава warning: function returns address of local variable, а в оригиналния ти код -не

26/10/2015 21:19:33

Filkolev 4482 Точки

Дереференцирането става в main функцията. Защо мислиш, че това се случва при return? Няма логика. Функцията е дефинирана да връща пойнтър и точно това прави. Предупрежденията, които посочваш, вероятно се появяват защото директно връщаш адрес и компилаторът е достатъчно умен, за да го види.

26/10/2015 21:41:06

trismagis 0 Точки

Прави сте, сори за глупостта която казах - тествах, наистина остава поинтер и ако си направиш watch на пойнтера, той става out of scope като се върне в main. Дори успях да я счупя:

#include <stdio.h>
int new_integer();
int* new_integer_ptr();


int main() {

    int good_var = new_integer();

    printf("Good var is %d\n",good_var);

    int* bad_var = new_integer_ptr();
    
    long double test[10000];      //nuke the stack
    memset(test, 0, sizeof(test));
        
    printf("Bad var is %d\n",(*bad_var));

    return 0;

}

int new_integer() {

    int stack_var = 1000;

    return stack_var; // here I return copy of local stack var; It's safe

    // Now original stack_var is dead

} 


int* new_integer_ptr() {

    int  stack_var = 1000;

    int* stack_ptr = &stack_var;

    return stack_ptr; // Really bad ! Because now stack_var wil be dead so stack_ptr points to garbage 

    //It's NOT safe

}

Нещата, мисля, са ясни

26/10/2015 22:19:09

itonev 22 Точки

О, аз съм наясно, че това няма как да работи.

В крайна сметка извъртях един цикъл с извиквания на printf и се счупи.

Всъщност @а_rusenov ми даде отговора, който търсех.

Счупване със сигурност ще се случи, когато имаме друг код изменящ стека.

Най-сетне се счупи с това:

for(int i=0;i<5;i++) {
        printf("Get Value # >>",i);
        scanf("%d", &value);
        printf("%d\n",value);
    }
    printf("Bad var is %d\n",(*bad_var));

27/10/2015 08:08:11

Виж всички отговори