Parametric Polymorphism (Genericity, C++ Templates)

Question 1

What’s parametric polymorphism?

Answer 1

Allows definitions to be parametrized at compile-time
- Such a definition is actually a “compile-time function” that returns a new program element (method, class, etc.)

Template parameters =
The “function”’s arguments
Instantiation of a template =
evaluating the “function”

Question 2

What are the steps in the instantiation process of a template?

Answer 2

1. Substitutes formal with actual template parameters
2. Generates new object (.o/.obj) code
3. A single (observable) instantiation per type unit. i.e Test instantiated at most 1 time.

Question 3

When does the compilation of a template occurs?

Answer 3

• Partial compilation when the definition is read
  Validation of non template related code
• Full compilation work done upon instantiation

Question 4

Does the template definition must be in the source code?

Answer 4

yes. the template definition must be reachable by includes from the instantiation point.

Question 5

Can a function be both virtual and templated?

Answer 5

No. if it was possible we would have problems, for example:

struct Base {
template
virtual void f(T) { … }
};

Base is compiled once as it is not templated, but how many entries should it’s vtable hold?
we don’t know, because f is different then f and from f…

Question 6

Is it possible to have a template argument which is not known at compile-time?

Answer 6

No. all parameters have to be known at compile-time.

Question 7

Why the following initialization works?

template
class Array {
size_t n; Type* buff;
public:
Array(size_t n_) : n(n_), buff(new Type[n]) {
if (buff == NULL) error(“Memory failure”);
}

Answer 7

because n is defined before buff. not because of the initialization list order, if we change definitions order it will fail.

Question 8

Can string or double appear as template arguments?

Answer 8

no.

Question 9

What is template specialization?

Answer 9

Having a specific case for the templated class that is defined differently. 
example:

template
struct Pair {
  // T a, b; set; print; ...
};

template<>
struct Pair { … }