Какво прави следният ред код с malloc?

Първо, кастингът при използване на malloc в C не е необходим. (вижте тук)

Вие извършвате malloc-ing, защото разпределяте памет на стек с размер на структура на възел. Виждате, че в C трябва да имате предвид къде се съхраняват всички променливи. А именно stack и heap (вижте тук)

Вътре във функция вашите променливи се наричат ​​локални променливи, които се съхраняват в stack. След като напуснете функцията, променливите в стека се изчистват.

За да можете да препращате или използвате локални променливи извън функцията, трябва да разпределите памет в heap, което правите тук. Вие разпределяте памет в купчината, така че да можете да използвате повторно същата променлива и в други функции.

В обобщение:

• Променливите във функция са локални за функцията, оттук и терминът локална променлива
• За други функции за достъп до локалната променлива, трябва да разпределите памет в купчината, за да споделите тази променлива с други функции.

За да ви дадем пример защо, разгледайте следния код:

#include <stdio.h>
#include <string.h>

char *some_string_func()
{
    char some_str[13]; /* 12 chars (for "Hello World!") + 1 null '\0' char */

    strcpy(some_str, "Hello World!");

    return some_str;
}

int main()
{
    printf("%s\n", some_string_func());
    return 0;
}

Това е доста просто, main просто извиква функция some_str_func, която връща локална променлива some_str, компилирането на горния код ще работи, но не и без предупреждения:

test.c: In function ‘some_string_func’:
test.c:11:9: warning: function returns address of local variable [enabled by default]

Въпреки че компилира имайте предвид, че some_str в some_str_func() връща локална променлива към функцията (т.е. в стека на функцията). Тъй като стекът се изчиства, след като напуснете функцията some_str_func(), в main() не е възможно да получите съдържанието на some_str, което е „Hello World“.

Ако се опитате да го стартирате, получавате:

$ gcc test.c
$ ./a.out

$

Не отпечатва нищо, защото няма достъп до some_str. За да го коригирате, вместо това отделяте малко място в паметта за низа "Hello World". така:

#include <stdio.h>
#include <string.h>

char *some_string_func()
{
    char *some_str;

    /* allocate 12 chars (for "Hello World!") + 1 null '\0' char */
    some_str = calloc(13, sizeof(char));

    strcpy(some_str, "Hello World!");

    return some_str;
}

int main()
{
    char *str = some_string_func();
    printf("%s\n", str);

    free(str);  /* remember to free the allocated memory */
    return 0;
}

Сега, когато го компилирате и стартирате, получавате:

$ gcc test.c
$ ./a.out
Hello World!
$

Ако ви е трудно да разберете C, знам, че много хора намират „Езикът за програмиране C“ от Brian W. Kernighan и Dennis Ritchie за наистина добра справка, но по-модерна и графична (дори забавна за четене! сериозно) книга е Head First C От Дейвид и Доун Грифитс, те обясняват много важни C концепции като Heap и Stack, разлика между динамични и статични C библиотеки, защо използването на Makefiles е добра идея, как работи Make и много други концепции, които не са обяснени преди в общи книги за C, определено си струва да се разгледат.

Друг добър онлайн ресурс е Zed Shaws Научете C по трудния начин, в които той предоставя добри примери за код и бележки.

Прочетете: void *malloc(size_t size);

Функцията malloc() разпределя size байта и връща указател към разпределената памет. Паметта не е инициализирана. Ако размерът е 0, тогава malloc() връща или NULL, или уникална стойност на указател, която по-късно може да бъде успешно предадена на free().

Съответно в

struct node* node = (struct node*)malloc(sizeof(struct node));
  //                                     ^----size---------^

вие разпределяте част от паметта от size = sizeof naode байта и връщане на адрес от malloc, съхранен в nodepointer.

Забележка Имате грешка името на променливата не трябва да бъде node, тъй като е име на структура. Можеш! но не е добра практика. Освен това sizeof(*pointer) се предпочита пред sizeof(Type) в случай, че типът някога бъде променен

Странична бележка: Безопасно е да избягвате да не прехвърляте адрес за връщане чрез функции malloc и calloc. прочетете: Да прехвърлям ли резултата от malloc?

Така че правилната предпочитана форма на горното твърдение е:

struct node* nd = malloc(sizeof *nd);
  //                     ^----size-^

Две поправки: (1) Премахване на typecast и (2) промяна на името на променливата на nd.

Използване на sizeof-

sizeof(T) ще каже броя на байтовете, необходими за съхраняване на променлива от тип T

Използване на malloc-

Malloc разпределя паметта динамично, тоест по време на изпълнение (когато вашата програма действително се изпълнява от CPU и е в паметта). Използваме това най-вече когато не сме сигурни за количеството памет, което се изисква по време на изпълнение. Така че ние динамично го разпределяме по време на изпълнение, използвайки malloc.

Използване на (struct node*)-

Malloc връща указател към блок памет с количеството пространство, което сте поискали (в неговите параметри). Това пространство е просто място в паметта. Следователно този указател няма тип, свързан с него. Прехвърляме този указател към (struct node*), защото той ще уведоми машината, че променливите от тип (struct node) ще бъдат записани в тази памет.

void* malloc (size_t size);

Разпределяне на блок памет

Заделя блок с размер байтове памет, връщайки указател към началото на блока. Съдържанието на новоразпределения блок памет не се инициализира и остава с неопределени стойности. Ако размерът е нула, върнатата стойност зависи от конкретната реализация на библиотеката (може или не може да бъде нулев указател), но върнатият указател не трябва да се дереферира.

И не предавайте резултата от malloc.

Трябва също да освободите тази памет:

void free (void* ptr);

Освободете блок памет

Блок памет, предварително разпределен чрез извикване на malloc, calloc или realloc, се освобождава, което го прави отново достъпен за по-нататъшно разпределение.

използвате malloc, за да позволите на указателите да имат към какво да сочат.

указателят е точно като уличен адрес и сградата, която стои на адреса, е построена от malloc -- или поне размера, необходим за изграждане на сградата -- какво ще построите там зависи от вас.

във вашия пример всеки възел в дървото е брой байтове, разпределени с malloc, размерът на възела е броят байтове, необходими за задържане на цялото съдържание на възела.

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

struct node* node = (struct node*)malloc(sizeof(struct node)); 

отделя достатъчно място за съхранение на node структура