Modern and Lucid C++ Advanced for Professional Programmers. Part 7 Compile-Time Computation. Department I - C Plus Plus

Size: px

Start display at page:

Download "Modern and Lucid C++ Advanced for Professional Programmers. Part 7 Compile-Time Computation. Department I - C Plus Plus"

Scot Cox
5 years ago
Views:

1 Department I - C Plus Plus Modern and Lucid C++ Advanced for Professional Programmers Part 7 Compile-Time Computation Thomas Corbat / Prof. Peter Sommerlad Rapperswil, HS2017

2 Topics 2 SFINAE Compile-Time Computation (Legacy) User-Defined Literals C++14 Features (If there is time)

3 SFINAE

4 Overload Selection 4 What do you expect is the return value of the program on the right? None, the program does not compile! Name increment is looked up increment(unsinged) increment Template Template arguments are deduced unsigned increment(unsigned i) { return i++; template<typename T> T increment(t value) { return value.increment(); int main() { return increment(42); increment(unsigned) increment<int>(int) Best overload is selected error: request for member 'increment' in 'value', which is of non-class type 'int' increment(int)

5 Substitution Failure Is Not An Error 5 During overload resolution the template parameters in a template declaration are substituted with the deduced types This may result in template instances that cannot be compiled Or otherwise suboptimal selection If the substitution of template parameter fails that overload candidate is discarded Substitution failure might happen in Function return type Function parameter Substitution Template parameter declaration And expressions in the above Errors in the instance body are still errors Substitution template<typename T> T increment(t value) { return value.increment(); int increment(int value) { return value.increment(); //T = int Substitution

6 Possible Solution (Not Recommended) 6 We can break the return type template<typename T> auto increment(t value) -> decltype(value.increment()) { return value.increment(); If we tell the compiler to use the type of value.increment() as return type for increment<int> That type cannot be determined during substitution error: no matching function for call to 'increment(int)' increment(42); ^ note: candidate: template<class T> decltype (value.increment()) increment(t) auto increment(t value) -> decltype(value.increment()) { ^~~~~~~~~ note: template argument deduction/substitution failed: In substitution of 'template<class T> decltype (value.increment()) increment(t) [with T = int]': error: request for member 'increment' in 'value', which is of non-class type 'int' auto increment(t value) -> decltype(value.increment()) {

7 Overload Selection with SFINAE 7 7 Since there is a problem during substitution that overload is discarded Name increment is looked up increment(unsinged) Template arguments are deduced increment(unsigned) increment Template increment<int>(int) unsigned increment(unsigned i) { return i++; template<typename T> auto increment(t value) -> decltype(value.increment()) { return value.increment(); int main() { return increment(42); Now the result is 42 Best overload is selected increment(unsigned) This approach, using decltype(...) as trailing return type, is infeasible in general Function might have return type void It is not elegant for complex bodies

8 std::is_class Let's examine our example again 8 <type_traits> We want the increment template to be selected only for class type arguments There exists a template std::is_class<t> contains static constexpr bool value; value is true if T is a class, false otherwise template<typename T> T increment(t value) { return value.increment(); int main() { return increment(42); In C++17 we will have std::is_class_v<t> A variable template of type bool (direct ::value) Can we apply this to the increment template directly? No, either value (true or false) is still valid We need something to create an error in the type of the function #include <type_traits> struct S {; int main() { std::is_class<s>::value; //true std::is_class<int>::value; //false

9 std::enable_if / std::enable_if_t template<bool expr, typename T = void> struct enable_if; 9 <type_traits> The std::enable_if_t template takes an expression and a type If the expression evaluates to true std::enable_if_t represents the given type Otherwise it does NOT represent a type int main() { std::enable_if_t<true, int> i; //int std::enable_if_t<false, int> error; //no type Inside std::enable_if template<bool expr, typename T = void> struct enable_if {; template<typename T> struct enable_if<true, T> { using type = T; ; template<bool expr, typename T = void> using enable_if_t = typename enable_if<expr, T>::type;

10 std::enable_if Applied 10 template<typename T, > T increment( T value) { return value.increment(); Spots to apply enable_if (SFINAE) Possibilities template<typename T> std::enable_if_t<std::is_class<t>::value, T> increment(t value) { return value.increment(); template<typename T> T increment(std::enable_if_t<std::is_class<t>::value, T> value) { return value.increment(); enable_if as parameter impairs type deduction template<typename T, typename = std::enable_if_t<std::is_class<t>::value, void>> T increment(t value) { return value.increment(); would be void per default

11 Compile-Time Computation

12 C++14 Compile-Time Computation 12 ROMable data (guaranteed!) Plain C++ Simpler than in C++03 Not yet everything possible provided Standard library not made up for everything desirable Compile times can increase horrendously Example that is supposed to take 24h to be compiled

13 C++03 Basic Features 13 (static) const variables in namespace scope of built-in types initialized with constant expression are usually put into ROMable memory, if at all. Allowed in constant expression context No complicated computations (except with macros) No guarantee to be done at compile-time in all cases size_t const SZ = 6 * 7; double x[sz]; Constant expression context Compile-time evaluation

14 C++03 Compile-Time Computation 14 template <size_t n> struct fact { static size_t const value{(n > 1)? n * fact<n-1>::value : 1; ; template <> struct fact<0> { // recursion base case: template specialization static size_t const value = 1; ; int a[fact<5>::value]; // check compile-time constant void testfactorialcompiletime() { ASSERT_EQUAL(sizeof(a), sizeof(int) * 2 * 3 * 4 * 5); "Integer" only (almost) through non-type template parameters Would need out-of-class static member variable definition for ODR-use at run-time or C++11 constexpr

15 C++03 Compile-Time Computation 15 Templates allow Turing-complete computation But it looks ugly and can be hard to understand Compiler error-messages can be lengthy Compile-time long and recursion depth limited (depends on the compiler and its settings) Almost only single values can be computed Arrays/structs possible, but ugly Observation: static const member variables of class templates are variables that depend on template parameters

16 C++11 Feature: constexpr Variables and static_assert() 16 constexpr size_t SZ{7 * 3 * (1 + 1); constexpr double x[sz] {1, 2, 3, 4, 5, 6, 7, 8, ; Constexpr variable: Guaranteed compile-time evaluation Can be used in constant expression contexts static_assert checked at compile-time (static) Syntax: static_assert(cond, message); //in C++17 message will be optional static_assert(sizeof(x) == 42 * sizeof(double), "size of array x unexpected"); static_assert(x[3] + x[4] == 9, "expect x initialized at compile-time"); void testsizeofandinitofx() { ASSERT_EQUAL(42 * sizeof(double), sizeof(x)); double const *px = x; // take address to make sure it exists in memory ASSERT_EQUAL(1, *px); // access first element

17 C++11 Compile-Time Computation 17 constexpr unsigned long long fact(unsigned short n) { return n > 1? n * fact(n - 1) : 1; int a[fact(5)]; void testfactorialcompiletime() { ASSERT_EQUAL(sizeof(int) * 2 * 3 * 4 * 5, sizeof(a)); Only 1 statement and recursion allowed in constexpr functions Overflow is a compile-error No local variables, but any "literal" type Simpler syntax than C++03 templates but not much more expressive, except for doubles

18 C++11 Compile-Time Computation 18 constexpr double factd(unsigned short n) { return n > 1? n * factd(n - 1) : 1; constexpr auto fac5 = factd(5); static_assert(120 == fac5, "see if doubles compare equal"); void testfactdouble(){ int i = 3 + fact(2); ASSERT_EQUAL(120.0, factd(i)); Can compute with floating point values at compile-time, but only single statement (return statement) in constexpr function Constexpr function: If used in constexpr context, guaranteed compile-time evaluation, otherwise run-time evaluation is possible Thus you can call constexpr functions from contexts where its arguments are not compile-time constant

19 C++11 Allows Generic constexpr 19 template <typename T> constexpr T abs(t x){ return x < 0? - x : x; static_assert(5 == abs(-5), "abs is correct for negative int"); static_assert(5 == abs(5), "abs is correct for int"); static_assert(5.0 == abs(-5.0), "abs is correct for negative double"); static_assert(5.0l == abs(-5.0l), "abs is correct for negative long double"); Return type must be specified, but it can be duduced It is better to use the abs (C++) function than a macro, as it is type-safe Also works at compile-time, which can be prooven by the static_asserts Single return statement restriction in C++11

Reminder: Functions, Temlpates and Patterns 20 Function overload resolution Pattern matching through call arguments Function template Template

20 Reminder: Functions, Temlpates and Patterns 20 Function overload resolution Pattern matching through call arguments Function template Template argument deduction from call arguments Class template: Implementation selection through (partial) specialization Pattern matching through template arguments

21 C++11 Literal Types 21 Trivial Types Built-in types, arrays of trivial types, structs of trivial types Without initializers, special member functions defined or virtual members with only trivial bases Literal Types: like Trivial structs/classes + constexpr constructor/initialization and trivial destructor (not user defined!) Literal Types can be used in constexpr functions, but only constexpr member functions can be called on values of literal type POD + constexpr constructor + trivial destructor + constexpr member functions

22 C++11 Standard Mistake: Literal Types 22 C++11 defined constexpr member functions to be implicitly const That turned out to be a problem with C++14! Incompatible change with C++14 (a quick fix) If a constexpr member function (in a literal type) is const, you need to specify it. Quiz: Does it make sense to have non-const constexpr member functions?

23 User-Defined Literals

24 Motivation for UDL 24 Type for velocity struct speed { /*constexpr?*/ /*explicit?*/ speed(long double kmh) : kmh { kmh { long double const kmh; ; Can be used in Example speed s {5.0; speed s = 5.0; auto s = 5.0; auto s = speed{5.0 Valid Yes Non-explicit Not a speed object Yes

25 Drawback of speed 25 Repetitive occurrence of explicit conversion speed{x What if we would like to have different units? e.g. mph? constexpr double MPH_TO_KMH { ; auto s_mph = speed{5.0 * MPH_TO_KMH; Alternative: User-defined literals auto s_kmh = 5.0_kmh; auto s_mph = 5.0_mph;

26 User-Defined Literals 26 Problem: Constants lack a dimension Can result in hard to detect bugs Overloading operator"" _UDLSuffix() UDLSuffix could lexically be any identifier, but must start with underscore _ (other suffixes are reserved for the standard) Allows to add dimension, conversion, etc. If possible define UDL operator functions as constexpr Add the suffix to integer, float and string literals Suffix belongs to literal (no whitespace between) 5.0_kmh; //correct 5.0 _mph; //wrong Rule: put overloaded UDL operators that belong together in a separate namespace Only a using namespace can import them

27 User-Defined Literals for speed 27 namespace velocity { constexpr double MPH_TO_KMH { ; struct speed { constexpr explicit speed(long double kmh) : kmh { kmh { long double const kmh; ; constexpr speed operator"" _kmh(long double kmh) { return speed{kmh; constexpr speed operator"" _mph(long double mph) { return speed{mph * MPH_TO_KMH;

28 User-Defined Literals for speed 28 using namespace velocity; void test_mph_operator() { ASSERT_EQUAL_DELTA(8.05_kmh, 5.0_mph, 0.01_kmh); Shorter and more expressive literals Beware: The ASSERT_EQUAL_DELTA macro above needs a bit more functionality in speed: operator long double() const;

29 User-Defined Literal Signatures (1/4) 29 For literal numbers the following signatures are useful Integral constants TYPE operator "" _suffix(unsigned long long) Example constexpr speed operator"" _kmh(unsigned long long kmh) { return speed{static_cast<long double>(kmh); auto s_kmh = 5_kmh; Floating point constants TYPE operator "" _suffix(long double)

30 User-Defined Literal Signatures (2/4) 30 For string literals the following signature is useful TYPE operator "" _suffix(char const *, std::size_t len) namespace mystring { std::string operator"" _s(char const *s, std::size_t len) { return std::string { s, len ; Note: Implementation above cannot be constexpr. Why? Example: using namespace mystring; auto s = "hello"_s; s += " world\n"; std::cout << s;

31 User-Defined Literal Signatures (3/4) 31 RAW UDL Operator TYPE operator "" _suffix(char const *) namespace mystring { std::string operator"" _s(char const *s) { return std::string { s ; Note: Works only for integral and floating literals, not for string literals! Example: using namespace mystring; auto rs = 42_s; rs += " raw\n"; std::cout << rs;

32 Raw UDL Operator Applied 32 Ternary suffix Base 3 Examples Ternary Decimal namespace ternary { unsigned long long operator"" _3(char const *s) { size_t convertedupto{; auto res = std::stoull(s, &convertedupto, 3u); if (convertedupto!= strlen(s)) throw std::logic_error { "invalid ternary" ; return res; using namespace ternary; int four = 11_3; std::cout << "four is " << four << '\n'; try { four = 14_3; // throws catch (std::exception const &e) { std::cout << e.what() << '\n'; Problem: exception at run-time

33 User-Defined Literal Signatures (4/4) 33 Template UDL Operator template<char...> TYPE operator "" _suffix() Empty parameter list Variadic template parameter Characters of the literal are template arguments 120_ternary; // => operator "" _ternary() // with template arguments '1', '2' and '0' Unfortunately, the template UDL operator does not work with string literals

34 Raw UDL Extreme: Ternary Number at Compile-Time (1/3) 34 Run-time errors for number conversion is bad There exists a variadic template version of UDL operators Interpretation of the characters (at compile-time) often requires a variadic class/variable template with specializations template<char...digits> constexpr unsigned long long operator"" _ternary() { return _impl::ternary_value<digits...>; We will also need a helper function to get the value of the digit: 3 n constexpr unsigned long long three_to(std::size_t power) { return power? 3ull * three_to(power - 1) : 1ull;

35 Raw UDL Extreme: Ternary Number at Compile-Time (2/3) 35 template<char...digits> extern unsigned long long ternary_value; template<char...digits> constexpr unsigned long long ternary_value<'0', Digits...> { ternary_value<digits...> ; template<char...digits> constexpr unsigned long long ternary_value<'1', Digits...> { 1 * three_to(sizeof...(digits)) + ternary_value<digits...> ; template<char...digits> constexpr unsigned long long ternary_value<'2', Digits...> { 2 * three_to(sizeof...(digits)) + ternary_value<digits...> ; template<> constexpr unsigned long long ternary_value<>{0;

36 Raw UDL Extreme: Ternary Number at Compile-Time (3/3) Slide not found! No slide "Raw UDL Extreme: Ternary Number at Compile-Time (3/3)" needed There used to be three with C++11 before variable templates now it is only two The class templates containing the value looked as follows (specialization for '0') template<char...digits> //Case for '0' struct parse_ternary<'0', Digits...> { static unsigned long long const value { parse_ternary<digits...>::value ; ;

..> Value: 1 * 3 2 + ternary_value<'2', '0'> Partial specialization: ternary_value<'2', Digits.

37 Ternary Number Compile-Time Steps 37 Example: 120_ternary 120_ternary -> resolves to ternary_value<'1', '2', '0'> Partial specialization: ternary_value<'1', Digits...> Value: 1 * ternary_value<'2', '0'> Partial specialization: ternary_value<'2', Digits...> Value: 2 * ternary_value<'0'> Partial specialization: ternary_value<'0', Digits...> Value: ternary_value<> Partial specialization: parse_ternary<> Value: 0 Value: 0 Value: 6 from 2 * Value: 15 from 1 *

38 Ternary Number Compile-Time Restrictions 38 Can we avoid the duplication of the specialization for '0', '1' and '2'? constexpr bool is_ternary_digit(char c) { return c == '0' c == '1' c == '2'; constexpr unsigned value_of(char c) { return c - '0'; template<char D, char...digits> constexpr std::enable_if_t<is_ternary_digit(d), unsigned long long> ternary_value<d, Digits...> { value_of(d) * three_to(sizeof...(digits)) + ternary_value<digits...> ;

39 Ternary Number: static_assert 39 The declaration of value is barely readable; let s try static_assert static_assert(cond, msg); It is a declaration itself and thus cannot be used with variable templates template<char D> constexpr unsigned value_of() { static_assert(is_ternary_digit(d), "Digits of ternary must be 0, 1 or 2"); return D - '0'; template<char D, char...digits> constexpr unsigned long long ternary_value<d, Digits...> { value_of<d>() * three_to(sizeof...(digits)) + ternary_value<digits...> ; Nice error message during compilation static_assert prevents SFINAE

40 Ternary Number: Outlook to C++20 (maybe) 40 Upcomming alternative: Concepts concept keyword Concept name used instead of typename Nice compiler messages template<char D> concept bool TernaryDigit = is_ternary_digit(d); template<ternarydigit D, TernaryDigit...Digits> constexpr unsigned long long ternary_value<d, Digits...> {...;..\main.cpp: In function 'int main(int, char**)':..\main.cpp:40:27: error: cannot call function 'long long unsigned int ternary::operator""_t() [with char...digits = {'1', '4']' std::cout << "14_t: " << 14_t << std::endl; ^~~~..\main.cpp:30:20: note: constraints not satisfied unsigned long long operator "" _t() { ^~~~~~~~..\main.cpp:30:20: note: in the expansion of 'TernaryDigit<Digits>...'..\main.cpp:30:20: note: 'TernaryDigit<'4'>' was not satisfied

41 Standard Literal Suffixes 41 Standard suffixes don t have a leading underscore Suffix for std::string: s Suffix for std::complex (imaginary): i, il, if Suffixes for std::chrono::duration: ns, us, ms, s, min, h More might be defined in the future Is the following example a problem? using namespace std::string_literals; using namespace std::chrono_literals; auto one_s = 1s; auto one_point_zero_s = 1.0s; auto fourty_two_s = "42"s;

42 Summary UDL 42 User-defined Literals can help to get dimensions of constants right as a short-hand for type conversions to implement compile-time constants of literal types obfuscate program code if applied mercilessly If constexpr, user-defined literals are resolved at compile-time No runtime-overhead Don t specify suffixes for all your types now!

Using Enum Structs as Bitfields

New York C++ Developers Group July 12, 2016 Using Enum Structs as Bitfields Presentation by Jon Kalb Based on an article in Overload magazine by Anthony Williams 1 What do these have in common?! explicit