# teaching machines

## CS 330 Lecture 24 – Generics/templates

April 2, 2012 by . Filed under cs330, lectures, spring 2012.

### Agenda

• named constructor pattern
• typing: strong and static and dynamic
• a peril of static typing: code
• Java generics
• C++ templates

### Code

#### makefile

drawer: drawer.cpp Vector.h Matrix.h Matrix.cpp Vector.cpp
g++ -Wall -o drawer Vector.cpp Matrix.cpp drawer.cpp


#### Vector.cpp

#include <cassert>
#include "Vector.h"

Vector2::Vector2() :
x(0.0f),
y(0.0f) {
}

Vector2::Vector2(float x, float y) :
x(x),
y(y) {
}

float& Vector2::operator[](int index) {
assert(index >= 0 && index <= 1);
return index == 0 ? x : y;
}

const float& Vector2::operator[](int index) const {
assert(index >= 0 && index <= 1);
return index == 0 ? x : y;
}

Vector2 Vector2::operator+(const Vector2& other) {
return Vector2(x + other.x, y + other.y);
}

std::ostream& operator<<(std::ostream& out,
const Vector2& v) {
out << v[0] << "," << v[1];
return out;
}


#### Vector.h

#ifndef VECTOR_H
#define VECTOR_H

#include <iostream>
#include <fstream>

class Vector2 {
public:
Vector2();
Vector2(float x, float y);

// write a subscript operator
float& operator[](int index);

const float& operator[](int index) const;

Vector2 operator+(const Vector2& other);

private:
float x;
float y;
};

std::ostream& operator<<(std::ostream& out,
const Vector2& v);

#endif


#### Matrix.cpp

#include <cmath>
#include "Matrix.h"

Matrix2::Matrix2() {
}

float& Matrix2::operator()(int r, int c) {
return elements[r * 3 + c];
}

const float& Matrix2::operator()(int r, int c) const {
return elements[r * 3 + c];
}

Vector2 operator*(const Matrix2& m, const Vector2& v) {
Vector2 product;
// dot m's row 0 with v's col 0
product[0] = m(0, 0) * v[0] + m(0, 1) * v[1] + m(0, 2);
// dot m's row 1 with v's col 0
product[1] = m(1, 0) * v[0] + m(1, 1) * v[1] + m(1, 2);
return product;
}

Matrix2 Matrix2::GetScale(float x, float y) {
Matrix2 m;
m(0, 0) = x;
m(1, 1) = y;
m(2, 2) = 1.0f;
m(0, 1) = m(0, 2) = m(1, 0) = m(1, 2) = m(2, 0) = m(2, 1) = 0.0f;

return m;
}

Matrix2 Matrix2::GetRotate(float degrees) {
float radians = degrees * 3.14159f / 180.0f;
Matrix2 m;
m(2, 2) = 1.0f;
m(0, 2) = m(1, 2) = m(2, 0) = m(2, 1) = 0.0f;

return m;
}

/* ------------------------------------------------------------------------- */



#### Matrix.h

#ifndef MATRIX_H
#define MATRIX_H

#include "Vector.h"

class Matrix2 {
public:
Matrix2();

float& operator()(int r, int c);
const float& operator()(int r, int c) const;

static Matrix2 GetScale(float x, float y);
static Matrix2 GetRotate(float degrees);
static Matrix2 GetTranslate(float x, float y);

private:
/* float elements[9]; */
double elements[9];
};

Vector2 operator*(const Matrix2& m, const Vector2& v);

#endif


#### drawer.cpp

#include <cmath>
#include <iostream>

#include "Matrix.h"
#include "Vector.h"

int main() {
Matrix2 rotate = Matrix2::GetRotate(30.0f);
Matrix2 scale = Matrix2::GetScale(1.04f, 1.04f);
/* float radians = 30.0f * 3.14159f / 180.0f; */
/* transform(0, 0) = cos(radians); */
/* transform(0, 1) = -sin(radians); */
/* transform(1, 0) = sin(radians); */
/* transform(1, 1) = cos(radians); */
/* transform(0, 2) = 0.0f; */
/* transform(1, 2) = 0.0f; */
/* transform(2, 0) = 0.0f; */
/* transform(2, 1) = 0.0f; */
/* transform(2, 2) = 1.0f; */
Vector2 point(1.0f, 0.0f);

std::cout << point << std::endl;
for (int i = 0; i < 120; ++i) {
point = rotate * point;
point = scale * point;
std::cout << point << std::endl;
}

/* Vector2 point2(1.0f, 2.0f); */
/* Vector2 sum = point + point2; */
/* Vector2 sum = point.operator+(point2); */
/* std::cout << "sum[0]: " << sum[0] << std::endl; */
/* std::cout << "sum[1]: " << sum[1] << std::endl; */
/* std::cout << "sum: " << sum << std::endl; */

/* std::cout << "point[0]: " << point[0] << std::endl; */
/* std::cout << "point[1]: " << point[1] << std::endl; */

/* point[0] = 11.0f; */

/* std::cout << "point[0]: " << point[0] << std::endl; */
/* std::cout << "point[1]: " << point[1] << std::endl; */

/* point[0] // point.getX() */
/* point[1] // point.getY() */
}


#### ArrayList.java

package cs330;

public class ArrayList {
private Object[] stuff;
private int size;

public ArrayList() {
stuff = new Object[10];
size = 0;
}

public Object get(int i) {
return stuff[i];
}

public int size() {
return size;
}

if (size == stuff.length) {
Object[] aWholeLotMoreStuff = new Object[stuff.length * 2];
System.arraycopy(stuff, 0, aWholeLotMoreStuff, 0, stuff.length);
stuff = aWholeLotMoreStuff;
}

stuff[size] = o;
++size;

return true;
}
}


### Haiku

on code reuse:
“Don’t reinvent the wheel!”
Ignore them. We don’t need wheels.
We need inventors.