October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By Adrien Hamelin | Apr 23, 2015 09:05 AM | Tags: performance
Want a fast JSON parser? Check out this one…
rapidjson 1.0.0 released
From the article:
This is the final v1.0.0 release of RapidJSON.
After the v1.0-beta, a lot of efforts have been put to make RapidJSON 100% line-of-code covered by the unit tests...
By Adrien Hamelin | Apr 23, 2015 08:49 AM | Tags: performance c++14
A new version of GCC is out, with a lot of improvements:
GCC 5.1 released
Some changes:
C++
- G++ now supports C++14 variable templates.
-Wnon-virtual-dtordoesn't warn anymore for final classes.- Excessive template instantiation depth is now a fatal error. This prevents excessive diagnostics that usually do not help to identify the problem.
- G++ and libstdc++ now implement the feature-testing macros from Feature-testing recommendations for C++.
- G++ now allows
typenamein a template template parameter.template<template<typename> typename X> struct D; // OK
- G++ now supports C++14 aggregates with non-static data member initializers.
struct A { int i, j = i; }; A a = { 42 }; // a.j is also 42
- G++ now supports C++14 extended constexpr.
constexpr int f (int i) { int j = 0; for (; i > 0; --i) ++j; return j; } constexpr int i = f(42); // i is 42
- G++ now supports the C++14 sized deallocation functions.
void operator delete (void *, std::size_t) noexcept; void operator delete[] (void *, std::size_t) noexcept;libstdc++
- A new One Definition Rule violation warning (controlled by -Wodr) detects mismatches in type definitions and virtual table contents during link-time optimization.
- New warnings
-Wsuggest-final-typesand-Wsuggest-final-methodshelp developers to annotate programs with final specifiers (or anonymous namespaces) to improve code generation. These warnings can be used at compile time, but they are more useful in combination with link-time optimization.- G++ no longer supports N3639 variable length arrays, as they were removed from the C++14 working paper prior to ratification. GNU VLAs are still supported, so VLA support is now the same in C++14 mode as in C++98 and C++11 modes.
- G++ now allows passing a non-trivially-copyable class via C varargs, which is conditionally-supported with implementation-defined semantics in the standard. This uses the same calling convention as a normal value parameter.
- G++ now defaults to
-fabi-version=0and-fabi-compat-version=2. So various mangling bugs are fixed, but G++ will still emit aliases with the old, wrong mangling where feasible. -Wabi continues to warn about differences.
- A Dual ABI is provided by the library. A new ABI is enabled by default. The old ABI is still supported and can be used by defining the macro _GLIBCXX_USE_CXX11_ABI to 0 before including any C++ standard library headers.
- A new implementation of
std::stringis enabled by default, using the small string optimization instead of copy-on-write reference counting.- A new implementation of
std::listis enabled by default, with an O(1)size()function;- Full support for C++11, including the following new features:
std::dequeandstd::vector<bool>meet the allocator-aware container requirements;- movable and swappable iostream classes;
- support for std::align and std::aligned_union;
- type traits std::is_trivially_copyable, std::is_trivially_constructible, std::is_trivially_assignable etc.;
- I/O manipulators std::put_time, std::get_time, std::hexfloat and std::defaultfloat;
- generic locale-aware std::isblank;
- locale facets for Unicode conversion;
- atomic operations for std::shared_ptr;
- std::notify_all_at_thread_exit() and functions for making futures ready at thread exit.
- Support for the C++11 hexfloat manipulator changes how the num_put facet formats floating point types when ios_base::fixed|ios_base::scientific is set in a stream's fmtflags. This change affects all language modes, even though the C++98 standard gave no special meaning to that combination of flags. To prevent the use of hexadecimal notation for floating point types use str.unsetf(std::ios_base::floatfield) to clear the relevant bits in str.flags().
- Full experimental support for C++14, including the following new features:
- std::is_final type trait;
- heterogeneous comparison lookup in associative containers.
- global functions cbegin, cend, rbegin, rend, crbegin, and crend for range access to containers, arrays and initializer lists.
- Improved experimental support for the Library Fundamentals TS, including:
- class std::experimental::any;
- function template std::experimental::apply;
- function template std::experimental::sample;
- function template std::experimental::search and related searcher types;
- variable templates for type traits;
- function template std::experimental::not_fn.
- New random number distributions logistic_distribution and uniform_on_sphere_distribution as extensions.
- GDB Xmethods for containers and std::unique_ptr.
By Blog Staff | Apr 23, 2015 08:33 AM | Tags: intermediate
A solid and entertaining treatment with good C++ examples:
Coupling and Cohesion
by Paul Watt
From the middle of the article:
... To further clarify this statement, not all code should be reused.
Why Not?
Because the majority of software that is written is designed to fulfill a very specific purpose. The challenge is to find the balance point between generic reusable building blocks, and a tool or application that meets a need. Generic software components are very valuable, however, they are almost useless by themselves...
And gems like this:
... For every statement of code that you write or use, you should ask the question: Does this add value or risk?
By Adrien Hamelin | Apr 22, 2015 08:00 AM | Tags: intermediate c++14
While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:
Exception-Safe Code, Part III
by Jon Kalb
Summary of the talk:
Are you 100% confident that your code is exception-safe?
Safe usage of exceptions is a non-trivial problem that the industry has struggled with for the better part of two decades. If you have fear, uncertainty, or doubt about exception safety or just want to see the best practices for using exceptions in C++ and/or C++11/14, this session is for you. We’ll start with “What is the problem we are trying to solve?” and discuss alternatives, acknowledge the challenges associated with exception usage, and cover some well-meaning but misguided attempts at safety. I will then present a set of guidelines that are the basis for safe exception usage and solid implementation techniques, including how to transition from an exception-unsafe legacy code base.
When we are finished you will know how to produce code that is easier to write, easier to understand, faster, and 100% robust in the face of exceptions.
By Adrien Hamelin | Apr 20, 2015 01:45 PM | Tags: intermediate c++14
While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:
Exception-Safe Code, Part II
by Jon Kalb
Summary of the talk:
Are you 100% confident that your code is exception-safe?
Safe usage of exceptions is a non-trivial problem that the industry has struggled with for the better part of two decades. If you have fear, uncertainty, or doubt about exception safety or just want to see the best practices for using exceptions in C++ and/or C++11/14, this session is for you. We'll start with "What is the problem we are trying to solve?" and discuss alternatives, acknowledge the challenges associated with exception usage, and cover some well-meaning but misguided attempts at safety. I will then present a set of guidelines that are the basis for safe exception usage and solid implementation techniques, including how to transition from an exception-unsafe legacy code base.
When we are finished you will know how to produce code that is easier to write, easier to understand, faster, and 100% robust in the face of exceptions.
By Marco Arena | Apr 18, 2015 07:19 AM | Tags: intermediate c++11
A post on three common pitfalls regarding initializer_list...or not?
Don't blame initializer_list prematurely
by Marco Arena
From the article:
“Cannot convert initializer list argument to ‘int*'”. People started trying to figure out why initializer_list was not covertible to int[]. [...] A gentleman spotted the following in the dark corners of the codebase:
vector<YahtzeeGame> games; games.push_back(make_tuple(5, 6, 2)); games.push_back(make_tuple(5, 6, 3)); games.push_back(make_tuple(5, 6, 4)); // other stuffExcited about C++11, he tried to refactor:
vector<YahtzeeGame> games = { {5, 6, 2}, {5, 6, 3}, {5, 6, 4} };
And does it compile? ...
By Mantosh Kumar | Apr 18, 2015 12:28 AM | Tags: None
Overview on Regular Expression Support in Modern C++.
by GuoJiufu
From the article:
Regular expression is a useful string process utility for handling both pure text and markup language text like html. There are a few useful tools that are designed to use regular expression, such as grep and sed. In development language, most script languages, for example, javascript or perl, support regular expression. Regular expression has also been introduced into java as module for a long time. In C, the most famous regular expression library among many of those libraries developed would be POSIX regular expression API. As for C++, boost regular expression library was developed a few years ago. Then in C++11, regular expression was introduced into the standard library as <regex>. This blog is going to explain what is regular expression and how it is supported in c++11/14.
By Mantosh Kumar | Apr 18, 2015 12:10 AM | Tags: None
Short overview on the new libraries introduced in boost 1.58.
by Jens Weller
From the article:
A new version of boost has been released, version 1.58 brings two new libraries and a lot of bug fixes (fixes for 28 libraries are listed). Also, a good resource for boost is the new and updated book about the boost libraries from Boris Schäling, which is also available online. Not included in this release is boost.compute, a library earlier this year accepted into boost and presented at C++Now, maybe it will be in 1.59 later this year.
By psfrolov | Apr 17, 2015 07:49 PM | Tags: intermediate c++11 boost
This article shows how modern C++ features, notably variadic templates and perfect forwarding, can be used to implement a generic variant of observer pattern without the help of either macros or proprietary compiler extensions.
Making Boost.Signals2 More OOP-Friendly
by Pavel Frolov
From the article:
The observer design pattern is by far the most popular and widely known among behavioural patterns. Unfortunately, unlike other mainstream languages out there, the C++ standard library doesn’t provide out of the box observer implementation. Luckily, Boost contains Signals2, a signal/slot library which can serve as a basis for an observer. Using Signals2 as it is, however, is not so convenient in object-oriented program due to the need of manually coded register and notify class methods for each of signal/slot pairs. This article suggests an observable mixin which attempts to solve the outlined problem.
By Adrien Hamelin | Apr 17, 2015 08:00 AM | Tags: intermediate c++14
While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:
Exception-Safe Code, Part I
by Jon Kalb
Summary of the talk:
Are you 100% confident that your code is exception-safe?
Safe usage of exceptions is a non-trivial problem that the industry has struggled with for the better part of two decades. If you have fear, uncertainty, or doubt about exception safety or just want to see the best practices for using exceptions in C++ and/or C++11/14, this session is for you. We'll start with "What is the problem we are trying to solve?" and discuss alternatives, acknowledge the challenges associated with exception usage, and cover some well-meaning but misguided attempts at safety. I will then present a set of guidelines that are the basis for safe exception usage and solid implementation techniques, including how to transition from an exception-unsafe legacy code base.
When we are finished you will know how to produce code that is easier to write, easier to understand, faster, and 100% robust in the face of exceptions.