0
The most reasonable assumption I can make is that you are referring to the data structures used when programming - some specification is, perhaps, in order.
In such case, the name itself says what - fixed arrays cannot accomodate a growing numbers of values beyond their initial limitations. Though I'm highly inexperience in programming, I can't imagine that, without context, any more definite answer can be given...
But hey, if anyone disagrees with me, don't take my word.
Wiki User
∙ 15y ago
Add your answer:
Earn +20 pts
Why is an array called a derived data type?
An array is not a derived data type at all. In order to be derived there has to be a base class and an array has no base class. Here is the basic declaration of the std::array template class from the <array> header file: template<class _Ty, size_t _Size> class array { // fixed size array of values // ... }; A vector, on the other hand, is derived (from the <vector> header file): template<class _Ty, class _Alloc = allocator<_Ty>> class vector : public _Vector_alloc<!is_empty<_Alloc>::value, _Vec_base_types<_Ty, _Alloc>> { // varying size array of values // ... };
What is the difference between an array element and a variable?
Array elements are all members of the same variable, indexed in a logical manner. variables are distinct objects which must be referred to distinctly. The main functional difference is that a program can iterate over an array without the programmer knowing the original size of the array or explicitly which member to access.
What is the difference between fixed and variable partition?
in the fixed partition the partition is once allocated is fixed. in fixed partition more memory wastage because of internal & external fragmentation.... in variable partition when a process comes then according to need of process the size of memory is allocated to the process
How does Asynchronous Transfer Mode ATM transmit data?
As fixed-size cells via a fixed channel between two points
What are some limitations with using models to show atoms?
Size, if a model of an atom was in proportion, the electrons would be very far away from the nucleus
Why fixed size array is not efficient?
It's not exactly true. Array with fixes size are efficient, but do not work well when you have to resize your array. This actually is the answer for your question. Fixed size arrays are not efficient if you have to change the size. Also you cannot destroy them and release memory used to save the array (for that you have to use operator new).
What is the difference between a fixed size array and a variable size array?
The obvious answer is that one has a constant size while the other does not. More specifically, a fixed-size array is one where the size is known at compile time and does not change at runtime. By contrast, the size of a variable-sized array may or may not be known at compile time but may change at runtime. We often refer to a variable-size array as being a dynamic array, however some people (myself included) incorrectly refer to a fixed-size array as being a static array. The misunderstanding largely comes from the fact that we often refer to the heap (or free store) as being dynamic memory because all dynamic variables are allocated there (including variable-size arrays). But the term dynamic array does not refer to the memory, it refers to the dynamic -- as in changeable -- nature of the array itself. By contrast, a fixed-size array is only deemed static if it is statically allocated, in which case it will be allocated in the program's data segment along with all other static variables, global variables and constants. But a local fixed-size array is allocated on the program's stack and is therefore, by definition, non-static. Moreover, you can allocate a fixed-size array on the heap!
What are limitations of array?
1) Array is a static data structure. Hence it has to be declared with a fixed size. Changing the size of the array involves procedures like relocation, freeing memory space, etc2) They hold elements of the same data type. Hence they are not suitable for storing and working with different data types. 3) Insertion and deletion in any place other than the end of the array has a time complexity of O(n).
Is an array is a collection of characters that can be fixed or variable?
No. An array is a collection of objects of any type, such as doubles, not just characters. You can even have arrays of arrays, or arrays of structs. In C, the size of an array is fixed, but it is possible to write code that will allow you to manually make it variable in size.
How do you find missing numbers in a array with elements below its size?
Please rephrase your question. An array usually has a fixed size and I don't recall ever having to "go below its size". This implies that the missing elements are not within the range of the array.
Is the array size is fixed after it is created?
Generally, a array is fixed in size. With some libraries, however, they are extensible, either by reallocation/copying strategies (C/C++/STL), or by linking/referencing strategies (JAVA).
What are the limitations of arrays?
1) Array is a static data structure. Hence it has to be declared with a fixed size. Changing the size of the array involves procedures like relocation, freeing memory space, etc2) They hold elements of the same data type. Hence they are not suitable for storing and working with different data types. 3) Insertion and deletion in any place other than the end of the array has a time complexity of O(n).
Sample program of single-dimentional array?
#include "stdio.h" #define SIZE 100; void main() { int array[SIZE], i, size; printf("\nEnter the Size off Array :- "); scanf("%d", &size); printf("\nEnter the Elements of Array :- ")' for(i = 0; i < size; i++) scanf("%d", &array[i]; printf("\nThe Elements of entered Array :- "); for(i = 0; i < size; i++) printf("%7d", array[i]); }
Difference between loop and array?
A loop usually referred to the program flow control with possible repetition of executing the same codes, an array is an abstraction of fixed size container. 2 different concepts.
Is there a way to use a variable to declare the size of an array in true basic?
! variable to declase the size of an array in True Basic ! set up a dummy value for array - any initial value > 0 is fine. DIM array$(999) ! ask the user for the length of the array INPUT PROMPT "Enter array size " :size ! resize the array with user defined length MAT REDIM array$(size) ! program end END
Why would you use the array of pointers to pointers?
You would use an array of pointers to pointers whenever you wished to implement a dynamic multi-dimensional array of 3 or more dimensions. Every multi-dimensional array can ultimately be reduced to a one-dimensional array where each element is itself a one-dimensional array (an array of arrays). With fixed-size arrays, all elements can be allocated contiguously regardless of how many dimensions there are. Fixed size arrays can be allocated both statically (when the size is known at compile time) or dynamically (when the size is unknown at compile time). However with large arrays it is often necessary to divide the array into smaller subarrays each of which is allocated separately (non-contiguously with each other) and maintain a separate array of pointers to keep track of each of those subarrays. Although this consumes more memory than a contiguously-allocated array would, it has the added benefit in that each subarray need not be the same length, thus it can actually save memory overall. However, if we had several such arrays then we would need yet another array in order to keep track of them all, and this array would need to be an array of pointers to pointers.
Why is an array called a derived data type?
An array is not a derived data type at all. In order to be derived there has to be a base class and an array has no base class. Here is the basic declaration of the std::array template class from the <array> header file: template<class _Ty, size_t _Size> class array { // fixed size array of values // ... }; A vector, on the other hand, is derived (from the <vector> header file): template<class _Ty, class _Alloc = allocator<_Ty>> class vector : public _Vector_alloc<!is_empty<_Alloc>::value, _Vec_base_types<_Ty, _Alloc>> { // varying size array of values // ... };
