templates with strings and auto in c++17 - tum

Technical University of Munich

Faculty of Informatics

Chair for Computer Aided Medical Procedures

Tobias Jülg

Garching, 05. June 2018

Templates with Strings and auto in C++17

Trend:

Shifting calculations towards compile time

• Limited execution time

• constexpr simplified metaprogramming a lot → interesting use cases

• E. g. regex libraries that analyse strings at compile time

→Simplifying syntax for strings and pushing modern concepts like auto to template development

2Tobias Jülg (TUM)

• Motivation

• Short Reminder of Templates

• New C++17 features

− Strings as non-type Template Parameters

− Placeholder Types as Template Parameters

▪ Using auto

▪ Applications

• References

• Exercises

3Tobias Jülg (TUM)

Agenda

• Motivation





▪ Using auto

▪ Applications

• References

• Exercises

4Tobias Jülg (TUM)

Agenda

• Type Templates

→ Compiler generates code with the replaced types

template <typename T> // T as typevariable

void Print(T p) {

std::cout << p << std::endl;

}

Print(0.5f); // T is deduced to float

• Non-Type Templates

→ Compiler generates code with the replaced values instead of types

→ Example: std::array

template<typename T, std::size_t N>

class Array {

T m_Array[N];

};

Array<int, 10> a;

5Tobias Jülg (TUM)

Short Reminder of Templates

• Values must be constant expressions

• Allowed types:

− const integral values, also enums

− pointers to objects/functions/members

− lvalue references to objects, functions or std::nullptr_t

• Implicit value deduction:

template<std::size_t N>

std::size_t GetSize(const int(&arr)[N]) {

return N;

}

int arr[10];

std::size_t n = GetSize(arr); //n will be 10

6Tobias Jülg (TUM)

Non-Type Templates

→ Advantages compared to passing• Values are known at compile time

• Compile time analysis, faster

• Motivation





▪ Using auto

▪ Applications

• References

• Exercises

7Tobias Jülg (TUM)

Agenda

• Properties of Variables

− Linkage: internal, external or non at all

− Scope: global or local scope (heap or stack)

− Duration: static or temporary duration

• When using strings as arguments− Linkage is always required

− You can’t pass string literals directly, instead const char*

− Rules for relaxed over time

• Situation before C++17− C++98 pointer parameters work only with external linkage

− C++11 internal linkage possible but only global scope

8Tobias Jülg (TUM)

Strings as Non-Type Template Parameters

In C++17

→Using pointers, defined in the current scope possible when declared static

→Still two lines of code but doesn’t pollute the global namespace

→Easier to use C-Strings

→Upcoming use cases: Compile-time JSON and regular expression parsing

template<const char *str>

class regex_parser { };

extern const char hello[] = "[a-zA-Z]*"; //external linkage

const char hello11[] = "C++11 [a-zA-Z]*"; //internal linkage

void foo() {

regex_parser<hello> msg; //okay for all C++ versions

regex_parser<hello11> msg11; //okay since C++11

static const char hello17[] = "C++17 [a-zA-Z]*"; //static declaration

regex_parser<hello17> msg17; //okay since C++17

}

9Tobias Jülg (TUM)

Strings as Non-Type Template Parameters

Before C++17

• You could pass a normal pointer to a

class template

• Compile-time functions returning the

address weren’t possible

• Except functions returning a nullptr

• Implementation only to evaluate the

return type

→ In C++17 by allowing static pointers this

inconsistency was fixed

10Tobias Jülg (TUM)

Pointers returned by Functions

template<int *p> struct A {};int n;A<&n> a; // OK

constexpr int *q() { return nullptr; }A<q()> c; // OK before C++17 because it

// returns a nullptr

constexpr int *p() { return &n; }A<p()> b; // error before C++17, now OK

• Motivation





▪ Using auto

▪ Applications

• References

• Exercises


Agenda

Before C++17, when you didn't want to write a explicit type for a non-type template

// I don't want to be specified on int here

template<int N> struct S { };

the following workaround was possible. Be x of any type:

template <typename T, T N> struct S { }; // definition

template<typename T> void foo(T x) {

S<decltype(x), x> s; // instantiation, x is of any type

}

• Type of x isn’t needed but has to be passed

→ redundancy

• Can get more complicated when passing function without fixed type

→ variadic functions


Placeholder Types as Template Parameters

• Motivation





▪ Using of auto

▪ Applications

• References

• Exercises


Agenda

• Like you use it in lambdas you can also use it with templates now

• In C++ 17 the auto keyword was introduced for non-typed templates

• → known as template <auto>

• → You don’t have to mind the types and let the compiler deduce it

• → Extremely useful for passing a function pointer with non-fixed types

Way to do the previous example in C++17:

template<auto N> struct S { };

S<42> s1; // OK type N is int

S<'a'> s2; // OK type N is char

S<2.5> s3; // Error

→ Can only deduce allowed types for templates


Using auto as Template Parameter

• You can also qualify auto like you do when using it with normal variables, for example to

require a pointer:

template<const auto* p>struct S { };

• Partial specialization

template<int M, int E> struct S { /*do some recursion*/ };

template<int M> struct S<M, 0> {

// end recursion when E is 0 --> different implementation

};

→ Also works for the auto types, for example for int

template<auto N> struct S { };

template<int N> struct S<N> {

// specialized implementation when N is of type int

};


Further features

• Even class template argument deduction is supported

template<typename T, auto N> struct A {

A(const std::array<T, N>&) { }

};

std::array<double, 10> sa1;

A a1{sa1}; // OK

→ Compiler deduces the types T being double and N being std::size_t without specifying it


Further features

• Motivation





▪ Using of auto

▪ Applications

• References

• Exercises


Agenda

auto allows to pass both a character or a c-string as template parameter

→ create a print function that accepts any number of parameters and make the separator

type independent:

template<auto Sep = ' ', typename First, typename... Args>

void print(const First& first, const Args&... args) {

std::cout << first;

auto outWithSpace = [](const auto& arg) {

std::cout << Sep << arg;

};

(..., outWithSpace(args));

std::cout << '\n’;

}


Application: Parameterizing Templates

auto allows to pass both a character or a c-string as template parameter

→ create a print function that accepts any number of parameters and make the separator

type independent:template<auto Sep = ' ', typename First, typename... Args>

void print(const First& first, const Args&... args) {

std::cout << first;

auto outWithSpace = [](const auto& arg) {

std::cout << Sep << arg;

};

(..., outWithSpace(args));

std::cout << '\n’;

}

Pass the default Argument for the first template:std::string s{ "world" };

print(7.5, "hello", s); // prints: 7.5 hello world

Pass a string literal as separator:static const char sep[] = ", ";

print<sep>(7.5, "hello", s); // prints: 7.5, hello, world


Application: Parameterizing Templates

→ Basically any type that can

be used as template

parameter

→ Runtime improvement for

logger functions

• Metaprogramming constants also needed to pass the type

• auto improves the instantiation process of these constants:

→ Like auto with normal variables you don’t need to pass the type


Application: Defining Metaprogramming Constants

template<auto v>struct constant{

static constexpr auto value = v;};using i = constant<42>;

template<typename T, T v>struct constant{

static constexpr T value = v;};using i = constant<int, 42>;

And when using a sequence with variadic template syntax instead of

template<typename T, T... Elements>

struct sequence {};

using indexes = sequence<int, 0, 3, 4>;

There are new possibilities to parameterize a list of constant template arguments:

• At least one argument and all having the same type:

template<auto V1, decltype(V1)... VS> struct HomoValueSequence {};

• Even compile-time objects representing a heterogeneous list of values like a tuple:

template<auto... VS> struct HeteroValueSequence {};

using tuple = HeteroValueSequence<0, 'h', true>;


Application: Defining Metaprogramming Constants

template<typename T, T... Elements> class Foo0 {};

template<auto... VS> class Foo1 { };

template<auto V1, decltype(V1)... VS> class Foo2 { };

Foo0<1, 'a', true> vals1;

Foo0<int, 1, 2, 3> vals2;

Foo0<> vals3;

Foo1<1, 2, 3> vals4;


Foo1<> vals6;

Foo2<> vals7;


Foo2<1, 2, 3> vals9;


Which lines won’t compile?

• Nicolai Josuttis, C++17 - The Complete Guide, ch. 12, 13, leanpub, 02.2017

• Louis Dionne, http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0424r2.pdf,

visited May 2018

• Louis Dionne, https://ldionne.com/2015/11/29/efficient-parameter-pack-indexing/ visited

May 2018

• Richard Smith, http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4268.html

visited May 2018

• James Touton, http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0127r1.html

visited May 2018


References

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0424r2.pdf

https://ldionne.com/2015/11/29/efficient-parameter-pack-indexing/

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4268.html

http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0127r1.html

templates with strings and auto in c++17 - tum

Documents