C++ Core Guidelines: More Non-Rules and Myths

by Rainer Grimm

Demystifying non-rules and myths in C++ is a laborious but absolutely necessary job. The goal is simple: use the powerful tool C++ appropriately...

Thoughts on a more powerful and simpler C++ (5 of N)

by Herb Sutter

Perhaps the most important thing we can do for C++ at this point in its evolution is to make sure we preserve its core strengths while also directing its evolution in ways that make it simpler to use. That is my own opinion at least, so this talk starts with a perspective question: What “is C++,” really? The language continues to evolve and change; as it does so, how can we be sure we’re picking C++ evolutionary improvements that not only don’t lose its “C++-ic” qualities, but make it a better C++ than ever?

At recent CppCons, I’ve spoken about several of my own personal C++ evolution efforts and experiments, and why I think they’re potentially important directions to explore for making C++ both more powerful and also simpler to use. The bulk of the talk is updates on two of these:

1. Lifetime and dangling: At CppCon 2015, Bjarne Stroustrup and I launched The C++ Core Guidelines in our plenary talks. In my part starting at 29:06, I gave an early look at my work on the Guidelines “Lifetime” profile, an approach for diagnosing many common cases of pointer/iterator dangling at compile time, with demos in an early MSVC-based prototype. For this year’s CppCon, I’ll cover what’s new, including:
    • use-after-move diagnoses
    • better support for the standard library out of the box without annotation
    • more complete implementations in two compilers: in MSVC as a static analysis extension, and in a Clang-based implementation that is efficient enough to run during normal compilation
    • the complete 1.0 Lifetime specification being released on the Guidelines’ GitHub repo this month

I’ll summarize the highlights but focus on what’s new, so I recommend rewatching that talk video as a refresher for background for this year’s session.

2. Metaclasses: In my CppCon 2017 talk, I gave an early look at my “metaclasses” proposal to use compile-time reflection and compile-time generation to make authoring classes both more powerful and also simpler. In this case, “simpler” means not only eliminating a lot of tedious boilerplate, but also eliminating many common sources of errors and bugs. For this year, we’ll cover what’s new, including:
    • an update on the Clang-based implementation, which now supports more use cases including function parameter lists
    • new examples, including from domains like concurrency
    • an updated P0707 paper, with more links to working examples live on Godbolt, being posted in the next few weeks for the pre-San Diego committee mailing

CppCon Advice

Hello all, I've been programming in C++ for about 5 years now, 4 years in a university setting and 1 at my current employer. Recently, I put in a request to attend CppCon and it was accepted, which I'm thrilled about...

CppCon 2019 Class, Presentation and Book Signing

by Anthony Williams

It is now less than a month to this year's CppCon, which is going to be in Aurora, Colorado, USA for the first time this year, in a change from Bellevue where it has been for the last few years...

Talks and Speakers of Meeting C++ 2019 are online!

by Jens Weller

The details of the talks and speakers for Meeting C++ 2019 are now online.

OOP Is Dead, Long Live Data-oriented Design

by Stoyan Nikolov

For decades C++ developers have built software around OOP concepts that ultimately failed us - we didn’t see the promises of code reuse, maintenance or simplicity fulfilled, and performance suffers significantly. Data-oriented design can be a better paradigm in fields where C++ is most important - game development, high-performance computing, and real-time systems.

The talk will briefly introduce data-oriented design and focus on practical real-world examples of applying DoD where previously OOP constructs were widely employed.

Examples will be shown from modern web browsers. They are overwhelmingly written in C++ with OOP - that’s why most of them are slow memory hogs. In the talk I’ll draw parallels between the design of systems in Chrome and their counterparts in the HTML renderer Hummingbird. As we’ll see, Hummingbird is multiple times faster because it ditches OOP for good in all performance-critical areas.

We will see how real-world C++ OOP systems can be re-designed in a C++ data-oriented way for better performance, scalability, maintainability and testability.

“C++17 Standard Library Quick Reference” Now Available

by Marc Gregoire

Together with Peter Van Weert, we finished our new book titled “C++17 Standard Library Quick Reference”. It’s published by Apress...

Making C++ Pipes Compatible with STL Algorithms

by Jonathan Boccara

As we saw in the previous post, the Smart output iterators are now called Pipes...

Remember the Vasa! or, plus ça change, plus c’est la même chose

by Ben Deane

I’ve been programming in C++ for almost a quarter of a century now. I grew up, professionally, with C++, and in many ways, it grew up along with me...

Overload 152 is now available

Reactive or Proactive.
Reactive systems are all the rage. Frances Buontempo compares them with a proactive approach.

A Low-Latency Logging Framework.
Logging can be a bottleneck in systems. Wesley Maness and Richard Reich demonstrate a low-latency logging framework that avoids common problems.

Empty Scoped Enums as Strong Aliases for Integral Types.
Scoped enums have many advantages. Lukas Böger demonstrates their use as strong types of numbers.

C++ Reflection for Python Binding.
There are various approaches to generating Python bindings in C++. Russell Standish shows how Classdesc can be used to achieve this.

Trip Report: Italian C++ 2019.
Milan held Italy’s largest C++ conference. Hans Vredeveld reports back.

Afterwood.
Many people are risk-averse. Chris Oldwood considers this position – in verse.