Scribd
Upload
308 views

Template Metaprogramming

This document introduces template metaprogramming in C++, which allows generating customized C++ code at compile-time using templates. It provides an example of implementing a vector class with customizable policies for features like error handling and locking via template parameters. Template metaprogramming enables avoiding a combinatorial explosion of implementations by encapsulating behaviors in policy classes specified independently of the vector class itself.

Uploaded by

Jessica Henderson
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
308 views

Template Metaprogramming

This document introduces template metaprogramming in C++, which allows generating customized C++ code at compile-time using templates. It provides an example of implementing a vector class with customizable policies for features like error handling and locking via template parameters. Template metaprogramming enables avoiding a combinatorial explosion of implementations by encapsulating behaviors in policy classes specified independently of the vector class itself.

Uploaded by

Jessica Henderson
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 32

C++ Template Metaprogramming in 15ish Minutes

C++ Template Metaprogramming in 15ish Minutes

A program is a sequence of instructions


which creates and modifies data.

A metaprogram is a sequence of instructions


which creates and modifies programs.

Why would you ever want to do this?

C++

Assembly

Machine Code

Metaprogramming introduces
new abstractions into the host language.

So what exactly is
template metaprogramming?

How C++ Templates Work


C++
Source
Code

Template
Compiler

This is a
metaprogramming step!

C++ Compiler

Machine
Code

A template metaprogram is a C++ program that


uses templates to generate customized C++ code
at compile-time.

A new abstraction: policies.

template <typename T> class Vector


{
public:
T getAt(int index);
void setAt(int index, T value);
};

/* ... etc. ... */

Vector
Range Checking
Type T
Synchronization

Templates are parameterized over types, not


behaviors.

A policy class is a type that implements a


particular behavior.

template <typename T>


class Vector
{
public:
T getAt(int index);
void setAt(int index, T value);
};

/* ... etc. ... */

template <typename T,
typename RangePolicy,
typename LockingPolicy>
class Vector
{
public:
T getAt(int index);
void setAt(int index, T value);
};

/* ... etc. ... */

template <typename T,
typename RangePolicy,
typename LockingPolicy>
class Vector: public RangePolicy,
public LockingPolicy
{
public:
T getAt(int index);
void setAt(int index, T value);
};

/* ... etc. ... */

Sample Range Policy


class ThrowingErrorPolicy
{
protected:
~ThrowingErrorPolicy() {}

};

static void CheckRange(int pos,


int numElems)
{
if(pos >= numElems)
throw std::out_of_bounds("Bad!");
}

Another Sample Range Policy


class LoggingErrorPolicy
{
public:
void setLogFile(std::string filename);
protected:
~LoggingErrorPolicy();
void CheckRange(int pos,
int numElems)
{
if(pos >= numElems && output != 0)
*log << "Error!" << std::endl;
}
private:
std::ofstream* log;
};

Another Sample Range Policy


class LoggingErrorPolicy
{
public:
void setLogFile(std::string filename);
protected:
~LoggingErrorPolicy();
void CheckRange(int pos,
int numElems)
{
if(pos >= numElems && output != 0)
*log << "Error!" << std::endl;
}
private:
std::ofstream* log;
};

Implementer Code
template <typename T,
typename RangePolicy,
typename LockingPolicy>
T Vector<T, RangePolicy, LockingPolicy>::
getAt (int position)
{
LockingPolicy::Lock lock;
ErrorPolicy::CheckBounds(position,
this->size);
return this->elems[position];
}

Implementer Code
template <typename T,
typename RangePolicy,
typename LockingPolicy>
T Vector<T, RangePolicy, LockingPolicy>::
getAt (int position)
{
LockingPolicy::Lock lock;
ErrorPolicy::CheckBounds(position,
this->size);
return this->elems[position];
}

Implementer Code
template <typename T,
typename RangePolicy,
typename LockingPolicy>
T Vector<T, RangePolicy, LockingPolicy>::
getAt (int position)
{
LockingPolicy::Lock lock;
RangePolicy::CheckRange(position,
this->size);
return this->elems[position];
}

Client Code
int main()
{
Vector<int, ThrowingErrorPolicy,
NoLockingPolicy> v;
for(size_t k = 0; k < kNumElems; ++k)
v.push_back(k);
/* ... etc. ... */
}

return 0;

Or this...
int main()
{
Vector<int, AssertingErrorPolicy,
PThreadLockingPolicy> v;
for(size_t k = 0; k < kNumElems; ++k)
v.push_back(k);
/* ... etc. ... */
}

return 0;

Or even this...
int main()
{
Vector<int, NoErrorPolicy,
NoLockingPolicy> v;
for(size_t k = 0; k < kNumElems; ++k)
v.push_back(k);
/* ... etc. ... */
}

return 0;

Policy classes beat the combinatorial explosion


of possible implementations.

This is not possible without


template metaprogramming.

But this is just a taste of what's possible


with template metaprogramming.

Template Metaprogramming Does:

Compile-time dimensional analysis.

Multiple dispatch.

Design patterns.

Code optimization.

Lexing and parsing.

And so much more...

Recommended Reading

More template
metaprogramming
than you'll know what
to do with.
Very advanced
material; be prepared
to be overwhelmed!
Considered the
seminal work in
modern C++
programming.

You might also like