Simple с таНос

Question

это не работает:

void function(char* var) 
{ 
    var = (char*) malloc (100); 
} 

int main() 
{ 
    char* str; 
    function(str); 
    strcpy(str, "some random string"); 
    printf("%s\n", str); 

    return 0; 
} 

это делает:

void function(char* var) 
{ 
    //var = (char*) malloc (100); 
} 

int main() 
{ 
    char* str; 
    //function(str); 
    str = (char*) malloc (100); 
    strcpy(str, "some random string"); 
    printf("%s\n", str); 

    return 0; 
} 

Почему?

Answer 1

Вы должны передать адрес указателя назначить адрес, который вы хотите внутри функция, в противном случае вы просто передавая копию:

void function(char** var) 
{ 
    *var = malloc (100); 
} 

int main() 
{ 
    char* str; 
    function(&str); 
    strcpy(str, "some random string"); 
    printf("%s\n", str); 

    return 0; 
} 

Answer 2

Для этого вам необходимо использовать указатель на указатель, char **.
Когда вы передаете указатель в качестве параметра, он копируется, поэтому то, что вы получаете внутри функции, - это еще один указатель, указывающий на то же место.

Вы должны получить char ** и сделать:

my_alloc_fun(void **ptr){ 
    *ptr= malloc(size); 
} 
void *myptr; 
my_alloc_fun(&myptr); 

Таким образом, вы получите адрес указателя внутри функции, так что вы можете сделать оригинальный указатель, чтобы указать на вновь выделенной памяти.

Answer 3

При вызове function(str), вы передаете значение str - function. Это значение - некоторая неинициализированная стоимость мусора, потому что вы ничего не задали в main, но это не проблема.

Проблема заключается в том, что function имеет свой собственный указатель, var, в который он помещает это значение для мусора, чтобы можно было сказать var points to the same thing (garbage) that str points to. Однако они не являются одной и той же переменной. Это две разные переменные, и изменение var не влияет на str.

Когда вы говорите var = (char*) malloc (100);, вы где-то выделяете память, а затем указываете var, чтобы указать на нее. Теперь var указывает на другое место, кроме str. Сразу же вы возвращаетесь от этой функции, теряя var и местоположение этой памяти. Это, кстати, утечка памяти.

Когда вы вернетесь на main, str - как и когда-либо, - указывая на мусор.

Числовой пример:

char *str;  // str -> 0xfeedface (garbage) 
function(str); 

// inside 'function', an initialization like this occurs 
char *var = str; // var -> 0xfeedface (same garbage) 
var = (char*) malloc (100); // var -> 0x12341234 (alloc'd memory) 
return; 

// back in 'main' 
strcpy(str, "some random string"); // str still points to 0xfeedface! 

Чтобы сделать это правильно, вам необходимо изменить str сек значение. Это означает, что function нужен указатель на str, или Указатель на указатель.

void function(char **var) 
{ 
    *var = (char*)malloc(sizeof(char) * 100); 
} 

int main() 
{ 
    char *str; 
    function(&str); 
    strncpy(str, "some random string", 99); 
    ... 
    free(str); // important in general 
} 

Answer 4

См. Мой ответ C Programming: malloc() inside another function для объяснения того, как об этом думать.

Answer 5

Указатели как любая другая переменная; разница заключается только в том, что представляет их ценность. В то время как double имеет значение, которое представляет число с плавающей запятой двойной точности, а значение int имеет значение, которое представляет целое число со знаком, указатель имеет значение, представляющее местоположение другой переменной.

Указатели по-прежнему передаются по значению другим функциям; так что ваш пример не работает по той же причине, что эта функция не аналогичным тому не работает:

void function(int var) 
{ 
    var = 100; 
} 

int main() 
{ 
    int num; 
    function(num); 
    printf("%d\n", num); 

    return 0; 
} 

Ответ в обоих случаях одно и то же: Когда function() изменяет значение параметра var, она меняется только его локальная копия этого - это не изменение переменной в пределах main().