சி மொழியானது
ஸ்டரக்சர் ஒரியண்டட் மொழியாதலால் அதற்கென்று தனி விதிமுறைகள் இருக்கின்றன.அவற்றில்
முக்கியமான ஒன்று அர்ரேயின் சைசை மாற்றுதல்.
அர்ரே என்பது
தொடர்ச்சியான மெமரி லொகேசன்களில் ஸ்டோர் ஆகும் டேட்டாக்களின் தொகுப்பாகும்.
மேலே உள்ள அர்ரேயில்
அதன் சைஸ் 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
