* Can you write a program to read integers from the input and print them in
  sorted order?

#include <vector>
#include <iostream>
#include <algorithm>

int main() {
  std::vector<int> data;
  int val = 0;
  while (std::cin >> val) {
    data.push_back(val);
  }
  std::sort(data.begin(), data.end());
  for (int elem: data) {
    std::cout << elem << " ";
  }
  std::cout << std::endl;
}

* What is this syntax "vector<int>"?

* What if we want to sort strings?

#include <vector>
#include <iostream>
#include <algorithm>

int main() {
  std::vector<std::string> data;
  std::string val;
  while (std::cin >> val) {
    data.push_back(val);
  }
  std::sort(data.begin(), data.end());
  for (std::string elem: data) {
    std::cout << elem << " ";
  }
  std::cout << std::endl;
}

* What are the differences between these two programs?

* Are they redundant?

* How could we factor out this redundancy?

#include <vector>
#include <iostream>
#include <algorithm>
template <class T> void readNSort() {
  std::vector<T> data;
  T val;
  while (std::cin >> val) {
    data.push_back(val);
  }
  std::sort(data.begin(), data.end());
  for (T elem: data) {
    std::cout << elem << " ";
  }
  std::cout << std::endl;
}
int main() {
  readNSort<int>();
}

* What does the declaration 'template <class T> void readNSort()' indicate?

* What if we wanted to sort strings?

#include <vector>
#include <iostream>
#include <algorithm>
template <class T>
void readNSort() {
  std::vector<T> data;
  T val;
  while (std::cin >> val) {
    data.push_back(val);
  }
  std::sort(data.begin(), data.end());
  for (T elem: data) {
    std::cout << elem << " ";
  }
  std::cout << std::endl;
}
int main() {
  readNSort<std::string>();
}

* Can you test it with doubles?

int main() {
  readNSort<double>();
}

* Does it work for any type?
  - Not really!

* What does a type must have to work with readNSort?
  - The in-streaming operator >>
  - The out-streaming operator <<
  - Must be "sortable", i.e.: has the greater than operator >

* Is it the case that any type has these operators? Consider:

struct S {
  int x, y;
};
int main() {
  readNSort<struct S>();
}

* Let's sum up the elements, instead of sorting them:

#include <deque>
#include <iostream>
template <class T> T readNSum(std::deque<T> &data) {
  T sum = data.front();
  data.pop_front();
  for (T elem: data) {
    sum = sum + elem;
  }
  return sum;
}
int main() {
  std::deque<int> data;
  data.push_back(1);
  data.push_back(2);
  data.push_back(3);
  std::cout << readNSum<int>(data) << std::endl;
}

* What's a deque?
  - That's a vector from where elements can be removed at both ends.

* Does the program above work with doubles?

int main() {
  std::deque<double> data;
  data.push_back(1.1);
  data.push_back(2.2);
  data.push_back(3.3);
  std::cout << readNSum<double>(data) << std::endl;
}

* Strings?

int main() {
  std::deque<std::string> data;
  data.push_back("a");
  data.push_back("a");
  data.push_back("a");
  std::cout << readNSum<std::string>(data) << std::endl;
}

* Does it work with struct S, i.e.:

struct S {
  int x, y;
};
int main() {
  struct S s;
  s.x = 1;
  s.y = 2;
  std::deque<struct S> data;
  data.push_back(s);
  data.push_back(s);
  data.push_back(s);
  std::cout << readNSum<struct S>(data).x << std::endl;
}

* What does it have to do to work with "struct S"?

struct S {
  int x, y;
  S operator + (const S &obj) { 
    S res;  
    res.x = obj.x + x;
    res.y = obj.y + y;
    return res;
  } 
};

template <class T>
T readNSum(std::deque<T> &data) {
  T sum = data.front();
  data.pop_front();
  for (T elem: data) {
    sum = sum + elem;
  }
  return sum;
}

* Would the code above work if I changed the implementation of readNSum like
  the code below?

template <class T> T readNSum(std::deque<T> &data) {
  T sum = data.front();
  data.pop_front();
  for (T elem: data) {
    sum += elem;
  }
  return sum;
}

* What we need to do to ensure that it compiles?

struct S {
  int x, y;
  S operator + (const S &obj) {
    S res; 
    res.x = obj.x + x;
    res.y = obj.y + y;
    return res; 
  } 
  S& operator += (const S &obj) {
    x = obj.x + x;
    y = obj.y + y;
    return *this;
  }
};

* Can we use two types in the same generic declaration?

#include <iostream>
template <class T, class U> class Pair {
  T first; 
  U second;
  public:
    Pair(T f, U s): first(f), second(s) {}
    T getFirst() {
      return first;
    }
    U getSecond() {
      return second;
    } 
};
int main() {
  Pair<int, std::string> p0(1, "um");
  std::cout << p0.getFirst() << std::endl;
  std::cout << p0.getSecond() << std::endl;
  Pair<double, bool> p1(3.14, true);
  std::cout << p1.getFirst() << std::endl;
  std::cout << p1.getSecond() << std::endl;
}

* Consider the template below. Can we remove the type declaration from 
  "k=GetMax<int>(i, j)", for instance?

#include <iostream>
using namespace std;
template <class T> T GetMax (T a, T b) {
  return (a>b?a:b);
}
int main () {
  int i=5, j=6, k;
  long l=10, m=5, n;
  k=GetMax<int>(i,j);
  n=GetMax<long>(l,m);
  cout << k << endl;
  cout << n << endl;
  cout << GetMax<std::string>("bola", "ovo");
  return 0;
}

* And how is this template implemented in assembly?

$> clang++ -S GetMax.cpp
... __Z6GetMaxIiET_S0_S0_
... __Z6GetMaxIlET_S0_S0_
... __Z6GetMaxINSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEET_S7_S7_

* How to declare a generic class member outside the class definition?

template <class T, class U> class Pair {
  T first;
  U second;
  public:
    Pair(T f, U s): first(f), second(s) {}
    T getFirst();
    U getSecond() {
      return second;
    }
};
template <class T, class U> T Pair<T, U>::getFirst() {
  return first;
}

* Is the program below going to compile?

#include <iostream>
using namespace std;
struct Interval {
  int x, y;
};
template <class T> T GetMax (T a, T b) {
  return (a>b?a:b);
}
int main () {
  Interval i0, i1;
  i0.x = 1;
  i0.y = 10;
  i1.x = 2;
  i1.y = 4;
  Interval i2 = GetMax<Interval>(i0,i1);
  cout << i2.x << endl;
  return 0;
}

* How to fix it?

#include <iostream>
using namespace std;
struct Interval {
  int x, y;
  bool operator> (const Interval& i1) {
    return x < i1.x && y > i1.y;
  } 
};
template <class T> T GetMax (T a, T b) {
  return (a>b?a:b);
}
int main () {
  Interval i0, i1;
  i0.x = 1;
  i0.y = 10;
  i1.x = 2;
  i1.y = 4;
  Interval i2 = GetMax<Interval>(i0,i1);
  cout << i2.x << endl;
  return 0;
}

* Do you think this makes sense?

int main () {
  Interval i0, i1;
  i0.x = 1;
  i0.y = 8;
  i1.x = 6;
  i1.y = 14;
  Interval i2 = GetMax<Interval>(i0,i1);
  cout << i2.x << endl;
  return 0;
}
// The output is 6

* Can you change the behavior of GetMax, but only for Interval?

#include <iostream>
using namespace std;
struct Interval {
  int x, y;
};
template <class T> T GetMax (T a, T b) {
  return (a>b?a:b);
}
template <> Interval GetMax<Interval> (Interval a, Interval b) {
  Interval i;
  i.x = a.x > b.x ? a.x : b.x;
  i.y = a.y > b.y ? a.y : b.y;
  return i;
}
int main () {
  Interval i0, i1;
  i0.x = 1;
  i0.y = 10;
  i1.x = 2;
  i1.y = 4;
  Interval i2 = GetMax<Interval>(i0,i1);
  cout << i2.x << endl;
  return 0;
}

* Take a look into the class below. Are all the generic elements "Types"?

// sequence template
#include <iostream>
using namespace std;
template <class T, int N> class BoundedArray {
    T memblock [N];
  public:
    void set (int x, T value);
    T get (int x);
};
template <class T, int N> void BoundedArray<T,N>::set (int x, T value) {
  memblock[x]=value;
}
template <class T, int N> T BoundedArray<T,N>::get (int x) {
  return memblock[x];
}
int main () {
  BoundedArray <int,5> myints;
  BoundedArray <double,5> myfloats;
  myints.set (0,100);
  myfloats.set (3,3.1416);
  cout << myints.get(0) << '\n';
  cout << myfloats.get(3) << '\n';
  return 0;
}

* Can you modify the class above to avoid accessing the array outside bounds?

// sequence template
#include <iostream>
#include <assert.h>
using namespace std;
template <class T, int N>
class BoundedArray {
    T memblock [N];
  public:
    void set (int x, T value);
    T get (int x);
};
template <class T, int N> void BoundedArray<T,N>::set (int x, T value) {
  assert(x >= 0 && x < N);
  memblock[x]=value;
}
template <class T, int N> T BoundedArray<T,N>::get (int x) {
  assert(x >= 0 && x < N);
  return memblock[x];
}

* What happens if I try to access an invalid bound?

int main () {
  BoundedArray <double,5> myfloats;
  myfloats.set (3,3.1416);
  cout << myfloats.get(6) << '\n';
  return 0;
}

* Can we write a program like this?

int main (int argc, char** argv) {
  BoundedArray <int,argc> myints;
  myints.set (0,100);
  cout << myints.get(0) << '\n';
  return 0;
}

* What is the problem with the program above?

* Can we separate a template into header and implementation modules?
// BoundedArray.h:
#ifndef BOUNDED_ARRAY_H
#define BOUNDED_ARRAY_H
template <class T, int N> class BoundedArray {
    T memblock [N];
  public:
    void set (int x, T value);
    T get (int x);
};
#endif
// BoundedArrayMain.cpp:
#include <iostream>
#include <assert.h>
#include "BoundedArray.h"
template <class T, int N> void BoundedArray<T,N>::set (int x, T value) {
  assert(x >= 0 && x < N);
  memblock[x]=value;
}
template <class T, int N> T BoundedArray<T,N>::get (int x) {
  assert(x >= 0 && x < N);
  return memblock[x];
}
#include <assert.h>
// BoundedArrayMain.cpp:
using namespace std;
#include "BoundedArray.h"
int main () {
  BoundedArray <int,5> myints;
  BoundedArray <double,5> myfloats;
  myints.set (0,100);
  myfloats.set (3,3.1416);
  cout << myints.get(0) << '\n';
  cout << myfloats.get(6) << '\n';
  return 0;
}

* Why the program above will not compile?

* Can you still separate the header file?

// BoundedArray.h:
#ifndef BOUNDED_ARRAY_H
#define BOUNDED_ARRAY_H
template <class T, int N> class BoundedArray {
    T memblock [N];
  public:
    void set (int x, T value);
    T get (int x);
};
#endif
// BoundedArray3.cpp
#include <iostream>
#include <assert.h>
#include "BoundedArray.h"
using namespace std;
template <class T, int N> void BoundedArray<T,N>::set (int x, T value) {
  assert(x >= 0 && x < N);
  memblock[x]=value;
}
template <class T, int N> T BoundedArray<T,N>::get (int x) {
  assert(x >= 0 && x < N);
  return memblock[x];
}
int main () {
  BoundedArray <int,5> myints;
  BoundedArray <double,5> myfloats;
  myints.set (0,100);
  myfloats.set (3,3.1416);
  cout << myints.get(0) << '\n';
  cout << myfloats.get(6) << '\n';
  return 0;
}

* Why is this type of polymorphism called "Parametric Polimorphism"?

// The type constructor:
template <class T, int N>