C++ Annotated: March – May 2016--Anastasia Kazakova
An overview of the recent C++ world:
C++ Annotated: March – May 2016
by Anastasia Kazakova
From the article:
In this edition:
- Conferences
- News & Stories
- Webinars
- Releases
News
CppCon 2015 Variadic Templates in C++11 / C++14 - An Introduction--Peter Sommerlad
Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:
Variadic Templates in C++11 / C++14 - An Introduction
by Peter Sommerlad
Summary of the talk:
Writing class templates and functions accepting a variable number of arguments has been a burden before C++11. With variadic templates, both class templates with a variable number of arguments as well as functions can be formulated much easier and more type safe way.
Nevertheless, the authoring of variadic templates can be challenging for the uninitiated. Even the interpretation of variadic template code can be a problem, as Olve Maudal's famous pub quiz shows.
This session will build up understanding and the ability to use and author variadic template functions and variadic template classes from easy examples up to more complicated applications such as employing std::forward correctly, std::integer_sequence and other upcoming language features such as a template UDL operator that bridges the gap between string literals and std::integer_sequence.
Understanding pack expansion, sizeof... and other hard to get on first sight issues are my goal. In the end you should have seen guidelines that help you avoid the template instantiation trap from the pub quiz and correct usage of std::forward in your variadic templates.
C++ User Group Meetings in June
The monthly posting of C++ User Group Meetings at Meeting C++:
C++ User Group Meetings in June 2016
by Jens Weller
There are 6 new User Groups:
Montpellier (Qt), Vienna, Auckland, Irvine (Qt), Oslo (Qt), and Seoul.
CppCast Episode 58: CLion with Anastasia Kazakova
Episode 58 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Anastasia Kazakova to discuss new features of JetBrains' Clion IDE.
CppCast Episode 58: CLion with Anastasia Kazakova
by Rob Irving and Jason Turner
About the interviewee:
A C/C++ fan since university, Anastasia has been creating real-time *nix-based systems and pushing them to production for 8 years. She has a passion for networking algorithms (especially congestion problems and network management protocols) and embedded programming, and believes in good tooling. Now she is a part of the JetBrains team working as a Product Marketing Manager for CLion, a cross-platform C/C++ IDE.
VoidParam Puzzle -- Alex Marmer
Alex Marmer has openend a puzzle.
VoidParam Puzzle
From the article:
How to handle 'void' parameter passed in a macro. He provides a solution as well.
In case that you have other or better solutions, don't hesitate to use the comment option on this site.
Compile Time Constants Part 1: Why We Need Them--Arne Mertz
The title says it all:
Compile Time Constants Part 1: Why We Need Them
by Arne Mertz
From the article:
Compile time constants are an important part of C++. They contribute to program correctness and allow the optimizer to do a better job. Today I will deal with what is possible in terms of compile time constants and compile time calculations in C++03.
Quick Q: If nullptr_t isn't a keyword, why are char16_t and char32_t?
Quick A: To allow overloading with the underlying types of uint_least16_t and uint_least32_t
Recently on SO:
If nullptr_t isn't a keyword, why are char16_t and char32_t?
The proposal itself explains why: to allow overloading with the underlying types of
uint_least16_tanduint_least32_t. If they were typedefed this wouldn't be possible.DefineAs for why they aren't in the std namespace, this is for compatibility with the original C proposal. C++ prohibits the C definitions from appearing in its own version ofchar16_tto be a distinct new type, that has the same size and representation asuint_least16_t. Likewise, definechar32_tto be a distinct new type, that has the same size and representation asuint_least32_t.[N1040 defined
char16_tandchar32_tas typedefs touint_least16_tanduint_least32_t, which make overloading on these characters impossible.]<cuchar>[c.strings] / 3
The headers shall not define the typesThe types then would need to be global typedefs, which carries its own set of issues such aschar16_t,char32_t, andwchar_t(2.11).typedef decltype(u'q') char16_t; namespace foo { typedef int char16_t; }The reason for
std::nullptr_tnot being a keyword can be found in the question you linkedWe do not expect to see much direct use ofmakingnullptr_tin real programs.nullptr_tthe real exception here.
CppCon 2015 Beyond Sanitizers...--Kostya Serebryany
Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:
Beyond Sanitizers...
by Kostya Serebryany
Summary of the talk:
At CppCon’2014 we presented the Sanitizers, a family of dynamic testing tools for C++. These tools allow you to find many stability and security bugs in C++ code, but they are only as good as your tests are. In this talk we will show how to improve your tests with guided fuzzing and how to protect your applications in production even if some bugs were not found. Fuzzing, or fuzz testing, is a surprisingly effective technique that allows you to discover new interesting test inputs. Coverage-guided fuzzing uses coverage-like code instrumentation to make fuzzing orders of magnitude more efficient. Taint-guided fuzzing goes even further by using taint tracking techniques. The next line of defense may be incorporated directly into production: the Control Flow Integrity instrumentation allows you to protect your program from corrupted function pointers (including pointers to virtual tables) and separating stack variables from the call stack protects from corrupted return addresses -- both with near-zero overhead. We will concentrate on particular tools implemented in the opensource LLVM toolchain (libFuzzer, DataFlowSanitizer, -fsanitize=cfi,safe_stack), but will also discuss several alternatives.
C++ for Games: Performance, Allocations and Data Locality -- Sergey Ignatchenko
Well-illustrated, and well-illustrated, gems:
C++ for Games: Performance, Allocations and Data Locality
by Sergey Ignatchenko
From the draft chapter:
One further thing to keep in mind with regards to 90-10 (or 70-30) rule is that even if only performance of 10% of the code matters, the rest of the code can still affect performance of critical 10% in a Pretty Bad Way :-( ...
C++ Performance: Common Wisdoms and Common "Wisdoms" -- Sergey Ignatchenko
Sergey is writing a book and making draft chapters available for review. Here are s
Some tried-and-true, well-illustrated and entertaining tips:
C++ Performance: Common Wisdoms and Common "Wisdoms"
by Sergey Ignatchenko
From the draft chapter intro:
The opposite of a fact is falsehood, but the opposite of one profound truth may very well be another profound truth. — Niels Bohr
There are quite a few common wisdoms when it comes to C++ and games. As it always the case when facing a bunch of common wisdoms, some of them have their merits, some are obsolete-beyond-belief, and some are just taken from a very different context and are not really applicable. Let’s take a look at the most popular ones...