• type equivalence
• type compatibility
• type inference

Coercion

• Automatic conversion
  
  • Ada require explicit conversion which is like casting in C (Java/ C++)
  • Haskell has several overloaded functions that serve as explicit coercions:
    • fromInteger, fromRational, toInteger, toRational, fromIntegral, fromRealFrac, fromIntegral, fromRealFrac
    • fromInteger and fromRation are implicitly used to provide overloaded numeric literals:
      
      
• 4.5 + 6 in most languages is probably 4.5 + 6.0
  • + is usually an overloaded operator, adding integers or reals (floats)
  • Usually addition of reals
      
• The Louden describes a PL/I's problem: (Rule: fractional value's precision must be maintained.)
  1/3 + 15 returns 5.33333333333333


• Type widening is more natural than type narrowing in general.
  • type widening
  • int to real
  • 2-byte int to 4 byte int
  • type narrowing
  • real to int

• Java uses the terms numerical promotion and widening conversion
• APL uses  promotion to means coercion from a scalar to an aggregate

What do you think this means?

The programmer should be aware:

• No standard definition for such terms
• The same code is executed for different types
  • The primitive type is changed and stored in a temporary location for use.

Casting

• In C++ the term cast refers to four different kinds of explicit type conversion
  • static_cast:produces a new value "equivalent" to the original.
    
    
    • double x = static_cast 3;
    • same a C cast
       
      
  • dynamic_cast:a run-time type-checked conversion of a pointer.
      
    
    • Value is 0 if the conversion is invalid
        

  Parent *  p = new Child;  //up cast

  Child * c = dynamic_cast<Child *> p;  //downcast
    

  • reinterpret_cast: produces no new values; merely changes the set of functions that can be applied to the original value
      
    
    • few reinterpret_casts are portable
    • completely unchecked
       
  • const_cast: removes const protection from a parameter

• C, C++, Java indexes are always integers starting at 0.

• FORTRAN 77, FORTRAN 90 uses integers.  The lowerbound default if 1.

• Pascal allows any ordinal type to be an index.

     type WkE = (Sat, Sun);

• C, C++, Java indexes are always integers starting at 0.
• FORTRAN 77, FORTRAN 90 uses integers.  The lower bound default if 1.
• Pascal allows any ordinal type to be an index.

• Ada allows any discrete type (page 153) to be an index.
   
• Integers, Booleans and characters are examples of discrete types ( also called ordinal types).
    
  
• Unconstrained 2-dimensional array

• Constrained 2-dimensional array

---

If the arrays are allocated during compile time then the range is statically bound.

• Fortran 77

• Global or automatic array (value model) variable in C:

  int arr [ 40 ];  

Automatic Arrays (variable length arrays) declared in  C functions:  

Range bound dynamic, storage dynamic

Prior to C99 this code would not compile.

Prior to C99: When multidimensional arrays are used, it is necessary to specify the bounds of but the first dimension.

---

When and where does array allocation take place?

If  the arrays are allocated from the heap then both the storage allocation and the subscript ranges can be dynamically bound.

Java: reference model

• Storage only on the heap
• Arrays are objects
   
  
  String [ ] sArray = new String[5];
  Object [ ] myArray = new Object [sArray.length];
  
  
• Java does do range checking.  All arrays have a field length that never changes.
   
• C, C++ can also dynamically allocate storage from the heap.
  • C, C++ does not do range checking.

Perl:

• variables names for arrays begin with "@"
• storage is dynamically allocated
• example:


@myPerlarr = ("one","two","three");
$myPerlarr[0]   is the scalar with value "one"
@myPerlarr[26] = "wow";

Extends the array to length 26.

---

How is the array stored in memory?  Runtime calculation of array element.

Computing effective address:

Arrays in most language implementation are stored in contiguous location in memory.  

Some languages arrays of arrays.

The key feature of arrays is O (1) access time to any array element.

Formula for computing the effective address of a one dimensional array:

• A: array [LowerBound .. UpperBound]
  
  
• Let ba be the base address of array A, and
• Let size be the number of addressable units(bytes) required to store a value of base type of A.
•  Then the effective address of A[k] is:

Multidimensional arrays:  Where does the second element of the array go? 

A: array [LowerBound .. UpperBound ] of array [1..4] of char

Row-major -- Rows are contiguous in memory A[2,4] is followed by A[2,5]

Column-major major columns are contiguous, A[2,4] is followed by A[3,4]

Fortran uses Column major most languages uses row major --

What is the implications for porting code? (Cache?, program correctness?)

---

Can arrays be initialized when they have their storage allocated?

Initialization: In FORTRAN, Java, C and Ada, arrays can be initialized in their declaration.

Forcing a '2 dimensional' array representation with initialization in Java:

 


Note: "global" variables in Java are initialized (0,nil) but NOT local variables.

---

Haskell, Prolog

• Do not have arrays.
• lists are the way to sequence data.
• How are lists different from arrays?

• Programming in C++, C# and Java you should use collection frameworks provided in the languages.

---

Pointers:

• C, C++ pointer types
  • polymorphic data types
  • the R-value is an address

int * x;

float * y;



• C pointers' "units" are adjusted according to the size of the type they point to.

• C++ allows functions to return l-values
  int a[10];
  int& f(int I) { return (a[I]); }
  f(5) = 17;
  // This assigns 17 to a[5]

Pointer (access) types provide a way of manipulating memory addresses.

Pointers may be used to create recursive types, e.g. linked list and trees.

C example:

typedef struct tree {
   int val;
   struct tree* right;
   struct tree* left;
}

Pointers and Arrays in C

• There is a close correspondence between types "array of Ttype" and "pointer to Ttype".
  • a[i] can be defined as *(( a )+( i ))
  • In fact a[i] is the same as i[a]!
  • Since ip = a; is legal is a = ip; legal?

int a[10], *ip;
ip = a;
ip = &a[0];