C++20: consteval and constexpr Functions -- Daniel Lemire

By Blog Staff | Apr 24, 2023 01:21 PM | Tags: None

Optimizing compilers seek try to push as much of the computation as possible at compile time.

C++20: consteval and constexpr Functions

by Daniel Lemire

From the article:

In modern C++, you can declare a function as ‘constexpr’, meaning that you state explicitly that the function may be executed at compile time.

The constexpr qualifier is not magical. There may not be any practical difference in practice between an inline function and a constexpr function, as in this example:

inline int f(int x) {
  return x+1;
}

constexpr int fc(int x) {
  return x+1;
}

Functional exception-less error handling with C++23’s optional and expected -- Sy Brand

By TartanLlama | Apr 23, 2023 11:13 AM | Tags: None

std::optional has been updated in C++23, and std::expected added as a new way of representing errors in your code. Read more about them here:

Functional exception-less error handling with C++23’s optional and expected

by Sy Brand

From the article:

std::optional<T> expresses “either a T or nothing”. C++23 comes with a new type, std::expected<T,E> which expresses “either the expected T, or some E telling you what went wrong”. This type also comes with that special new functional interface. As of Visual Studio 2022 version 17.6 Preview 3, all of these features are available in our standard library. Armed with an STL implementation you can try yourself, I’m going to exhibit how to use std::optional‘s new interface, and the new std::expected to handle disappointments.

Simple Usage of C++20 Modules -- Victor Zverovich

By Blog Staff | Apr 21, 2023 01:18 PM | Tags: None

In my previous post I showed how to compile {fmt} as a C++20 module with clang. Although taking only two commands, ideally it’s not something you should be doing manually. So in this post, I’ll talk about module support in CMake, everyone’s favorite not a build system.

Simple Usage of C++20 Modules

by Victor Zverovich

From the article:

My first attempt was to use the CMake’s built-in functionality advertised in “import CMake; C++20 Modules”. And after some struggle I made it to work with clang but unfortunately it was very limited. Here are some of the problems and limitations that I discovered:

1. It only worked with ninja and while I don’t have anything against this build system it’s an extra hassle to get this additional dependency installed while make is usually available by default. This restriction also likely means that you cannot use such a CMake config with IDEs.
2. Native CMake support only worked with clang 16 while the fmt module can be built manually with clang 15.
3. It required the latest version of CMake and a lot of ceremony to set up, including some incomprehensible things.
4. There were issues in dynamic dependency extraction both in clang-scan-deps and CMake itself.

Hiring for C++ with Meeting C++

By Meeting C++ | Apr 21, 2023 02:24 AM | Tags: meetingcpp hiring community

A presentation on the results of the Meeting C++ online job fair in 2022 & 2023 and the plans for the next for May 9th & 10th

Hiring for C++ with Meeting C++

by Jens Weller

Video:

Functional Exception-less Error Handling with C++23’s Optional and Expected -- Sy Brand

By Blog Staff | Apr 20, 2023 01:15 PM | Tags: None

This post is an updated version of an article from five years ago, now that everything Sy talked about is in the standard and implemented in Visual Studio.

Functional Exception-less Error Handling with C++23’s Optional and Expected

by Sy Brand

From the article:

In software things can go wrong. Sometimes we might expect them to go wrong. Sometimes it’s a surprise. In most cases we want to build in some way of handling these misfortunes. Let’s call them disappointments.

std::optional was added in C++17 to provide a new standard way of expressing disappointments and more, and it has been extended in C++23 with a new interface inspired by functional programming.

C++23’s New Fold Algorithms -- Sy Brand

By Blog Staff | Apr 19, 2023 09:09 AM | Tags: None

This post explains the benefits of the new “rangified” algorithms, talks you through the new C++23 additions, and explores some of the design space for fold algorithms in C++.

C++23’s New Fold Algorithms

by Sy Brand

From the article:

C++20’s algorithms make several improvements to the old iterator-based ones. The most obvious is that they now can take a range instead of requiring you to pass iterator pairs. But they also allow passing a “projection function” to be called on elements of the range before being processed, and the use of C++20 concepts for constraining their interfaces more strictly defines what valid uses of these algorithms are. These changes allow you to make refactors like:

// C++17 algorithm
cat find_kitten(const std::vector<cat>& cats) {
    return *std::find_if(cats.begin(), cats.end(),
        [](cat const& c) { return c.age == 0; });
}

// C++20 algorithm
cat find_kitten(std::span<cat> cats) {
    return *std::ranges::find(cats, 0, &cat::age);
}

Broker -- Rainer Grimm

By Blog Staff | Apr 17, 2023 10:40 AM | Tags: None

The Broker Pattern structures distributed software systems that interact with remote service invocations. It is responsible for coordinating the communication, its results, and exceptions.

Broker

by Rainer Grimm

From the article:

The Broker Pattern from the book  "Pattern-Oriented Software Architecture, Volume 1" helps solve many challenges of distributed systems, such as finding the appropriate service provider, communicating with them securely, using the right programming language, or dealing with errors. This will not go into the details. It should only provide you with a rough idea of the Broker Pattern. For further information, study the pattern in the book "Pattern-Oriented Software Architecture, Volume 1".

C++20 Lambda Extensions: Lambda Default Constructors -- Gajendra Gulgulia

By Blog Staff | Apr 13, 2023 04:50 PM | Tags: None

In this article, I cover Default constructuctible lambdas.

C++20 Lambda Extensions: Lambda Default Constructors

by Gajendra Gulgulia

From the article:

1. Default construction: Very short background

In C++ objects are default constructible if they satisfy certain conditions. The set of conditions vary and I’ll not go into all the details of what they are as it will be out of the scope of this article. Consider the Person class with default constructor in line 3. 

class Person{
    public:
         Person() = default;   //default constructor
         Person(std::uint32_t age, std::string name):
         age_{age}, name_{name}
         { /*empty body */ }

         std::string getName()  const { return name_;}
         std::uint32_t getAge() const { return age_; }
        
        void setAge(const std::uint32_t age) {age_ = age;}
        void setName(const std::string& name){name_ = name;}
   private:
       std::uint32_t age_{};
       std::string name_{};
};

C++23’s New Fold Algorithms -- Sy Brand

By TartanLlama | Apr 13, 2023 01:02 PM | Tags: c++20

If you want to find out more about the std::ranges::fold_* algorithms in C++23, here's a new post for you.

C++23’s New Fold Algorithms

By Sy Brand

From the article:

C++20 added new versions of the standard library algorithms which take ranges as their first argument rather than iterator pairs, alongside other improvements. However, key algorithms like std::accumulate were not updated. This has been done in C++23, with the new std::ranges::fold_* family of algorithms.

Announcing Meeting C++ 2023

By Meeting C++ | Apr 13, 2023 08:37 AM | Tags: meetingcpp community

Today this years edition of the Meeting C++ conference has been announced:

Announcing Meeting C++ 2023

by Jens Weller

From the article:

This years Meeting C++ conference will be held in Berlin on the 12th - 14th November!

Like in the previous year, we will be hosting 3 tracks on site and plan for a prerecorded online track. The online part also will include live streams from all onsite talk tracks.

Tickets are available via event brite...