Dinamiskie masīvi ir spēcīga datu struktūra programmēšanā, kas ļauj veidojot un manipulējot dažāda lieluma masīvi izpildlaikā. Programmā C dinamiskie masīvi tiek ieviesti, izmantojot norādes un atmiņas piešķiršanas funkcijas, padarot tos par vērtīgu rīku atmiņas lietojuma optimizēšanai un efektīvu programmu izveidei. Šajā rakstā mēs izpētīsim dinamisko masīvu jēdzienu C, to priekšrocības un trūkumus, kā arī to, kā ar tiem izveidot un manipulēt.

Izpratne par dinamiskajiem masīviem

A dinamiskais masīvs ir masīvs, kura lielumu laikā var mainīt izpildlaiks . Atšķirībā no statiskie masīvi , kuriem ir fiksēts izmērs, kas tiek noteikts kompilēšanas laikā, dinamisko masīvu izmērus var mainīt pēc vajadzības. Tas nodrošina lielāku elastību un labāku atmiņas pārvaldību, jo masīva lielumu var pielāgot, lai tas atbilstu glabājamo datu apjomam.

Dinamiskie masīvi tiek realizēti, izmantojot norādes un atmiņas piešķiršanas funkcijas. C valodā visbiežāk izmantotās atmiņas piešķiršanas funkcijas ir malloc () , calloc() , un realloc() . Šīs funkcijas ļauj piešķirt un atdalīt atmiņu izpildlaikā, kas ir nepieciešams dinamisko masīvu izveidošanai un manipulācijām ar tiem.

Dinamisko masīvu priekšrocības

Dinamisko masīvu izmantošanai C valodā ir vairākas priekšrocības. Dažas no galvenajām priekšrocībām ir šādas:

1. Viena no galvenajām priekšrocībām ir tā, ka tie ļauj labāk pārvaldīt atmiņu. Izmantojot statiskos masīvus, masīva lielums ir fiksēts , kas nozīmē, ka atmiņa tiek piešķirta visam masīvam uzreiz. Ja masīvs netiek pilnībā izmantots, atmiņa var tikt izniekota.
2. Izmantojot dinamiskos masīvus, atmiņa tiek piešķirta tikai pēc vajadzības, kas var nodrošināt efektīvāku atmiņas izmantošanu.
3. Dinamiskie masīvi nodrošina arī lielāku elastību.
4. Tas var būt ierobežojošs, it īpaši, ja izpildlaikā ir jāmaina masīva lielums.
5. Dinamiskie masīvi ļauj pēc vajadzības pielāgot masīva lielumu, kas var padarīt programmas daudzpusīgākas un pielāgojamākas.

Dinamisko masīvu trūkumi

Lai gan dinamiskajiem masīviem ir daudz priekšrocību, tiem ir arī daži trūkumi. Daži no galvenajiem trūkumiem ir šādi:

sdlc dzīves cikls

1. Viens no galvenajiem trūkumiem ir tas, ka to ieviešana var būt sarežģītāka nekā statiskos masīvus.
2. Dinamiskajiem masīviem ir jāizmanto norādes un atmiņas piešķiršanas funkcijas , ko var būt grūtāk saprast un izmantot nekā statisko masīvu vienkāršo masīva sintakse.
3. Dinamiskie masīvi var būt arī lēnāki nekā statiskie masīvi. Tā kā ir iesaistīta atmiņas piešķiršana un atdalīšana, dinamisko masīvu izmantošana ir saistīta ar pieskaitāmām izmaksām. Šīs pieskaitāmās izmaksas dažos gadījumos var padarīt dinamiskos masīvus lēnākus nekā statiskos masīvus.

Dinamisku masīvu izveide programmā C

Lai izveidotu dinamisku masīvu C, mums ir jāizmanto atmiņas piešķiršanas funkcijas lai piešķirtu atmiņu masīvam. Visbiežāk izmantotās atmiņas piešķiršanas funkcijas C ir malloc (), calloc () , un realloc() . Šeit ir piemērs, kā izveidot dinamisku masīvu, izmantojot malloc ():

"abc" ir skaitļos

 int *arr; int size = 10; arr = (int*) malloc(size * sizeof(int)); 

Paskaidrojums:

Šajā piemērā mēs deklarējam rādītāju uz veselu skaitļu masīvu, ko sauc arr . Mēs arī deklarējam veselu mainīgo, ko sauc Izmērs , kas apzīmē masīva lielumu, ko vēlamies izveidot. Pēc tam mēs izmantojam malloc () funkcija, lai piešķirtu atmiņu masīvam. The malloc () funkcija ņem masīva lielumu (in baiti ) kā argumentu, tāpēc mēs reizinām masīva lielumu ar vesela skaitļa lielumu (kas ir 4 baiti lielākajā daļā sistēmu), lai iegūtu kopējo izmēru baitos.

Manipulēšana ar dinamiskajiem masīviem C

Kad esam izveidojuši dinamisku masīvu C, mēs varam ar to manipulēt tāpat kā ar jebkuru citu masīvu. Mēs varam piekļūt atsevišķiem masīva elementiem, izmantojot masīva sintaksi:

 arr[0] = 5; 

Šajā piemērā mēs iestatām pirmo masīva elementu uz 5 .

Varam arī izmantot cilpas lai atkārtotu masīvu:

 for (int i = 0; i<size; i++) { arr[i]="i" * 2; } < pre> <p>In this example, we use a <strong> <em>for loop</em> </strong> to set each element of the array to twice its index.</p> <p>To resize a dynamic array in C, we can use the <strong> <em>realloc()</em> </strong> function. The <strong> <em>realloc()</em> </strong> function takes two arguments: a <strong> <em>pointer</em> </strong> to the original memory block and the <strong> <em>new size</em> </strong> of the memory block. Here is an example of how to resize a dynamic array using realloc():</p> <pre> int new_size = 20; arr = (int*) realloc(arr, new_size * sizeof(int)); </pre> <p>In this example, we declare a new integer variable called <strong> <em>new_size</em> </strong> , which represents the new size of the array. After that, we use the <strong> <em>realloc() function</em> </strong> to resize the array. The <strong> <em>realloc() function</em> </strong> takes the pointer to the original memory block (in this case, <strong> <em>arr</em> </strong> ) and the <strong> <em>new size</em> </strong> of the memory block (in <strong> <em>bytes</em> </strong> ). We multiply the <strong> <em>new size</em> </strong> of the array by the <strong> <em>size</em> </strong> of an <strong> <em>integer</em> </strong> to get the total size in bytes.</p> <p>It is important to note that when we resize a dynamic array using <strong> <em>realloc()</em> </strong> , any existing data in the array will be preserved. If the new size of the array is larger than the original size, the new elements will be uninitialized.</p> <p>To free the memory used by a dynamic array in C, we can use the <strong> <em>free()</em> </strong> function. The <strong> <em>free()</em> </strong> function takes a pointer to the memory block that was allocated using <strong> <em>malloc()</em> </strong> , <strong> <em>calloc()</em> </strong> , or <strong> <em>realloc()</em> </strong> . Here is an example of how to free the memory used by a dynamic array:</p> <pre> free(arr); </pre> <p>In this example, we use the <strong> <em>free() function</em> </strong> to free the memory used by the dynamic array <strong> <em>arr</em> </strong> . It is important to note that once we have freed the memory used by a dynamic array, we should not attempt to access the elements of the array.</p> <h3>Some more examples of using dynamic arrays in C:</h3> <p> <strong>Adding Elements to a Dynamic Array:</strong> </p> <p>One of the main benefits of using a dynamic array is the ability to add elements to the array as needed. Here is an example of how to add an element to a dynamic array:</p> <pre> #include #include int main() { int size = 5; int *arr = (int*) malloc(size * sizeof(int)); int i; for(i = 0; i<size; i++) { arr[i]="i;" } add a new element to the array size++; arr="(int*)" realloc(arr, size * sizeof(int)); arr[size-1]="i;" for(i="0;" i< size; printf('%d ', arr[i]); free(arr); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> 0 1 2 3 4 5 </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first create a dynamic array <strong> <em>arr</em> </strong> of size <strong> <em>5</em> </strong> using the <strong> <em>malloc()</em> </strong> function. After that, we set each element of the array to its index using a <strong> <em>for loop</em> </strong> . To add a new element to the array, we increment the size of the array by one and use the <strong> <em>realloc() function</em> </strong> to resize the array. We set the value of the last element in the array to the current value of <strong> <em>i</em> </strong> . Finally, we print the contents of the array and free the memory used by the array.</p> <h3>Resizing a Dynamic Array</h3> <p>Another advantage of using a dynamic array is the ability to resize the array as needed. Here is an example of how to resize a dynamic array:</p> <pre> #include #include int main() { int size = 5; int *arr = (int*) malloc(size * sizeof(int)); int i; for(i = 0; i<size; i++) { arr[i]="i;" } resize the array size="10;" arr="(int*)" realloc(arr, * sizeof(int)); for(i="5;" i< size; printf('%d ', arr[i]); free(arr); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> 0 1 2 3 4 5 6 7 8 9 </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first create a dynamic array <strong> <em>arr</em> </strong> of size <strong> <em>5</em> </strong> using the <strong> <em>malloc() function</em> </strong> . After that, we set each element of the array to its index using a <strong> <em>for loop</em> </strong> . To resize the array, we set the value of size to <strong> <em>10</em> </strong> and use the <strong> <em>realloc()</em> </strong> function to resize the array. After that, we set the value of the new elements in the array using another for loop. Finally, we print the contents of the array and free the memory used by the array.</p> <h2>Conclusion</h2> <p> <strong> <em>Dynamic arrays</em> </strong> are a powerful data structure in programming that allow for the creation and manipulation of arrays of varying sizes during runtime. In C, dynamic arrays are implemented using pointers and memory allocation functions, making them a valuable tool for optimizing memory usage and creating efficient programs.</p> <p>While <strong> <em>dynamic arrays</em> </strong> have many advantages, they also have some disadvantages. Dynamic arrays can be more complex to implement than static arrays and can be slower in some cases. However, the flexibility and efficiency of dynamic arrays make them a valuable tool for many programming tasks.</p> <p>To create and manipulate dynamic arrays in C, we must use memory allocation functions to allocate and deallocate memory during runtime. The most commonly used memory allocation functions in C are <strong> <em>malloc()</em> </strong> , <strong> <em>calloc()</em> </strong> , and <strong> <em>realloc()</em> </strong> . It is important to properly manage memory usage when working with dynamic arrays to avoid memory leaks and other memory-related issues.</p> <hr></size;></pre></size;></pre></size;>

Šajā piemērā mēs deklarējam jaunu veselu mainīgo lielumu ar nosaukumu jauns_izmērs , kas apzīmē jauno masīva izmēru. Pēc tam mēs izmantojam realloc() funkcija lai mainītu masīva lielumu. The realloc() funkcija novirza rādītāju uz sākotnējo atmiņas bloku (šajā gadījumā arr ) un jauns izmērs atmiņas bloka (in baiti ). Mēs reizinām jauns izmērs no masīva, ko Izmērs no an vesels skaitlis lai iegūtu kopējo izmēru baitos.

char uz virkni

Ir svarīgi atzīmēt, ka mainot dinamiskā masīva izmērus, izmantojot realloc() , tiks saglabāti visi masīvā esošie dati. Ja jaunais masīva izmērs ir lielāks par sākotnējo izmēru, jaunie elementi netiks inicializēti.

Lai atbrīvotu atmiņu, ko izmanto dinamiskais masīvs C, mēs varam izmantot bezmaksas () funkciju. The bezmaksas () funkcija parāda rādītāju uz atmiņas bloku, kas tika piešķirts, izmantojot malloc () , calloc() , vai realloc() . Šeit ir piemērs, kā atbrīvot dinamiskā masīva izmantoto atmiņu:

 free(arr); 

Šajā piemērā mēs izmantojam bezmaksas () funkcija lai atbrīvotu dinamiskā masīva izmantoto atmiņu arr . Ir svarīgi atzīmēt, ka pēc tam, kad esam atbrīvojuši dinamiskā masīva izmantoto atmiņu, mums nevajadzētu mēģināt piekļūt masīva elementiem.

Vēl daži dinamisko masīvu izmantošanas piemēri programmā C:

Elementu pievienošana dinamiskajam masīvam:

Viena no galvenajām dinamiskā masīva izmantošanas priekšrocībām ir iespēja masīvam pēc vajadzības pievienot elementus. Šeit ir piemērs, kā dinamiskam masīvam pievienot elementu:

 #include #include int main() { int size = 5; int *arr = (int*) malloc(size * sizeof(int)); int i; for(i = 0; i<size; i++) { arr[i]="i;" } add a new element to the array size++; arr="(int*)" realloc(arr, size * sizeof(int)); arr[size-1]="i;" for(i="0;" i< size; printf(\'%d \', arr[i]); free(arr); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> 0 1 2 3 4 5 </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first create a dynamic array <strong> <em>arr</em> </strong> of size <strong> <em>5</em> </strong> using the <strong> <em>malloc()</em> </strong> function. After that, we set each element of the array to its index using a <strong> <em>for loop</em> </strong> . To add a new element to the array, we increment the size of the array by one and use the <strong> <em>realloc() function</em> </strong> to resize the array. We set the value of the last element in the array to the current value of <strong> <em>i</em> </strong> . Finally, we print the contents of the array and free the memory used by the array.</p> <h3>Resizing a Dynamic Array</h3> <p>Another advantage of using a dynamic array is the ability to resize the array as needed. Here is an example of how to resize a dynamic array:</p> <pre> #include #include int main() { int size = 5; int *arr = (int*) malloc(size * sizeof(int)); int i; for(i = 0; i<size; i++) { arr[i]="i;" } resize the array size="10;" arr="(int*)" realloc(arr, * sizeof(int)); for(i="5;" i< size; printf(\'%d \', arr[i]); free(arr); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> 0 1 2 3 4 5 6 7 8 9 </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first create a dynamic array <strong> <em>arr</em> </strong> of size <strong> <em>5</em> </strong> using the <strong> <em>malloc() function</em> </strong> . After that, we set each element of the array to its index using a <strong> <em>for loop</em> </strong> . To resize the array, we set the value of size to <strong> <em>10</em> </strong> and use the <strong> <em>realloc()</em> </strong> function to resize the array. After that, we set the value of the new elements in the array using another for loop. Finally, we print the contents of the array and free the memory used by the array.</p> <h2>Conclusion</h2> <p> <strong> <em>Dynamic arrays</em> </strong> are a powerful data structure in programming that allow for the creation and manipulation of arrays of varying sizes during runtime. In C, dynamic arrays are implemented using pointers and memory allocation functions, making them a valuable tool for optimizing memory usage and creating efficient programs.</p> <p>While <strong> <em>dynamic arrays</em> </strong> have many advantages, they also have some disadvantages. Dynamic arrays can be more complex to implement than static arrays and can be slower in some cases. However, the flexibility and efficiency of dynamic arrays make them a valuable tool for many programming tasks.</p> <p>To create and manipulate dynamic arrays in C, we must use memory allocation functions to allocate and deallocate memory during runtime. The most commonly used memory allocation functions in C are <strong> <em>malloc()</em> </strong> , <strong> <em>calloc()</em> </strong> , and <strong> <em>realloc()</em> </strong> . It is important to properly manage memory usage when working with dynamic arrays to avoid memory leaks and other memory-related issues.</p> <hr></size;></pre></size;>

Paskaidrojums:

Šajā piemērā mēs vispirms izveidojam dinamisku masīvu arr izmēra 5 izmantojot malloc () funkciju. Pēc tam mēs iestatām katram masīva elementam tā indeksu, izmantojot a cilpai . Lai masīvam pievienotu jaunu elementu, mēs palielinām masīva lielumu par vienu un izmantojam realloc() funkcija lai mainītu masīva lielumu. Mēs iestatām masīva pēdējā elementa vērtību uz pašreizējo vērtību i . Visbeidzot mēs izdrukājam masīva saturu un atbrīvojam masīva izmantoto atmiņu.

mašīnraksta datuma veids

Dinamiskā masīva izmēra maiņa

Vēl viena dinamiskā masīva izmantošanas priekšrocība ir iespēja pēc vajadzības mainīt masīva izmērus. Šeit ir piemērs, kā mainīt dinamiskā masīva lielumu:

 #include #include int main() { int size = 5; int *arr = (int*) malloc(size * sizeof(int)); int i; for(i = 0; i<size; i++) { arr[i]="i;" } resize the array size="10;" arr="(int*)" realloc(arr, * sizeof(int)); for(i="5;" i< size; printf(\'%d \', arr[i]); free(arr); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> 0 1 2 3 4 5 6 7 8 9 </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first create a dynamic array <strong> <em>arr</em> </strong> of size <strong> <em>5</em> </strong> using the <strong> <em>malloc() function</em> </strong> . After that, we set each element of the array to its index using a <strong> <em>for loop</em> </strong> . To resize the array, we set the value of size to <strong> <em>10</em> </strong> and use the <strong> <em>realloc()</em> </strong> function to resize the array. After that, we set the value of the new elements in the array using another for loop. Finally, we print the contents of the array and free the memory used by the array.</p> <h2>Conclusion</h2> <p> <strong> <em>Dynamic arrays</em> </strong> are a powerful data structure in programming that allow for the creation and manipulation of arrays of varying sizes during runtime. In C, dynamic arrays are implemented using pointers and memory allocation functions, making them a valuable tool for optimizing memory usage and creating efficient programs.</p> <p>While <strong> <em>dynamic arrays</em> </strong> have many advantages, they also have some disadvantages. Dynamic arrays can be more complex to implement than static arrays and can be slower in some cases. However, the flexibility and efficiency of dynamic arrays make them a valuable tool for many programming tasks.</p> <p>To create and manipulate dynamic arrays in C, we must use memory allocation functions to allocate and deallocate memory during runtime. The most commonly used memory allocation functions in C are <strong> <em>malloc()</em> </strong> , <strong> <em>calloc()</em> </strong> , and <strong> <em>realloc()</em> </strong> . It is important to properly manage memory usage when working with dynamic arrays to avoid memory leaks and other memory-related issues.</p> <hr></size;>

Paskaidrojums:

Šajā piemērā mēs vispirms izveidojam dinamisku masīvu arr izmēra 5 izmantojot malloc() funkcija . Pēc tam mēs iestatām katram masīva elementam tā indeksu, izmantojot a cilpai . Lai mainītu masīva izmēru, mēs iestatām lieluma vērtību uz 10 un izmantojiet realloc() funkcija, lai mainītu masīva izmēru. Pēc tam mēs iestatām jauno elementu vērtību masīvā, izmantojot citu for cilpu. Visbeidzot mēs izdrukājam masīva saturu un atbrīvojam masīva izmantoto atmiņu.

Java galvenā metode

Secinājums

Dinamiskie masīvi ir jaudīga programmēšanas datu struktūra, kas izpildlaikā ļauj izveidot dažāda lieluma masīvus un manipulēt ar tiem. Programmā C dinamiskie masīvi tiek ieviesti, izmantojot norādes un atmiņas piešķiršanas funkcijas, padarot tos par vērtīgu rīku atmiņas lietojuma optimizēšanai un efektīvu programmu izveidei.

Kamēr dinamiskie masīvi ir daudz priekšrocību, tiem ir arī daži trūkumi. Dinamisko masīvu ieviešana var būt sarežģītāka nekā statiskos masīvus, un dažos gadījumos tie var darboties lēnāk. Tomēr dinamisko masīvu elastība un efektivitāte padara tos par vērtīgu rīku daudziem programmēšanas uzdevumiem.

Lai izveidotu un apstrādātu dinamiskos masīvus programmā C, mums ir jāizmanto atmiņas piešķiršanas funkcijas, lai piešķirtu un atbrīvotu atmiņu izpildlaikā. Visbiežāk izmantotās atmiņas piešķiršanas funkcijas C ir malloc () , calloc() , un realloc() . Strādājot ar dinamiskiem masīviem, ir svarīgi pareizi pārvaldīt atmiņas lietojumu, lai izvairītos no atmiņas noplūdēm un citām ar atmiņu saistītām problēmām.