Overload 148 is now available

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

Overload 148 is now available

From the journal:

Revolution, Restoration and Revival.
Trends cycle in seasons. Frances Buontempo wonders what programmers should on the lookout for.

Diseconomies of Scale.
Bigger is not always better. Allan Kelly considers when smaller is more productive.

Flip Model: A Design Pattern.
Publishing dynamic, complex data to many clients in a threadsafe manner is challenging. Daniele Pallastrelli presents the Flip model pattern to overcome the challenges.

Memory Management Patterns in Business-Level Programs.
There are many memory management patterns. Sergey Ignatchenko considers these from an application level.

Compile-time Data Structures in C++17: Part 3, Map of Values.
A compile time map of values allows code to be tested more easily. Bronek Kozicki demonstrates how to avoid a central repository of values.

Algol 68 - A Retrospective.
Algol 68 has influenced programming languages in many ways. Daniel James reminds us just how many.

Measuring Throughput and the Impact of Cache-line Awareness.
How do you measure throughput? Richard Reich and Wesley Maness investigate suitable metrics.

Using multi-stage containers for C++ development—Marc Goodner

An interesting method.

Using multi-stage containers for C++ development

by Marc Goodner

From the article:

Containers are a great tool for configuring reproducible build environments. It’s fairly easy to find Dockerfiles that provide various C++ environments. Unfortunately, it is hard to find guidance on how to use newer techniques like multi-stage builds. This post will show you how you can leverage the capabilities of multi-stage containers for your C++ development. This is relevant to anyone doing C++ development regardless what tools you are using...

AI-Assisted Code Completion Suggestions Come to C++ via IntelliCode—Nick Uhlenhuth


AI-Assisted Code Completion Suggestions Come to C++ via IntelliCode

by Nick Uhlenhuth

From the article:

After reading and writing enough code, you begin to notice certain usage patterns. For example, if a stream is open, it will eventually be closed. More interestingly, if a string is used in the context of an if-statement, it will often be to check if the string is empty or if it has a certain size. You begin to identify and use these coding patterns over time, but what if Visual Studio already knew these common patterns and could suggest them to you as you code? That’s exactly what IntelliCode does...

Madrid Cpp meetup: Bare metal programming

New Madrid C++ comin' atcha:

Embedded systems: Bare metal programming

By Madrid C/C+

In Spanish from the event brief: 

Acabamos el año con uno de los meetups más esperados de la temporada: sistemas embebidos. Nos adentramos en un terreno inexplorado por muchos de nosotros, pero que tienen gran relevancia en el mundo industrial: IoT, domótica, industria del automóvil,...

Trip Report: C++ Standards Meeting in San Diego, November 2018—Botond Ballo

New trip report.

Trip Report: C++ Standards Meeting in San Diego, November 2018

by Botond Ballo

From the article:

A few weeks ago I attended a meeting of the ISO C++ Standards Committee (also known as WG21) in San Diego, California. This was the third committee meeting in 2018; you can find my reports on preceding meetings here (June 2018, Rapperswil) and here (March 2018, Jacksonville), and earlier ones linked from those. These reports, particularly the Rapperswil one, provide useful context for this post...

Exploring Clang Tooling – Using Build Tools with clang-tidy—Stephen Kelly

Today about clang-tidy.

Exploring Clang Tooling – Using Build Tools with clang-tidy

by Stephen Kelly

From the article:

The previous series about clang-tidy on this blog covered the basics of creating a clang-tidy extension and tooling to support that in the form of clang-query.

While the series focused on single-file examples for simplicity, developers progressing in this direction will need to run the tooling on all of the files in their project at once, or on all files which match a specific pattern.

How to Design Function Parameters That Make Interfaces Easier to Use (2/3)—Jonathan Boccara

Agree with the logic?

How to Design Function Parameters That Make Interfaces Easier to Use (2/3)

by Jonathan Boccara

From the article:

Let’s continue exploring how to design function parameters that help make both interfaces and their calling code more expressive.

If you missed on the previous episode of this topic, here is what this series of articles contains:

  • Part 1: interface-level parameters, one-parameter functions, const parameters,
  • Part 2: calling contexts, strong types, parameters order,
  • Part 3: packing parameters, processes, levels of abstraction.

Python-Like enumerate() In C++17—Nathan Reed

Handy little piece of code.

Python-Like enumerate() In C++17

by Nathan Reed

From the article:

Python has a handy built-in function called enumerate(), which lets you iterate over an object (e.g. a list) and have access to both the index and the item in each iteration. You use it in a for loop, like this:

for i, thing in enumerate(listOfThings):
    print("The %dth thing is %s" % (i, thing))

Iterating over listOfThings directly would give you thing, but not i, and there are plenty of situations where you’d want both (looking up the index in another data structure, progress reports, error messages, generating output filenames, etc).

C++ range-based for loops work a lot like Python’s for loops. Can we implement an analogue of Python’s enumerate() in C++? We can!

Quick Q: Regarding shared_ptr reference count block

Quick A: it is an implementation detail for the std.

Recently on SO:

Regarding shared_ptr reference count block

(1) Regarding size: How can I programatically find the exact size of the control block for a std::shared_ptr?

There is no way. It's not directly accessible.

(2) Regarding logic: Additionally, boost::shared_ptr mentions that they are completely lock-free with respect to changes in the control block.(Starting with Boost release 1.33.0, shared_ptr uses a lock-free implementation on most common platforms.) I don't think std::shared_ptr follows the same - is this planned for any future C++ version? Doesn't this also mean that boost::shared_ptr is a better idea for multithreaded cases?

Absolutely not. Lock-free implementations are not always better than implementations that use locks. Having an additional constraint, at best, doesn't make the implementation worse but it cannot possibly make the implementation better.

Consider two equally competent programmers each doing their best to implement shared_ptr. One must produce a lock-free implementation. The other is completely free to use their best judgment. There is simply no way the one that must produce a lock-free implementation can produce a better implementation all other things being equal. At best, a lock-free implementation is best and they'll both produce one. At worse, on this platform a lock-free implementation has huge disadvantages and one implementer must use one. Yuck.