Pure Virtual C++ Conference 2020 (April 30, online)

By Blog Staff | Apr 16, 2020 03:54 PM | Tags: None

Even though most spring C++ events are cancelled, a new one was just announced for the end of this month!

Sign up for Pure Virtual C++ Conference 2020

by Sy Brand

From the post:

Pure Virtual C++ 2020 is a free single-track one-day virtual conference for the whole C++ community. It is taking place on Thursday 30th April 2020 from 14:30 to 23:00 UTC. Sign up on the event website.

All talks will be pre-recorded and streamed on YouTube Live with a live Q&A session with the speakers. After the event, the talks will be available to watch online for free.

CLion 2020.1 release is here!

By Anastasia Kazakova | Apr 15, 2020 12:46 AM | Tags: None

Welcome the fresh CLion 2020.1 release!

CLion 2020.1: Dozens of Improvements Across the IDE, and Benefits for CUDA and Embedded Projects

by Anastasia Kazakova

From the article:

Here is a quick overview of the main highlights. If you are interested in the specific details, please read on:

• CUDA projects: code assistance in CUDA C/C++ code, an updated New Project wizard, support for CUDA file extensions
• Embedded development: support for the IAR compiler and a plugin for PlatformIO
• Windows projects: support for Clang-cl and an LLDB-based debugger for the Visual Studio C++ toolchain
• Clang-based tools update
• Refactorings, formatter, documentation, and editor enhancements
• Run/Debug configurations
• IntelliJ Platform updates

Results summary: 2020 Global Developer Survey "Lite"

By Blog Staff | Apr 14, 2020 03:59 PM | Tags: None

Over the past week, we ran our third annual global C++ developer survey. Thank you to everyone who responded. As promised, here is a summary of the results:

CppDevSurvey-2020-04-summary.pdf

The results have now been forwarded to the C++ standards committee to help inform C++ evolution. Your feedback will be very helpful, and thank you again for your participation! Stay safe, everyone.

Overload 156 is now available

By Adrien Hamelin | Apr 14, 2020 12:21 PM | Tags: community

ACCU’s Overload journal of April 2020 is out. It contains the following C++ related articles.

Overload 156 is now available

From the journal:

R.E.S.P.E.C.T..
Respect can mean many different things. Frances Buontempo muses on its myriad meanings.

Pass the Parcel.
Python’s module and package system has many features. Steve Love explores some more advanced ones.

Quick Modular Calculations (Part 3).
This article concludes the 3-part series. Cassio Neri presents a new algorithm that also works for 64-bit operands.

Deconstructing Inheritance.
Inheritance can be overused. Lucian Radu Teodorescu considers how it can go wrong and the alternatives.

Using Compile Time Maps for Sorting.
Compile time sorting can be interesting. Norman Wilson shows how to sort a map.

Profiting from the Folly of Others.
Code referred to as a hack can raise an eyebrow. Alastair Harrison learns about accessing private members of C++ classes by investigating a header called UninitializedMemoryHacks.h

It’s About Time.
How easy is it to make code wait for a time period before doing something? Mike Crowe looks at ways to avoid problems when a system clock changes.

A Day in the Life of a Full-Stack Developer.
Many roles claim to be full stack. Teedy Deigh shares a day in the life of a full stack developer.

shared_ptr - basics and internals with examples--Hitesh Kumar

By Adrien Hamelin | Apr 14, 2020 12:19 PM | Tags: c++11 basics

Did you know it?

shared_ptr - basics and internals with examples

by Hitesh Kumar

From the article:

The C++11 std::shared_ptr<T> is a shared ownership smart pointer type. Several shared_ptr instances can share the management of an object's lifetime through a common control block. The managed object is deleted when the last owning shared_ptr is destroyed (or is made to point to another object). Memory management by shared_ptr is deterministic because the timing of a managed object's destruction is predictable and in the developer's control. Hence, std::shared_ptr brings deterministic automatic memory management to C++, without the overhead of garbage collection. Here is a basic example of shared_ptr...

corobatch: using coroutines to batch operations with no effort--Francesco Zoffoli

By Adrien Hamelin | Apr 13, 2020 11:06 AM | Tags: c++20

Interested?

corobatch: using coroutines to batch operations with no effort

by Francesco Zoffoli

From the article:

Often performing operations in batch is more efficient than doing them one at a time. Typical examples could be most kinds of I/O, or vectorized instructions.

Unfortunately, doing operations on groups of items at the same time can be much less readable than doing them one element at a time...

Runtime Polymorphism with std::variant and std::visit--Bartlomiej Filipek

By Adrien Hamelin | Apr 13, 2020 11:00 AM | Tags: c++17

Different compromise.

Runtime Polymorphism with std::variant and std::visit

by Bartlomiej Filipek

From the article:

Runtime polymorphism usually connects with v-tables and virtual functions. However, in this blog post, I’ll show you a modern C++ technique that leverages std::variant and std::visit. This C++17 technique might not only offer better performance and value semantics, but also interesting design patterns...

C++20: An Infinite Data Stream with Coroutines--Rainer Grimm

By Adrien Hamelin | Apr 13, 2020 10:55 AM | Tags: c++20

The series continue.

C++20: An Infinite Data Stream with Coroutines

by Rainer Grimm

From the article:

My story to coroutines in C++20 goes on. Today I dive deep into the coroutines framework to create an infinite data stream. Consequentially, you have to read the two previous posts "C++20: Coroutines - A First Overview", and "C++20: More Details to Coroutines" to be prepared...

Fundamental operations on type lists (Part2) -- Szilard Szaloki

By Szilard Szaloki | Apr 9, 2020 10:25 AM | Tags: None

Part2 of Fundamental operations on type lists is now available, featuring common template metaprogramming idioms, like multiple inheritance and the void* trick, demonstrated on simple metafunctions, such as push_front<>, push_back<>, pop_front<> and pop_back<>.

Fundamental operations on type lists (Part2)

by Szilard Szaloki

From the article:

Among the simplest metafunctions are push_front<> and push_back<>, since they can be easily implemented by leveraging C++11's parameter pack expansion...

Fundamental operations on type lists (Part1) -- Szilard Szaloki

By Szilard Szaloki | Apr 8, 2020 12:37 PM | Tags: None

Check out this article on basic C++ template metaprogramming concepts, such as type lists and metafunctions. This post also elaborates on alias templates and their limitations,
presents different approaches to implementing four fundamental metafunctions (first<>, front<>, last<> and back<>) and introduces a common metaprogramming primitive: apply<>.

Fundamental operations on type lists (Part1)

by Szilard Szaloki

From the article:

One of the fundamental building blocks of template metaprogramming is type lists. Dealing with them used to be a hassle, but since C++11 they are pretty much built into the language through type template parameter packs...