June 16-21, Sofia, Bulgaria
September 13-19, Aurora, CO, USA
October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 16-21, Kona, HI, USA
By Adrien Hamelin | Jun 25, 2019 12:40 PM | Tags: community
use the power of C++ in the web.
Pragmatic compiling of C++ to WebAssembly. A Guide.
by Thomas Deniffel
From the article:
Most C++-Programmers I know of have already heard of WebAssembly, but most have had troubles getting started. This guide brings you beyond of a simple “Hello World”: To a stateful-applications with interactions between C++ and JavaScript...
By Adrien Hamelin | Jun 25, 2019 12:26 PM | Tags: c++17
Did you think to use it like that?
Space Game: A std::variant-Based State Machine by Example
by Nikolai Wuttke
From the article:
One of a powerful uses of std::variant is to implement State Machines. Some time ago I showed a simple example, but today we have something bigger. In today’s article by Nikolai Wuttke you’ll see how to leverage std::variant and build a space game!
By Adrien Hamelin | Jun 24, 2019 01:32 PM | Tags: c++11
Still relevant.
In case you missed it: SFINAE and enable_if
by Eli Bendersky
From the article:
There's an interesting issue one has to consider when mixing function overloading with templates in C++. The problem with templates is that they are usually overly inclusive, and when mixed with overloading, the result may be surprising...
By Adrien Hamelin | Jun 24, 2019 01:27 PM | Tags: community
The series continue.
C++ Core Guidelines: Rules for Strings
by Rainer Grimm
From the article:
The C++ core guidelines use the term string as a sequence of characters. Consequently, the guidelines are about C-strings, C++-strings, the C++17 std::string_view's, and std::byte's...
By Adrien Hamelin | Jun 24, 2019 01:19 PM | Tags: intermediate
Simple and efficient.
A simple workaround for the fact that std::equal takes its predicate by value
by Raymond Chen
From the article:
The versions of the std::equal function that takes a binary predicate accepts the predicate by value, which means that if you are using a functor, it will be copied, which may be unnecessary or unwanted.
In my case, the functor had a lot of state, and I didn’t want to copy it....
By rodburns | Jun 14, 2019 12:03 PM | Tags: None
This blog post offers a generic description of using lambdas in C++ and how it's possible to use them with SYCL, an open standard interface for programming heterogeneous hardware using C++.
Generic Interfaces with Generic Lambdas using C++ for SYCL
by Georgi Mirazchiyski
From the article:
C++ Lambdas, first introduced in C++11, are an important part of the way that the SYCL standard is defined and implemented. SYCL is required to handle different types and pass around functions so lambdas are a good fit allowing anonymous function objects to be passed to SYCL kernels. We talk about how we use lambdas in our guides and documentation, but never about how lambdas work or even how to use them in SYCL, so in this blog post we will examine how they can be used in SYCL.
By Adrien Hamelin | Jun 11, 2019 01:45 PM | Tags: intermediate community
The series continue.
C++ Core Guidelines: Avoid Bounds Errors
by Rainer Grimm
From the article:
When you access an element outside a container of the STL, the result is not so promising. You effect may be an error or undefined behaviour. Undefined behaviour means all bets are open...
By Adrien Hamelin | Jun 10, 2019 12:22 PM | Tags: intermediate community
Quick A: read the SO FAQ.
Recently on SO:
What are the basic rules and idioms for operator overloading?
- The General Syntax of operator overloading in C++
- The Three Basic Rules of Operator Overloading in C++
- The Decision between Member and Non-member
- Common operators to overload
- Overloading new and delete
...
By Marco Arena | Jun 5, 2019 06:43 AM | Tags: c++20 c++17 advanced
A new interpretation of a classical problem:
Kadane in next-gen C++
by Marco Arena
From the article:
We, programmers, get better results while thinking in patterns. We decompose complex problems in combinations of simpler patterns. However, many problems cannot be solved with known patterns. Here is where creativity kicks in...
By Adrien Hamelin | Jun 4, 2019 11:04 AM | Tags: intermediate c++14
Quick A: mostly for exception safety.
Recently on SO:
Differences between std::make_unique and std::unique_ptr with new
The motivation behind make_unique is primarily two-fold:
make_unique is safe for creating temporaries, whereas with explicit use of new you have to remember the rule about not using unnamed temporaries.
foo(make_unique<T>(), make_unique<U>()); // exception safe foo(unique_ptr<T>(new T()), unique_ptr<U>(new U())); // unsafe*The addition of make_unique finally means we can tell people to 'never' use new rather than the previous rule to "'never' use new except when you make a unique_ptr".
There's also a third reason:
make_unique does not require redundant type usage. unique_ptr<T>(new T()) -> make_unique<T>()None of the reasons involve improving runtime efficiency the way using make_shared does (due to avoiding a second allocation, at the cost of potentially higher peak memory usage).