சி மொழியில் டைனமிக் மெமரி அலகேசன்.

 

சி மொழியானது ஸ்டரக்சர் ஒரியண்டட் மொழியாதலால் அதற்கென்று தனி விதிமுறைகள் இருக்கின்றன.அவற்றில் முக்கியமான ஒன்று அர்ரேயின் சைசை மாற்றுதல்.

அர்ரே என்பது தொடர்ச்சியான மெமரி லொகேசன்களில் ஸ்டோர் ஆகும் டேட்டாக்களின் தொகுப்பாகும்.

மேலே உள்ள அர்ரேயில் அதன் சைஸ் 9 ஆகும்.இதுவே அர்ரேயின் சைஸை மாற்ற வேண்டும் என்றால்

அதாவது அர்ரேயில் 5 எலெமெண்டுகள் இருந்தால் போதும்.நான்கை நீக்க வேண்டும் இதற்கென்ன செய்யலாம் என்றால் ?

அதே போல் நமக்கு இப்பொழுது உள்ள 9 எலெமெண்டுகளுடன் கூடுதலாக  3 எலெமெண்டுகள் வேண்டும் என்றால் ?

இவ்வாறு இயக்க நேரத்தில் ஒரு அர்ரேயின் அளவை மாற்றியமைக்க பயன்படுவதே டைனமிக் மெமரி அலோகேசன் ஆகும்.

எனவா டைனமிக் மெமரி அலோகேசன் என்பது இயக்க நேரத்தில் டேட்டா ஸ்ட்ரக்சரின்(சான்றாக அர்ரே) அளவை மாற்றியமைத்தல் ஆகும்.

இதற்கு stdlib.h என்ற ஹெட்டர் ஃபைளில் உள்ள கீழ் வரும் லைப்ரரி ஃபங்க்சன்கள் பயன்ப்டுகின்றன. அவை

1.      malloc()

2.      calloc()

3.      free()

4.      realloc()

ஆகியவை ஆகும்

 

malloc()

malloc() அல்லது memory allocation என்பது குறிப்பிட்ட அளவு ஒற்றை பெரிய மெமரி பிளாக்கை ஒதுக்கீடு செய்ய பயன்படுகின்றது.இது வாய்ட் டைப் பாயிண்டரை ரிடர்ன் செய்கின்றது. இதை எந்த டேட்டா டைப்பிற்கும் டைப் கேஸ்ட் செய்யலாம்.

இது வேரியபிள் மதிப்பை தொடக்குவிப்பதில்லை. இதில் ஏதாவது கார்பேஜ் மதிப்பு சென்று அமரும்.

Syntax: 
 

ptr = (cast-type*) malloc(byte-size)

For Example:

 

சான்று:

ptr = (int*) malloc(100 * sizeof(int));

int டேட்டா டைப் 4 பைட் மெமரி எடுத்துக் கொள்ளும் ஆதலால் 400 பைட் மெமரி ஒதுக்கீடு செய்யப்படும்.ptr ஆனது முதல் பைட்டின் மெமரியை சுட்டும்.

 

மெமரி ஒதுக்கீடு செய்யும் அளவு இல்லையெனில் ptr-க்கு null மதிப்பை ரிடர்ன்  செய்யும்.

#include <stdio.h> #include <stdlib.h>   int main() {       // This pointer will hold the     // base address of the block created     int* ptr;     int n, i;       // Get the number of elements for the array     printf("Enter number of elements:");     scanf("%d",&n);     printf("Entered number of elements: %d\n", n);       // Dynamically allocate memory using malloc()     ptr = (int*)malloc(n * sizeof(int));       // Check if the memory has been successfully     // allocated by malloc or not     if (ptr == NULL) {         printf("Memory not allocated.\n");         exit(0);     }     else {           // Memory has been successfully allocated         printf("Memory successfully allocated using malloc.\n");           // Get the elements of the array         for (i = 0; i < n; ++i) {             ptr[i] = i + 1;         }           // Print the elements of the array         printf("The elements of the array are: ");         for (i = 0; i < n; ++i) {             printf("%d, ", ptr[i]);         }     }       return 0; }

Output: 

Enter number of elements: 5

Memory successfully allocated using malloc.

The elements of the array are: 1, 2, 3, 4, 5,

 

Calloc() ஃபங்க்சன்.

 Calloc() அல்லது contiguous மெமரி அலோகேசன் என்பது குறிப்பிட்ட எண்ணிக்கையில் மெமரி பிளாக்கை ரிடர்ன் செய்யும்.இது malloc உடன் இரண்டு விதங்களில் வேறுபடுகின்றது.அவை

1.      ஒவ்வொரு பிளாக்கும் 0 என்ற தொடக்க மதிப்பிருத்தப்படுகின்றது.

2.      இந்த ஃபங்க்சனுக்கு 2 பாராமீட்டர்கள் அனுப்பப்படுகின்றது.

 

3.    Syntax: 
 

ptr = (cast-type*)calloc(n, element-size);

/*here, n is the no. of elements and element-size is the size of each element*/

 

சான்று:

ptr = (float*) calloc(25, sizeof(float));

 

இந்த ஸ்டேட்மெண்ட் ஆனது 25 எண்ணிக்கையில் ஒவ்வொன்றும் 4 பைட் உள்ள அளவு மெமரி ஒதுக்கீடு செய்யப்படும்.

மெமரி பற்றவில்லையெனில் நல் பாயிண்டர் ரிடர்ன் செய்யப்படும்.

சான்று நிரல்.

#include <stdio.h> #include <stdlib.h>   int main() {       // This pointer will hold the     // base address of the block created     int* ptr;     int n, i;       // Get the number of elements for the array     n = 5;     printf("Enter number of elements: %d\n", n);       // Dynamically allocate memory using calloc()     ptr = (int*)calloc(n, sizeof(int));       // Check if the memory has been successfully     // allocated by calloc or not     if (ptr == NULL) {         printf("Memory not allocated.\n");         exit(0);     }     else {           // Memory has been successfully allocated         printf("Memory successfully allocated using calloc.\n");           // Get the elements of the array         for (i = 0; i < n; ++i) {             ptr[i] = i + 1;         }           // Print the elements of the array         printf("The elements of the array are: ");         for (i = 0; i < n; ++i) {             printf("%d, ", ptr[i]);         }     }       return 0; }

Output: 

Enter number of elements: 5

Memory successfully allocated using calloc.

The elements of the array are: 1, 2, 3, 4, 5,

 Free() ஃபங்க்சன்

இந்த ஃபங்க்சன் ஆனது டைனமிக் ஆக ஒதுக்கீடு செய்யப்பட்ட மெமரியை டி அலோக்கேட் செய்ய பயன்படுகின்றது.malloc அல்லது calloc மூலம் ஒதுக்கப்பட்ட மெமரி தானாக டிஅலோகேட் ஆகாது. Free() ஃபங்க்சனஆனது தேவையில்லாத மெமரியை டியலோகேட் செய்கின்றது.

Syntax: 
 

free(ptr);

 

 

சான்று நிரல்.

#include <stdio.h> #include <stdlib.h>   int main() {       // This pointer will hold the     // base address of the block created     int *ptr, *ptr1;     int n, i;       // Get the number of elements for the array     n = 5;     printf("Enter number of elements: %d\n", n);       // Dynamically allocate memory using malloc()     ptr = (int*)malloc(n * sizeof(int));       // Dynamically allocate memory using calloc()     ptr1 = (int*)calloc(n, sizeof(int));       // Check if the memory has been successfully     // allocated by malloc or not     if (ptr == NULL || ptr1 == NULL) {         printf("Memory not allocated.\n");         exit(0);     }     else {           // Memory has been successfully allocated         printf("Memory successfully allocated using malloc.\n");           // Free the memory         free(ptr);         printf("Malloc Memory successfully freed.\n");           // Memory has been successfully allocated         printf("\nMemory successfully allocated using calloc.\n");           // Free the memory         free(ptr1);         printf("Calloc Memory successfully freed.\n");     }       return 0; }

Output: 

Enter number of elements: 5

Memory successfully allocated using malloc.

Malloc Memory successfully freed.

 

Memory successfully allocated using calloc.

Calloc Memory successfully freed.

realloc() ஃபங்க்சன்.

இது டைனமிக் ஆக அலோகேட் செய்யப்பட்ட மெமரியின் அளவை மாற்றியமைக்க பயன்படுகின்றது.ஏற்கனவே உள்ள மெமரி அளவை கூட்டலாம் அல்லது குறைக்கலாம்.இரண்டுக்குமே realloc() ஃபங்க்சன் பயன்படுகின்றது.ஏற்கனவே ஸ்டோர் செய்யப்பட்ட மதிப்புகள் அப்படியே இருக்கும் புதிதாய் ஒதுக்கீடு செய்யப்பட்ட மெமரிகள் ஏதாவது ஒரு கார்பேஜ் மதிப்பைக் கொண்டிருக்கும்.

Syntax: 
 

ptr = realloc(ptr, newSize);

 

where ptr is reallocated with new size 'newSize'.

சான்று நிரல்.

 

 

 

 

 

int main()

{

 

    // This pointer will hold the

    // base address of the block created

    int* ptr;

    int n, i;

 

    // Get the number of elements for the array

    n = 5;

    printf("Enter number of elements: %d\n", n);

 

    // Dynamically allocate memory using calloc()

    ptr = (int*)calloc(n, sizeof(int));

 

    // Check if the memory has been successfully

    // allocated by malloc or not

    if (ptr == NULL) {

        printf("Memory not allocated.\n");

        exit(0);

    }

    else {

 

        // Memory has been successfully allocated

        printf("Memory successfully allocated using calloc.\n");

 

        // Get the elements of the array

        for (i = 0; i < n; ++i) {

            ptr[i] = i + 1;

        }

 

        // Print the elements of the array

        printf("The elements of the array are: ");

        for (i = 0; i < n; ++i) {

            printf("%d, ", ptr[i]);

        }

 

        // Get the new size for the array

        n = 10;

        printf("\n\nEnter the new size of the array: %d\n", n);

 

        // Dynamically re-allocate memory using realloc()

        ptr = realloc(ptr, n * sizeof(int));

 

        // Memory has been successfully allocated

        printf("Memory successfully re-allocated using realloc.\n");

 

        // Get the new elements of the array

        for (i = 5; i < n; ++i) {

            ptr[i] = i + 1;

        }

 

        // Print the elements of the array

        printf("The elements of the array are: ");

        for (i = 0; i < n; ++i) {

            printf("%d, ", ptr[i]);

        }

 

        free(ptr);

    }

 

    return 0;

}

Output: 

Enter number of elements: 5

Memory successfully allocated using calloc.

The elements of the array are: 1, 2, 3, 4, 5,

 

Enter the new size of the array: 10

Memory successfully re-allocated using realloc.

The elements of the array are: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

மற்றும் ஒரு சான்று  நிரல்.

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int index = 0, i = 0, n,

        *marks; // this marks pointer hold the base address

                // of  the block created

    int ans;

    marks = (int*)malloc(sizeof(

        int)); // dynamically allocate memory using malloc

    // check if the memory is successfully allocated by

    // malloc or not?

    if (marks == NULL) {

        printf("memory cannot be allocated");

    }

    else {

        // memory has successfully allocated

        printf("Memory has been successfully allocated by "

               "using malloc\n");

        printf("\n marks = %pc\n",

               marks); // print the base or beginning

                       // address of allocated memory

        do {

            printf("\n Enter Marks\n");

            scanf("%d", &marks[index]); // Get the marks

            printf("would you like to add more(1/0): ");

            scanf("%d", &ans);

 

            if (ans == 1) {

                index++;

                marks = (int*)realloc(

                    marks,

                    (index + 1)

                        * sizeof(

                            int)); // Dynamically reallocate

                                   // memory by using realloc

                // check if the memory is successfully

                // allocated by realloc or not?

                if (marks == NULL) {

                    printf("memory cannot be allocated");

                }

                else {

                    printf("Memory has been successfully "

                           "reallocated using realloc:\n");

                    printf(

                        "\n base address of marks are:%pc",

                        marks); ////print the base or

                                ///beginning address of

                                ///allocated memory

                }

            }

        } while (ans == 1);

        // print the marks of the students

        for (i = 0; i <= index; i++) {

            printf("marks of students %d are: %d\n ", i,

                   marks[i]);

        }

        free(marks);

    }

    return 0;

}

வெளியீடு:

நன்றி.

முத்து கார்த்திகேயன்,மதுரை.

 To learn c,c++ in direct or online class

contact

Muthu karthikeyan

91 96293 29142