დინამიური მეხსიერების განაწილება პროგრამირების ენაში C - IT Academy STEP Tbilisi დინამიური მეხსიერების განაწილება პროგრამირების ენაში C - IT Academy STEP Tbilisi

თბილისი, ჯანო ბაგრატიონის 6

დინამიური მეხსიერების განაწილება პროგრამირების ენაში C

დინამიური მეხსიერების განაწილება არის ერთერთი ძირითადი და მნიშვნელოვანი კონცეფცია პროგრამირების ენაში „C“ და ასევე ერთერთი საინტერესო თემა ინტერვიუების თვალსაზრისით. Malloc, Calloc, Free და Realloc ფუნქციები “C” ენაში “STDLIB.H” სათაურით გვხვდება და ძირითადად ის ფუნქციებია, რომლებიც გამოიყენება დინამიური მეხსიერების განაწილების განხორციელების დროს.

რა არის დინამიური მეხსიერების განაწილება?

პროგრამის მუშაობის დროს მეხსიერების განაწილების პროცესს დინამიური მეხსიერების განაწილება ჰქვია. რა იგულისხმება სიტყვებში პროგრამის მსვლელობის დროს“at runtime”? საერთოდ, როცა ჩვენ ვაცხადებთ პრიმიტიულ ცვლადს, ვთქვათ “int a;”, მაშინ მეხსიერება ნაწილდება კომპილაციის დროს და ჩვენ ამას “Static memory”-ს, სტატიკური მეხსიერების განაწილებას ვეძახით. სტატიკურში იმას ვგულისხმობთ, რომ მეხსიერება, რომელიც უნდა განაწილდეს, სინამდვილეში ფიქსირებულია ზომაში.

თუ მასივზე ვსაუბრობთ, მაშინ გამოცხადებული ზომაც ფიქსირებულია, ამას კი სტატიკური მეხსიერების განაწილება აკონტროლებს. უფრო მეტიც, მომხმარებლის განსაზღვრული მონაცემთა ტიპი, მაგალითად, სტრუქტურის ზომა ასევე ფიქსირებულია, როცა ჩვენს პროგრამაში ფიქსირებულ კოდს ვწერთ.

ასეთი ტიპის გამოცხადებას თავდაპირველად ფიქსირებული ზომა აქვს, ეს ისეთი რამ არის, რაც სასურველი არ არის და ჩვენ ყოველთვის არ გვაქვს პროგრამები ფიქსირებული კოდებით. ჩვენ ისეთი რამ გვჭირდება, რაც დინამიური იქნება და მოთხოვნებს შეესაბამება, რომ მეხსიერების განაწილება აუცილებლად განხორციელდეს.

შეიძლება არსებობდეს სხვადასხვა სცენარი, როცა დამატებითი მეხსიერება გვჭირდება ან პროგრამის მეხსიერება წინასწარ დაკონკრეტებული არ არის, ამიტომ ის დინამიურად განაწილდება პროგრამის მოთხოვნის და საჭიროების შესაბამისად. მაგალითად, მასივის შემთხვევაში, შესაძლებელია ზომის გაზრდა ან შემცირება იმ ელემენტებზე დაყრდნობით, რომლებსაც ჩვენ ვინახავთ ან ვშლით.

როგორ უნდა მივაღწიოთ დინამიური მეხსიერების განაწილებას?

დინამიური განაწილების შემთხვევაში, ბიბლიოთეკის რუტინები, რომლებიც მეხსიერების მენეჯმენტის ფუნქციების სახელით არის ცნობილი, გამოიყენება მეხსიერების განაწილებისთვის და გათავისუფლებისთვის პროგრამის მუშაობის დროს. ამ ფუნქციების განმარტება მოცემულია ფაილში “stdlib.h” სათაურით. ის უზრუნველყოფს საჭირო ფუნქციებს მეხსიერების განაწილებისთვის და გათავისუფლებისთვის, რასაც მოგვიანებით განვიხილავთ ამ სტატიაში.

იმისთვის, რომ კარგად გავიგოთ დინამიური მეხსიერების განაწილება, მოდით თავდაპირველად კონცენტრაცია გავაკეთოთ იმაზე, თუ როგორ ნაწილდება მეხსიერება სხვადასხვა პარამეტრებში “C” პროგრამაში. დააკვირდით ქვემოთ მოცემულ ცხრილს.

ლოკალური ცვლადი – Stack (გროვა)

თავისუფალი მეხსიერება – Heap (უამრავი)

გლობალური ცვლადი

პროგრამის ინსტრუქციები – მუდმივად შენახვის სივრცე

სტატიკური ცვლადი

საერთოდ, გლობალური ცვლადები, სტატიკური ცვლადები და პროგრამის ინსტრუქციები ინახება მუდმივად შენახვის სივრცეში. ხოლო ლოკალური ცვლადები ინახება მეხსიერებაში, რომელსაც ჰქვია Stack (გროვა).

მეხსიერებას ლოკალურ და გლობალურ ცვლადს შორის ჰქვია Heap (უამრავი) სივრცე. ეს ძირითადად არის მონაცემების სტრუქტურა, რომელიც გამოიყენება დინამიური მეხსიერების განაწილებისთვის ჩვენი პროგრამის მუშაობის დროს. Heap-ის (უამრავი) ზომა მუდმივად იცვლება თითოეული მეხსიერების მოთხოვნის შემთხვევაში.

ფუნქციები, რომლებიც დინამიური მეხსიერების განხორციელების დროს გამოიყენება.

1 Malloc() ფუნქცია

ეს ფუნქცია გამოიყენება განაწილებულ მეხსიერებასთან „array“ (მასივთან) ან „structures“ (სტრუქტურებთან), მაგრამ მოთხოვნილი მეხსიერების ერთი ბლოკისთვის. ეს მეთოდი ძირითადად გამოიყენება მომხმარებლისთვის განსაზღვრული მონაცემთა ტიპებისთვის მეხსიერების გასანაწილებლად C ენაში. ფუნქცია იტოვებს სპეციალური ზომის მეხსიერების ბლოკს და აბრუნებს “void” ტიპის პოინტერს, რომელიც შეიძლება გადაიქცეს ნებისმიერი ფორმის პოინტერად. რას ვგულისხმობთ ამაში?

დინამიურ განაწილებაში პოინტერებს მთავარი როლი უკავიათ. ფუნქცია იღებს არგუმენტს, ანუ ზომას, თუ რამდენი ბაიტი უნდა გავანაწილოთ და შემდეგ დაბრუნების ტიპი იყოს “void-pointer”, რომელიც არის “generic type” და ჩვენი კომფორტის მიხედვით, შეგვიძლია რადაც გვინდა იმად გადავაქციოთ. ეს შეიძლება გადაიქცეს ინთეჯერად, char, double, float, struct, linked list, graph node ან ნებისმიერ სხვა რამედ.

თუ მეხსიერება ერთხელ მაინც განაწილდა სწორად, ის დააბრუნებს მეხსიერების საბაზო მისამართს, რაც აქვს ჩვენს დაბრუნებულ პოინტერებს, ხოლო არასწორად განაწილების შემთხვევაში, ის დააბრუნებს “null pointer”-ს.

SYNTAX:- void* malloc(byte-size);

 

როცა სრულდება malloc ფუნქცია, მაშინ კომპილატორიდან გამომდინარე და 16 ან 32 ბიტი OS-ის თანახმად, ის შესაბამისად ანაწილებს მეხსიერებას მონაცემთა ტიპებისთვის.

პროგრამა მაგალითისთვის:

#include <stdio.h>#include <stdlib.h>#include <conio.h>void main(){    int number, i, *pointer, sum = 0;    printf(“Enter number of elements: “);    scanf(“%d”, &number); // memory allocation using the malloc function    pointer = (int*) malloc(number * sizeof(int));// here (int*) is actually typecasted from void pointer // to integer pointer since our function accept the integer type.     if(pointer == NULL)                         {        printf(“Memory not allocated.”);        exit(0);    }    printf(“Enter elements of array: “);    for(i = 0; i < number; ++i)    {        scanf(“%d”, pointer + i);        sum += *(pointer + i);    }    printf(“Sum = %d”, sum);    free(pointer);    getch();}

 

2 Calloac() ფუნქცია

ეს მეთოდიც მეხსიერების განაწილებისთვის გამოიყენება მასივებთან და სტრუქტურებთან. Malloc-ის მსგავსად თუ ის კონკრეტულად მითითებულთან შედარებით, არასაკმარის სივრცეს გაანაწილებს, null pointer-ს დააბრუნებს. უდიდესი განსხვავება malloc() და calloac()-ს შორის არის ის, რომ ის ამუშავებს მრავალჯერად მოთხოვნებს მეხსიერების გასანაწილებლად.

SYNTAX:-  (void*) calloc(number_of_items, element_size);

 

ფუნქცია იღებს ორ არგუმენტს, ერთი არის მასივის ან ვთქვათ მონაცემთა ტიპის ზომა და მეორე არის თითოეული ელემენტის ზომა, დაბრუნების ტიპი კვლავ void pointer-ია, რომელიც არის generic type-ი. თუ საკმარისი მეხსიერება ხელმისაწვდომია, მაშინ calloac ფუნქცია ანაწილებს “number of items” “size of elements” ზომის მეხსიერების ბლოკს და აბრუნებს void pointer-ში შენახულ საბაზო მისამართს.

პროგრამა მაგალითისთვის:

#include <stdio.h>#include <stdlib.h>#include <conio.h>void main(){    int number, i, *ptr, sum = 0;    printf(“Enter number of elements: “);    scanf(“%d”, &number);// implementing the calloc function    ptr = (int*) calloc(number, sizeof(int));    if(ptr == NULL)    {        printf(“Error! memory not allocated.”);        exit(0);    }     printf(“Enter elements of array: “);    for(i = 0; i < number; ++i)    {        scanf(“%d”, ptr + i);        sum += *(ptr + i);    }     printf(“Sum = %d”, sumber);    free(ptr);    getch();}

 

შენიშვნა: თუ calloc() ფუნქციის პირველი არგუმენტი არის null, მაშინ ის malloc() ფუნქციის ექვივალენტია.

3 Realloc() ფუნქცია

ამ მეთოდის ძირითადი დევიზი არის მასივის ზომის გაზრდა ან შემცირება ან ვთქვათ მეხსიერების გადანაწილება, რომელიც განაწილებული იყო malloc() და calloc() ფუნქციების მიერ თუ ადრე განაწილებული მეხსიერება არასაკმარისია ან მოთხოვნილზე მეტია.

SYNTAX:- ptr = realloc(ptr, newsize);

 

აქ, არგუმენტებში, პირველი ჩვენ გვაქვს არსებული ბლოკის საწყისი მისამართის პოინტერი და მეორე არგუმენტი არის ახალი ბლოკის ზომა, რომელიც შეიძლება იყოს უფრო დიდი ან უფრო პატარა, იმისთვის, რომ ახალი ზომა მიუთითოთ.

პროგრამა მაგალითისთვის:

#include <stdio.h>#include <stdlib.h>#include <conio.h>void main(){    int *ptr, i , n1, n2;    printf(“Enter size of array: “);    scanf(“%d”, &n1);     ptr = (int*) malloc(n1 * sizeof(int));     printf(“Address of previously allocated memory: “);    for(i = 0; i < n1; ++i)         printf(“%u\t”,ptr + i);     printf(“\nEnter new size of array: “);    scanf(“%d”, &n2);// reallocating the memory of size n2    ptr = realloc(ptr, n2 * sizeof(int));    for(i = 0; i < n2; ++i)         printf(“%u\t”, ptr + i);    getch();}

 

4 ფუნქცია გათავისუფლება

დინამიურად განაწილებული მეხსიერება, რომელიც შექმნილია calloc() ან malloc() მეთოდების გამოყენებით, თავისით არ თავისუფლდება. ჩვენ გვჭირდება პირდაპირ გამოვიყენოთ მეთოდი free() სივრცის გასათავისუფლებლად. ამიტომ, როცა დაგვჭირდება მეხსიერების წაშლა ან გათავისუფლება, მაშინ უნდა გამოვიძახოთ ფუნქცია “free function”.

IT Academy STEP – თქვენი წარმატება იწყება აქ !

იზრუნეთ მომავალზე, შეისწავლეთ პროგრამირება, მიიღეთ ხარისხიანი ცოდნა  და უზარმაზარი გამოცდილება!

დეტალური ინფორმაციისათვის და კურსზე ჩასაწერად, გთხოვთ გაიაროთ რეგისტრაცია პროგრამული უზრუნველყოფის დეველოპერი

 

გახსოვდეთ, წარმატებული IT სპეციალისტი უპრობლემოდ პოულობს მაღალანაზღაურებად სამსახურს და ერთვება მსოფლიოს ნებისმიერი წერტილიდან

მიიღეთ საჭირო ცოდნა

შემოგვიერთდით მსოფლიო ბრენდ  IT აკადემია STEP-ში!

თბილისი,
ჯანო ბაგრატიონი #6
+995 (32) 215-55-51
+995 (32) 215-50-05

დარეკეთ ან დარეგისტრირდით ეხლავე, ჩვენი კვალიფიციური სპეციალისტები დაგიკავშირდებიან უმოკლეს დროში

რეგისტრაცია

სახელი, გვარი*
ტელეფონი*
E-mail*
სად გაეცანით ინფორმაციას ღია კარის დღის შესახებ?*


ახალი ამბები