Assignment 6

Pada post kali ini, saya akan menjawab pertanyaan-pertanyaan Assignment #6 dari Chapter 6, dari buku "Concepts of Programming Languages" karya Robert W. Sebesta.

Review Questions

        1.  What are the advantages of user-defined enumeration types?
The advantages are readability and reliability.

        2. In what ways are the user-defined enumeration types of C# more reliable than those of C++?
C# enumeration types are like those of C++, except that they are never coerced to integer. So, operations on enumeration types are restricted to those that make sense. Also, the range of values is restricted to that of the particular enumeration type.

        3. What are the design issues for arrays?

• Where do arrays start? Some choices are zero, one, or any integer value, positive or negative.
• What notation is used to indicate arrays? Common choices are to include subscripts in parentheses or brackets.
• How many elements does an array of size 10 have? Possible choices are 10 (which could go from 0 to 9, or 1 to 10), or 11 (when the elements go from 0 to 10).
• How are arrays arranged in memory? Two choices are by row or by column.
• What can be used for array subscript? Choices are only integers, any ordinal value, sets, reals, or other items.
• What sort of error checking is done for the array indexes?
• What array operations are available? Can we add two arrays, or compare arrays?
• Can arrays be assigned or returned as function values?
• Are array slices or sections available?

        4. Define static, fixed stack-dynamic, stack-dynamic, fixed heap-dynamic, and heap dynamic arrays. What are the advantages of each?

• Static array : the subscript ranges that are statically bound and storage allocation is static (done before run time). The advantage is efficiency, means that there is no dynamic allocation or deallocation required.
• Fixed Stack-dynamic array : the subscript ranges that are statically bound, but the allocation is done at declaration elaboration time during execution. The advantage is space efficiency, means that a large array in one subprogram can use the same space as a large array in a different subprogram, as long as both subprograms are not active at the same time.
• Stack-dynamic array : both the subscript ranges and the storage allocation are dynamically bound at elaboration time. the advantage is flexibility. the size of an array need not be known until the array is about to be used.
• Fixed heap-dynamic array : similar to a fixed stack dynamic array, in that the subscript ranges and the storage binding are both fixed after storage is allocated. the differences are that both the subscript ranges and storage bindings are done when the user program requests them during execution, and the storage is allocated from the heap, rather than the stack. the advantage is flexibility – the array’s size always fits the problem.
• Heap dynamic array : the binding of subscript ranges and storage allocation is dynamic and can change any number of times during the array’s lifetime. The advantage is flexibility, means that arrays can grow and shrink during program execution as the need for space changes.

        5. What happens when a nonexistent element of an array is referenced in Perl?

When a nonexistent element of an array is referenced in perl, an array can be made to shrink to no elements by assigning it the empty list. So, the length of an array is defined to be the largest subscript plus one.

Problem Sets

        6. Explain all of the differences between Ada’s subtypes and derived types.

A subtype is compatible with its base type, so you can mix operands of the base type with operands of the base type. For example : subtype Week_Days is Integer range 1..7; Since this is a subtype, you can (for example) add 1 to a weekday to get the next weekday. A derived type is a completely separate type that has the same characteristics as its base type. You cannot mix operands of a derived type with operands of the base type. If, for example, you used:type Week_Day is new Integer range 1..7; Then you would not be able to add an integer to a weekday to get another weekday. To do manipulations on a derived type, you'd normally define those manipulations yourself (e.g., create a package). At the same time, a derived type does "inherit" all the operations of its base type (even some that may not make sense) so you do still get addition.

        7. What significant justification is there for the -> operator in C and C++?
The only justification for the -> operator in C and C++ is writability. It is slightly easier to write p -> q than (*p).q.In C and C++, there are two ways a pointer to a record can be used to reference a field in that record. If a pointer variable p points to a record with a field named age, (*p).age can be used to refer to that field. The operator ->, when used between a pointer to a record and a field of that record, comfbines dereferencing and field reference. For example, the expression p -> age is equivalent to (*p).age. In Ada, p.age can be used, because such uses of pointers are implicitly dereferenced.

        8. What are all of the differences between the enumeration types of C++and those of Java?

In C++, an enumeration is just a set of named, integral constants. In Java, an enumeration is more like a named instance of a class. You have the ability to customize the members available on the enumeration.Also, C++ will implicitly convert enum values to their integral equivalent, whereas the conversion must be explicit in Java.

        9. The unions in C and C++ are separate from the records of those languages, rather than combined as they are in Ada. What are the advantagesand disadvantages to these two choices?
Advantage:

Unconstrained variant records in Ada allow the values of their variants to change types during execution.

Disadvantage:
However, the type of the variant can be changed only by assigning the entire record, including the discriminant. This disallows inconsistent records because if the newly assigned record is a constant data aggregate, the value of the tag and the type of the variant can be statically checked for consistency.

        10. Multidimensional arrays can be stored in row major order, as in C++, or in column major order, as in Fortran. Develop the access functions for both of these arrangements for three-dimensional arrays.
Let the subscript ranges of the three dimensions be named min(1), min(2), min(3), max(1), max(2), and max(3). Let the sizes of the subscript ranges be size(1), size(2), and size(3). Assume the element size is 1. Row Major Order: location(a[i,j,k]) = (address of a[min(1),min(2),min(3)]) +((i-min(1))*size(3) + (j-min(2)))*size(2) + (k-min(3)) Column Major Order: location(a[i,j,k]) = (address of a[min(1),min(2),min(3)]) +((k-min(3))*size(1) + (j-min(2)))*size(2) + (i-min(1))