Introduction to Programming with C++ For Engineers, Book Review -- Bartlomiej Filipek

By Bjarne Stroustrup | Aug 18, 2023 01:52 PM | Tags: None

Lots of practical examples, general programming, software development techniques, OOP, parallel algorithms, plus C++ to combine it all into working applications. This is a short introduction to the book “Introduction to Programming with C++” by Prof. Boguslaw Cyganek, an excellent book for students who start their journey with system coding.

Introduction to Programming with C++ For Engineers, Book Review

By Bartlomiej Filipek

From the review:

“I have been highly impressed by Introduction to Programming with C++ for Engineers and can’t recommend it enough. With its content designed keeping in mind the author’s own students, the book assumes no prior programming experience, making it an excellent choice for anyone who wishes to learn C++ as their first programming language. […]
The book extends its reach beyond just the programming language, shedding light on aspects such as microprocessor operations, software development processes, UML, and more. Furthermore, the appendices cover essential tools like CMake and Git, making this book a comprehensive guide for anyone delving into C++ programming. The detailed content, careful attention to detail, and clarity in explaining concepts have garnered much praise for the book. This makes it an invaluable resource for those aspiring to learn and understand modern C++ programming."

PVS-Studio 7.26: running analysis in VS Code and Qt Creator, integration with DefectDojo, and more

By Andrey Karpov | Aug 17, 2023 03:38 AM | Tags: visual studio code qt creator pvs-studio defectdojo

PVS-Studio 7.26 has been released. Now you can run the analysis in plugins for VS Code and Qt Creator; upload the analysis results to DefectDojo, and more. In this note, we'll take a closer look at these and other enhancements.

PVS-Studio 7.26: running analysis in VS Code and Qt Creator, integration with DefectDojo, and more

by Sergey Vasiliev

From the article:

Now the PVS-Studio plugins for Visual Studio Code and Qt Creator support the analysis of C and C++ projects. Moreover, the plugins support mass suppression of analyzer warnings (with the help of suppress files). This mechanism enables you to hide warnings for legacy code and work only with new warnings. In this way, the integration of the analyzer into the project will be much easier.

Let's Enumerate the UB -- Shafik Yaghmour

By Blog Staff | Aug 16, 2023 01:46 PM | Tags: None

Some time ago I started working on P1705 Enumerating Core Undefined Behavior, I have collected a large set of undefined behavior (UB) during that time. There is going to be a lot of work involved in getting the annex into shape and editing it into the standard. While this work is ongoing, I will take some time to write blog posts to explore the set of undefined behaviors.

Let's Enumerate the UB

By Shafik Yaghmour

From the article:

In these posts I will cover: why we have each undefined behavior, some consequences of running afoul of each UB and tools we can use to catch UB. My plan is to enumerate them in the order they appear in the standard.

IFNDR (What is that?)

Before we go on, let’s talk about a term we find in the standard, ill-formed no diagnostic required; also known as IFNDR. This is like undefined behavior in that the standard places no requirements on a program that contains IFNDR constructs, see [intro.compliance.general]p2.2 which says (emphasis mine):

If a program contains a violation of a rule for which no diagnostic is required, this document places no requirement on implementations with respect to that program.

compared to the defintion of undefined behavior which says:

behavior for which this document imposes no requirements

The main difference is that IFNDR is a static property of your code (it is a propety of the program).

C++23: Deducing This -- Rainer Grimm

By Blog Staff | Aug 14, 2023 01:39 PM | Tags: None

Anyone who thinks a small C++ standard follows a significant C++ standard is wrong. C++23 provides powerful extensions to C++20. These extensions include the core language, particularly the standard library. Today, I present a small but very impactful feature of the core language: deducing this.

C++23: Deducing This

By Rainer Grimm

From the article:

Deducing this, sometimes also called explicit object parameter, allows it to make the implicit this pointer of a member function explicit. Like Python, the explicit object parameter must be the first function parameter and is called in C++, by convention, Self and self.

struct Test {

    void implicitParameter();               // implicit this pointer
    void explictParameter(this Self& self); // explicit this pointer
};

Deducing this enables new programming techniques in C++23: deduplication of function overloading based on the object’s lvalue/rvalue value category and constness. Additionally, you can reference a lambda and invoke it recursively. Furthermore, deducing this simplifies the implementation of CRTP

2023-07 Mailing Available

By Administrator | Aug 14, 2023 07:30 AM | Tags: None

The 2023-07 mailing of new standards papers is now available.

HPX V1.9.1 released -- STE||AR Group

By Hartmut Kaiser | Aug 12, 2023 08:25 AM | Tags: performance parallelism heterogeneous computing distributed computing concurrency c++23 c++20 c++17 c++14 c++11

The STE||AR Group has released V1.9.1 of HPX -- A C++ Standard library for Concurrency and Parallelism.

HPX V1.9.1 Released

We have released HPX 1.9.1 that adds a number of small new features and fixes a handful of problems discovered since the last 1.9.0 release. In particular: we fixed various occasional hanging during startup and shutdown in distributed scenarios. We also added support for zero-copy serialization on the receiving side to the TCP, MPI, and LCI parcelports. Moreover, we have added support for Visual Studio 2019 and GCC using MINGW on Windows, and also support for GCC 13 and Clang 15.0.0. Furthermore, we aligned our header names to their standards counterparts so porting from standard C++ to HPX is now easier. Last but not least, and by adhering to popular demand, we started adding migration guides for people interested in moving their codes away from other, commonplace parallelization frameworks like OpenMP and MPI. We have also continued to improve our documentation, please have a look here.

If you have any questions, comments, or exploits to report you can reach us on IRC or Matrix (#ste||ar on libera.chat) or email us at hpx-users. We depend on your input!

You can download the release from our releases page or check out the v1.9.1 tag using git. A full list of changes can be found in the release notes.

HPX is a general-purpose parallel C++ runtime system for applications of any scale. It implements all of the related facilities as defined by the C++20 Standard. As of this writing, HPX provides the only widely available open-source implementation of the new C++17, C++20, and C++23 parallel algorithms, including a full set of parallel range-based algorithms. Additionally, HPX implements functionalities proposed as part of the ongoing C++ standardization process, such as large parts of the features related parallelism and concurrency as specified by the upcoming C++23 Standard, the C++ Concurrency TS, Parallelism TS V2, data-parallel algorithms, executors, and many more. It also extends the existing C++ Standard APIs to the distributed case (e.g., compute clusters) and for heterogeneous systems (e.g., GPUs).

HPX seamlessly enables a new Asynchronous C++ Standard Programming Model that tends to improve the parallel efficiency of our applications and helps reducing complexities usually associated with parallelism and concurrency.

How To Address 7 Major C++ Pain Points with CLion -- Anastasia Kazakiova

By Blog Staff | Aug 10, 2023 01:32 PM | Tags: None

In the 2023 Annual C++ Developer Survey conducted by the C++ Foundation, the community identified a number of major pain points when working with C++.

How To Address 7 Major C++ Pain Points with CLion

By Anastasia Kazakiova

From the article:

As we’ll discuss in this article, CLion can help C++ developers with most of these in various ways:

• Managing third-party libraries
• Improving build times
• Setting up a CI-pipeline
• Managing a CMake project
• Checking code for thread, memory and type safety issues on-the-fly
• Setting up a development environment from scratch
• Modernize your code

RFC - fat pointer class, evolution of YOMM2 -- Reddit Q&A

By Blog Staff | Aug 9, 2023 01:24 PM | Tags: None

Question from reddit poster: I am preparing to release a new feature, a fat pointer class (virtual_ptr), that makes method dispatch even more efficient. Dispatching a method with one virtual argument via a virtual_ptr takes only three instructions and two independent memory reads. As an interesting side-effect, it is now possible to use YOMM2 with non polymorphic classes hierarchies.

RFC - fat pointer class, evolution of YOMM2

From the discussion:

I am preparing to release a new feature, a fat pointer class (virtual_ptr), that makes method dispatch even more efficient. Dispatching a method with one virtual argument via a virtual_ptr takes only three instructions and two independent memory reads. As an interesting side-effect, it is now possible to use YOMM2 with non polymorphic classes hierarchies.

Once I increase the semantic minor version number, I will mostly be stuck with the API. So, if you are interested and in the mood, please review the documentation.

Beyond this, I have been mulling a major version bump. There are a few stuff that are deprecated, and I would like to get rid of them.

Also, I wonder if it would be a good time to switch to C++20. The internals would be a lot simpler and cleaner if I could use concepts.

I have a few major developments on the radar:I have a few major developments on the radar:

• dispatch on std::any and std::variant
• "fat" versions of std::any and std::variant (in the manner of virtual_ptr)
• going headers only
• related to the former: tunable runtime
• quasi static initialization of method tables

I wonder if it would be better to wait until these items are completed before switching to C++20 and putting the C++17 code in bugfix only mode.

Finite State Machine with std::variant - Vending Machine -- Bartlomiej Filipek

By Blog Staff | Aug 7, 2023 01:17 PM | Tags: None

In my last article, we discussed Finite State Machines based on std::variant and some cool C++17 techniques. Today I want to go further and show you an example of a Vending Machine implementation.

Finite State Machine with std::variant - Vending Machine

By Bartlomiej Filipek

From the article:

Here’s a basic diagram that illustrates how the machine is going to work:

Following the model from the last article, each state and the event will be a separate small structure. Later we can “pack” them into std::variant.

C++23: The Next C++ Standard -- Rainer Grimm

By Blog Staff | Aug 5, 2023 01:37 PM | Tags: None

C++23 will be the next C++ standard after C++20. This new standard significantly improves C++ but is less game-changing than C++98, C++11, or C++20. C++23 is more in the tradition of C++17.

C++23: The Next C++ Standard

By Rainer Grimm

From the article:

The C++ Standards

C++ is more than 40 years old. What happened in the last years? Here is a simplified answer ending in C++23.

C++98

At the end of the 80ths, Bjarne Stroustrup and Margaret A. Ellis wrote their famous book Annotated C++ Reference Manual (ARM). These books served two purposes. First, there were many independent C++ implementations. ARM defined, therefore, the functionality of C++. Second, ARM was the base for the first C++ standard: C++98 (ISO/IEC 14882). C++98 had a few essential features: templates, the standard template library (STL) with its containers and algorithms, strings, and IO streams.

C++03

With C++03 (14882:2003), C++98 got a technical correction that is so small that there is no place on my timeline. In the community, C++03, which includes C++98, is called legacy C++.