• Implement a linked list

typedef struct Node Node;
struct Node {
  int*  item;
  Node* next;
};
int* get_last (Node* xs) {
  while (xs->next != NULL) {
    xs = xs->next;
  }
  return xs->item;
}

Code duplication

typedef struct FloatNode FloatNode;
struct FloatNode {
  float*  item;
  FloatNode* next;
};
float* get_last (FloatNode* xs) {
  while (xs->next != NULL) {
    xs = xs->next;
  }
  return xs->item;
}

• Use type (void*) in C

typedef struct Node Node;
struct Node {
  void* item;
  Node* next;
};
void* get_last (Node* xs) {
  while (xs->next != NULL) {
    xs = xs->next;
  }
  return xs->item;
}

Benefits? Downsides?

No static protection against casts

int main () {
  int p     = (int*) malloc (sizeof(int));
  *p        = 2123456789;
  Node* xs  = (Node*) malloc (sizeof(Node));
  xs->next  = NULL;
  xs->item  = p;               // store pointer
  double* q = get_last(xs);    // alias of p
  printf ("q=%f\n", *q);       // unsafe access
}

$ clang -m32 parametric-03.c && ./a.out
q=96621069057346178268049192388430659584.000000

• Generic list using subtype polymorphism

static class Node {
  Object  item;
  Node    next;
}
static Object getLast (Node xs) {
  while (xs.next != null) {
    xs = xs.next;
  }
  return xs.item;
}

ClassCastException at runtime, but no unsafe memory access

public static void main (String[] args) {
  Integer p = Integer.valueOf(2123456789);
  Node xs   = new Node();
  xs.next   = null;
  xs.item   = p;                      // store Integer
  Double q  = (Double) getLast(xs);   // ClassCastException
  System.out.printf ("d=%f\n", q);    // unsafe access
}

$ javac Parametric2.java
$ java Parametric2
java.lang.ClassCastException: Integer cannot be cast to Double

• Container base class

  abstract class Node {
    Object item;
    Node next;
    Object getLast() {
      Node xs = this;
      while (xs.next != null) xs = xs.next;
      return xs.item;
    }
  }
  

• Implementations reuse getLast

  class IntNode extends Node {
    int getLastItem() {
      return (int)getLast(); // cast      
    }
  }
  

Benefits? Downsides?

static casts shifted into library, but problem not solved

How to adapt a class?

• Need type parameters

  class Node {
    ??? item;
    Node next;
    ??? getLast() {
      Node xs = this;
      while (xs.next != null) xs = xs.next;
      return xs.item;
    }
  }
  

• Generic list using parametric polymorphism

class Node<X> {
  X       item;
  Node<X> next;
  X getLast () {
    Node<X> xs = this;
    while (xs.next != null) xs = xs.next;
    return xs.item;
  }
}

• Create a list of Integer

  public static void main (String[] args) {
    Node<Integer> xs = new Node<>();
    xs.next   = null;
    xs.item   = Integer.valueOf(37);
  

• Incompatible read: compile error

    Double q = (Double) getLast(xs); // compiler error
    System.out.printf ("d=%f\n", q); // unsafe access
  }
  

  $ javac Parametric1.java
  error: incompatible types: Integer cannot be converted to Double
    Double q = (Double) getLast(xs);   // compiler error
                              ^
  

static class ArrayList<X> {
  X[] a;
  ArrayList(int n) {
    a = new X[n];
  }
  void put (int i, X item) { a[i] = item; }
  X    get (int i)         { return a[i]; }
}

$ javac Parametric3.java
error: generic array creation
  a = new X[n];
          ^

static class ArrayList<X> {
  X[] a;
  ArrayList(int n) {
    a = (X[]) new Object[n];
  }
  void put (int i, X item) { a[i] = item; }
  X    get (int i)         { return a[i]; }
}

$ javac -Xlint:unchecked Parametric4.java
warning: [unchecked] unchecked cast
    a = (X[]) new Object[n];
              ^

static class ArrayList<X> {
  X[] a;
  
  @SuppressWarnings("unchecked")
  ArrayList(int n) {
    a = (X[]) new Object[n];
  }
  void put (int i, X item) { a[i] = item; }
  X    get (int i)         { return a[i]; }
}

$ javac -Xlint:unchecked Parametric4.java

ArrayList<String> ss = new ArrayList<>(10);
ArrayList os = ss;
os.put (1, 2123456789);
// ClassCastException when reading
String s = ss.get (1);

$ javac Parametric6.java
Note: Parametric6.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

$ java Parametric6                     
ClassCastException: Integer cannot be cast to class String
  at Parametric.main(Parametric6.java:6)

String[] ss = new String[10];
Object[] os = ss;
// ArrayStoreException when writing
os[1] = 2123456789;
String s = ss[1];

$ javac Parametric7.java
// no warnings

$ java Parametric7                     
ArrayStoreException: Integer
   at Parametric.main(Parametric7.java:5)

template <class T> class Node {
  public:
    T item;
    Node<T>* next;
    T getLast() {
      Node<T>* c = this;
      while (c->next != nullptr) 
        c = c->next;
      return c->item;
    }
}

int main(int argc, char* argv[]) {
  Node<int>* n = new Node<int>();
  n->item = 5;
  n->next = new Node<int>();
  n->next->item = 6;
  cout 
    << "Last item: " 
    << n->getLast() << endl;
}

template <class T> class Node {
  public:
    T item;
    Node<T>* next;
    // ...
    void printCout() {
      Node<T>* c = this;
      cout << c->item;
      while (c->next != nullptr) {        
        c = c->next;
        cout << "," << c->item;
      }
      cout << endl;
    }
}