Comparison of dynamic arrays and fixed arrays

Dynamic arrays and static arrays are two different types of arrays commonly used in programs. They have clear differences in memory management, size and usage flexibility.

Static array is an array that is defined and allocated memory space at compile time. Its size is determined at compile time and cannot be modified. The size of a static array is usually specified when declaring it, for example: int arr[10]. When using static arrays, the compiler allocates a fixed size of memory space for them, resulting in their size not being modified at runtime. This means that the size of a static array cannot be increased or decreased dynamically.

In contrast, a dynamic array is an array that is created and destroyed at runtime, and its size can be adjusted as needed. The size of a dynamic array is not determined at compile time, but memory space is allocated and released as needed at runtime. The size of a dynamic array can be dynamically adjusted by using specific functions, such as malloc() and realloc(). When using dynamic arrays, the size of the array can be dynamically adjusted according to actual needs.

The following is a specific code example to illustrate the difference between dynamic arrays and static arrays:

Static array example:

#include <iostream>

int main() {
    int arr[5]; // 静态数组声明
    
    for(int i = 0; i < 5; i++) {
        arr[i] = i; // 为静态数组赋值
    }
    
    for(int i = 0; i < 5; i++) {
        std::cout << arr[i] << " "; // 输出静态数组的元素
    }
    
    return 0;
}

A static array with a size of 5 is declared here Array arr and assign a value to it. The size of a static array is determined at compile time and cannot be modified at runtime.

Dynamic array example:

#include <iostream>
#include <cstdlib>

int main() {
    int size;
    std::cout << "请输入动态数组的大小：";
    std::cin >> size;
    
    int* arr = (int*) malloc(size * sizeof(int)); // 动态数组的创建
    
    for(int i = 0; i < size; i++) {
        arr[i] = i; // 为动态数组赋值
    }
    
    for(int i = 0; i < size; i++) {
        std::cout << arr[i] << " "; // 输出动态数组的元素
    }
    
    free(arr); // 动态数组的销毁
    
    return 0;
}

Here, the size of the dynamic array is obtained through user input, and then the malloc() function is used to dynamically create an int type dynamic array arr of size size. The size of dynamic arrays can be adjusted based on input. Finally, use the free() function to release the memory space occupied by the dynamic array.

As can be seen from the above example, the difference between dynamic arrays and static arrays lies in the way the size is determined and the way memory is managed. The size of a static array is determined at compile time and cannot be modified, whereas the size of a dynamic array can be adjusted as needed at runtime. The creation and destruction of dynamic arrays requires the use of specific functions for memory management, while the memory management of static arrays is automatically handled by the compiler. Therefore, in practical applications, we need to choose to use static arrays or dynamic arrays according to specific needs.

The above is the detailed content of Comparison of dynamic arrays and fixed arrays. For more information, please follow other related articles on the PHP Chinese website!