User-Defined Types

A class is a user-defined type provided to represent a concept in the code of a program. Essentially, all language facilities beyond the fundamental types, operators, and statements exist to help define better class or to use them more conveniently.

A struct helps us organize the elements that a type needs into a data structure, e.g.

struct Vector {
  int sz;         // number of elements
  double* elem;   // pointer to elements on the free store
};

void vector_init(Vector& v, int s) {
  v.elem = new double[s];
  v.sz = s;
}

However, notice that a user of Vector has to know every detail of a Vector’s representation. We can improve on this.

There is no fundamental difference between a struct and a class; a struct is simply a class with members public by default.

Unscoped (or Plain or C-Style) Enumerations

Plain (or C-style) enums are entered in the same scope as the name of their enum, and implicitly convert to their integer value, e.g.

enum Color { red, green, blue };
int col = green;
Color c2 = 1; // error: invalid conversion from 'int' to 'Color' [-fpermissive]

enum CardColor { red, black }; // Error: "red" conflicts with a previous declaration

The name can be omitted if it’s not going to be used, e.g.

enum { red, green, blue };
int col = red;

.

Unnamed enums are common in code written before alternative ways of specifying integer constants, e.g.

A union is a struct in which all members are allocated at the same address so that the union occupies as much space as its largest member, e.g.

// This is a naked union because it doesn't have an associated indicator
// for which member it holds.
union Value {
  Node* p;
  int i;
}

// The language doesn't keep track of which kind of value is held by a
// union, so the programmer must do that themselves, e.g.

enum Type { ptr, num };

struct Entry {
  string name;
  Type t;
  Value v;      // use v.p if t == ptr; use v.i if t == num
};

// Sample usage.
void f(Entry* pe) {
  if (pe->t == num)
    std::cout << pe->v.i;
  // ...
}

implements a toy version of Python’s object system using dictionaries that contain references to properties, functions and other dictionaries. Consider two shapes, Square and Circle, with the methods perimeter, area, and density.

Objects

A function is an object, where the bytes in a function are instructions. For example:

def foo():
  print("in foo")

… creates an object in memory that contains instructions to print a string, and assigns that object to the variable foo.

Mixins

A mix-in is an abstract subclass. This technique is especially useful in languages where a class can only have a single superclass.

const calculatorMixin = (Base) =>
  class extends Base {
    calc() {}
  };

const randomizerMixin = (Base) =>
  class extends Base {
    randomize() {}
  };

class Foo {}
class Bar extends calculatorMixin(randomizerMixin(Foo)) {}