Character String Types in Programming Languages

Inexpensive to provide

Limited dynamic length

enum colors {red, blue, green, yellow, black};

Aid to readability and reliability

An array is a homogeneous aggregate of data elements where each element is identified by its position relative to the first element.

Homogeneous nature

A rectangular array is a multi-dimensioned array in which all rows have the same number of elements and all columns have the same number of elements, while a jagged array has rows with varying numbers of elements.

Implementing arrays requires more compile-time effort than primitive types because arrays are more complex data structures that need to manage memory allocation, indexing, and other operations, while primitive types have a simpler representation in memory.

The fundamental difference between a record and an array is that record elements, or fields, are not referenced by indices, while array elements are referenced by indices.

An associative array is an unordered collection of data elements that are indexed by an equal number of values called keys, where the user-defined keys must be stored.

In C, C++, and C#, records are supported with the struct data type.

Most languages use dot notation for field references, for example: Employee_Record.Employee_Name.Middle.

Subscript expressions are used to map indices to array elements, allowing for the retrieval and manipulation of specific elements within an array.

Static arrays have subscript ranges that are statically bound and storage allocation is also static, done before runtime. Fixed stack-dynamic arrays have statically bound subscript ranges but dynamic storage allocation at declaration time. Stack-dynamic arrays have dynamically bound subscript ranges and dynamic storage allocation at runtime.

In Ada, the use of parentheses () for array references is to maintain uniformity between array references and function calls, as both are mappings from indices to elements.

The subscript expression to access the element in the second row and third column of a $3 \times 4$ matrix represented as a two-dimensional array would be array[1][2].

Static arrays are the most efficient due to their static subscript ranges and storage allocation, but they lack flexibility in terms of array size. Fixed stack-dynamic arrays offer a balance of efficiency and flexibility, with statically bound subscript ranges but dynamic storage allocation. Stack-dynamic arrays provide the most flexibility, allowing for dynamically bound subscript ranges and dynamic storage allocation, but may be less efficient than the other categories.

While both array references and function calls involve a mapping from input values to output values, the syntax used to express them differs. Array references typically use subscript expressions with brackets [] or parentheses (), whereas function calls use parentheses () to enclose the arguments passed to the function.

Fixed heap-dynamic arrays have storage binding that is dynamic but fixed after allocation (binding is done when requested and storage is allocated from heap, not stack). This provides flexibility as the array's size always fits the problem. Fixed stack-dynamic arrays have storage binding that is static and allocated on the stack, providing less flexibility.

C and C++ arrays that include the static modifier are static, e.g., static int a = {1, 2, 3, 4, 5};. Arrays without the static modifier are fixed stack-dynamic, e.g., int* arr = new int(5);.

C and C++ provide fixed heap-dynamic arrays using the malloc functions, e.g., int* arr = (int*)malloc(sizeof(int) * n);.

In C, C++, Java, and C#, arrays can be initialized at the time of storage allocation, e.g., int list[] = {4, 5, 7, 83}; in C/C++. Character strings in C/C++ can be initialized as char name[] = "freddie";. Arrays of strings in C/C++ can be initialized as char *names[] = {"Bob", "Jake", "Joe"};. In Java, String objects can be initialized as String[] names = {"Bob", "Jake", "Joe"};.

The advantage of heap-dynamic array bindings is flexibility, as arrays can grow or shrink during program execution.

C# includes a second array class ArrayList that provides fixed heap-dynamic arrays, whereas C and C++ use the malloc functions to achieve the same.

Arrays are used when data values have the same type and are processed the same way, while records are used when data values are heterogeneous and processed differently.

A pointer type variable has a range of memory addresses and a special value, nil.

Assignment and dereferencing.

C++ uses an explicit operation via '*'. For example, j = *ptr sets j to the value located at ptr.

Pointers are extremely flexible but can lead to memory-related issues if not handled properly.

Access to array elements is much slower than access to record fields.