COMP6771 Week 7.1

Templates, Part 2

Inclusion compilation model

  • What is wrong with this?
  • g++ min.cpp main.cpp -o main
template <typename T>
T min(T a, T b);
template <typename T>
T min(T a, T b) {
  return a < b ? a : b;
}
#include <iostream>

int main() {
  std::cout << min(1, 2) << "\n";
}

min.h

min.cpp

main.cpp

Inclusion compilation model

  • When it comes to templates, we include definitions (i.e. implementation) in the .h file
    • This is because template definitions need to be known at compile time (template definitions can't be instantiated at link time because that would require an instantiation for all types)
  • Will expose implementation details in the .h file
  • Can cause slowdown in compilation as every file using min.h will have to instantiate the template, then it's up the linker to ensure there is only 1 instantiation.
template <typename T>
T min(T a, T b) {
  return a < b ? a : b;
}
#include <iostream>

int main() {
  std::cout << min(1, 2) << "\n";
}

min.h

main.cpp

Inclusion Compilation Model

  • Alternative: Explicit instantiations
  • Generally a bad idea
template <typename T>
T min(T a, T b);
template <typename T>
T min(T a, T b) {
  return a < b ? a : b;
}

template int min<int>(int, int);
template double min<double>(double, double);
#include <iostream>

int main() {
  std::cout << min(1, 2) << "\n";
  std::cout << min(1.0, 2.0) << "\n";
}

min.h

min.cpp

main.cpp

Inclusion Compilation Model

  • Exact same principles will apply for classes
  • Implementations must be in header file, and compiler should only behave as if one Stack<int> was instantiated
#include <vector>

template <typename T>
class Stack {
 public:
  Stack() {}
  void pop();
  void push(const T& i);
 private:
  std::vector<T> items_;
}

#include "stack.tpp"
template <typename T>
void Stack<T>::pop() {
  items_.pop_back();
}

template <typename T>
void Stack<T>::push(const T& i) {
  items_.push_back(i);
}
int main() {
  Stack<int> s;
}

Stack.h

Stack.tpp

main.cpp

Inclusion Compilation Model

  • Lazy instantiation: Only members functions that are called are instantiated
    • In this case, pop() will not be instantiated
#include <vector>

template <typename T>
class Stack {
 public:
  Stack() {}
  void pop();
  void push(const T& i);
 private:
  std::vector<T> items_;
}

#include "stack.tpp"
template <typename T>
void Stack<T>::pop() {
  items_.pop_back();
}

template <typename T>
void Stack<T>::push(const T& i) {
  items_.push_back(i);
}
int main() {
  Stack<int> s;
  s.push(5);
}

Stack.h

Stack.tpp

main.cpp

Static Members

  • Each template instantiation has it's own set of static members
#include <vector>

template <typename T>
class Stack {
 public:
  Stack();
  ~Stack();
  void push(T&);
  void pop();
  T& top();
  const T& top() const;
  static int numStacks_;
 private:
  std::vector<T> stack_;
};

template <typename T>
int Stack<T>::numStacks_ = 0;

template <typename T>
Stack<T>::Stack() { numStacks_++; }

template <typename T>
Stack<T>:: ~Stack() { numStacks_--; }
#include <iostream>

#include "lectures/week7/stack.h"

int main() {
  Stack<float> fs;
  Stack<int> is1, is2, is3;
  std::cout << Stack<float>::numStacks_ << "\n";
  std::cout << Stack<int>::numStacks_ << "\n";
}

Friends

  • Each stack instantiation has one unique instantiation of the friend
#include <vector>

template <typename T>
class Stack {
 public:
  Stack();
  ~Stack();
  void push(T&);
  void pop();
  friend std::ostream& operator<<(std::ostream& os, const Stack& s);
 private:
  std::vector<T> stack_;
};

template <typename T>
void push(T& t) { 
  stack_.push_back(t);
}

template <typename T>
std::ostream& operator<<(std::ostream& os, const Stack<T>& s) {
  std::cout << "My top item is " << s.stack_.back() << \n";
}
#include <iostream>
#include <string>

#include "lectures/week7/stack.h"

int main() {
  Stack<std::string> ss;
  ss.push("Hello");
  std::cout << ss << "\n":

  Stack<int> is;
  is.push(5);
  std::cout << is << "\n":
}

Default Members

  • We can provide default arguments to template types (where the defaults themselves are types)
  • It means we have to update all of our template parameter lists
#include <vector>

template <typename T, typename CONT = std::vector<T>>
class Stack {
 public:
  Stack();
  ~Stack();
  void push(T&);
  void pop();
  T& top();
  const T& top() const;
  static int numStacks_;
 private:
  CONT stack_;
};

template <typename T, typename CONT>
int Stack<T, CONT>::numStacks_ = 0;

template <typename T, typename CONT>
Stack<T, CONT>::Stack() { numStacks_++; }

template <typename T, typename CONT>
Stack<T, CONT>:: ~Stack() { numStacks_--; }
#include <iostream>

#include "lectures/week7/stack.h"

int main() {
  Stack<float> fs;
  Stack<int> is1, is2, is3;
  std::cout << Stack<float>::numStacks_ << "\n";
  std::cout << Stack<int>::numStacks_ << "\n";
}

COMP6771 19T2 - 7.1 - Templates Part 2

By cs6771

COMP6771 19T2 - 7.1 - Templates Part 2

  • 665
Loading comments...

More from cs6771