October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By Meeting C++ | Oct 15, 2024 06:56 AM | Tags: meetingcpp conference community
Meeting C++ 2024 is just 30 days away! Come to Berlin and meet with the C++ Community and the C++ committee for 3 days!
The Schedule of Meeting C++ 2024
by Jens Weller
From the page:
Meeting C++ 2024 features 4 keynotes, 3 tracks onsite and one online track, the conference is live streamed from Berlin. All Tickets include access to the videos after the conference.
This years keynotes are Titus Winters, Hana Dusíková, Herb Sutter and Peter Sommerlad!
By Andrey Karpov | Oct 15, 2024 04:47 AM | Tags: semantics parsing name resolution lookups
The PVS-Studio Team invite you to the webinar. Date: November 06, 2024, 12:00 PM UTC+1.
C++ semantics
by Yuri Minaev
Summary of the talk:
In this talk on the С++ semantics, we will take a look at symbols and name resolution. We will discuss different kinds of lookups, scope importing, overload resolution, as well as templates and their specifics. Speaker: Yuri Minaev.
By Blog Staff | Oct 14, 2024 10:13 AM | Tags: None
When you transition from older C++ standards like C++11 or C++14 to the latest C++17 and C++20 it can be a tough journey. It's essential for writing clean and easy-to-maintain code, but many developers find the process challenging.
Write Modern Code with Features of C++17 and C++20
by Andreas Fertig
From the article:
Here are three common hurdles:
1. Variety of New Features
Adapting to C++17 and C++20 can be intimidating. As the latest standards offer a wide range of new features and syntax changes. One such feature is the introduction of structured bindings in C++17, which represents a shift from how variables were traditionally declared and accessed.Old Way (C++14 and Earlier):
Before C++17, when you needed to unpack values from a pair or a tuple, you would typically do something like this:
Here, you need to use std::get<>() to access each element of the tuple, which is both verbose and less intuitive, especially when dealing with more complex data structures.
By Wu Yongwei | Oct 13, 2024 08:04 AM | Tags: None
<img alt="ACCU" data-cke-saved-src="https://isocpp.org/files/img/logo.png" src="https://isocpp.org/files/img/logo.png" 225px;="" height:="" 60px;="" float:="" right;"="" style="float: right;">Programming at compile time has been possible in C++ for a long time. Yongwei Wu considers its past, present, and future.
C++ Compile-Time Programming
by Yongwei Wu
From the article:
Compile-time programming is a key feature of C++. It enables writing high-performance code often unattainable in other languages. This article explores its past, present, and future applications, highlighting the diverse possibilities in C++. We’ll briefly cover template metaprogramming, constexpr, variadic templates, static reflection, and more.
By Giovanni Dicanio | Oct 13, 2024 08:02 AM | Tags: None
Converting Unicode strings to lower and upper cases should be an easy task to accomplish. Unfortunately, that is not the case with C++. Even the so common approach of iterating "char-by-char" in the input string and invoking std::tolower/toupper is wrong. Let's discuss a possible solution to this problem in this article:
How To Convert Unicode Strings to Lower and Upper Case in C++
by Giovanni Dicanio
From the article:
[...] A possible solution to properly convert Unicode strings to lower and upper cases in Windows C++ code is to use the LCMapStringEx Windows API. This is a low-level C interface API.
I wrapped it in higher-level convenient reusable C++ code, available here on GitHub. I organized that code as a header-only library: you can simply include the library header, and invoke the ToStringLower and ToStringUpper helper functions.
By Meeting C++ | Oct 12, 2024 05:56 AM | Tags: meetingcpp community c++26 c++23 c++20 basics advanced
Meeting C++ hosted an online AMA with Herb Sutter on Friday.
AMA with Herb Sutter - Meeting C++ live
by Jens Weller & Herb Sutter
Video:
By Blog Staff | Oct 11, 2024 10:06 AM | Tags: None
When working with C++ standard containers and functions, handling references can sometimes lead to unexpected behavior, particularly with copy semantics. This is where std::ref and std::cref come into play, allowing you to store references in containers and pass them safely to template functions like std::bind or std::thread.
What is std::ref?
by Sandor Dargo
From the article:
Have you heard about
std::refandstd::cref? The helper functions that generate objects of typestd::reference_wrapper? The answer is probably yes. In that case, this article is probably not for you. But if you haven’t heard about them, or the only usage ofstd::reference_wrapperyou faced was storing references in a vector, then probably it’s worth reading on.This article is inspired by some failing tests that needed me to use
std::refin order to pass them.What does
reference_wrapperdo?A reference of an object
T(T&) is not copy assignable. On the other hand,std::reference_wrapper<T>which emulatesT&it both copy-constructible and copy-assignable. It’s even trivially copyable, so copying can take place on a byte level which makes it very efficient.So when should we use such a wrapper?
By Meeting C++ | Oct 9, 2024 10:59 AM | Tags: meetingcpp learning event community c++26 c++23 c++20
A post highlighting some of the talks that let you learn about Modern C++ at Meeting C++ 2024
Learn Modern C++ at Meeting C++ 2024
by Jens Weller
From the article:
I think this is what should you get excited the most, C++20 is making its way through the compiler implementations and you actually can apply this to your own code base. The top voted talk this year reflects this, in C++ Modules - getting started today Andreas Weis will show you how Modules are now available with the big 3 compilers.
...
Trainings at Meeting C++
After Meeting C++ 2024 there is a trainings week in the last week of November, you an choose between trainings from Kevlin Henney, Slobodan Dimtrovic and Nicolai Josuttis:
Programming with Guts by Kevlin Henney
C++ for C Developers - Migrating from C to C++ by Slobodan Dimtrovic
Generic programming in C++ with templates and auto by Nico Josuttis
Concepts, Ranges, and Views - The New Way of Programming in C++ by Nico Josuttis
By Blog Staff | Oct 8, 2024 12:37 PM | Tags: None
When designing a circular doubly-linked list, the initial challenge is determining how to manage the construction of new nodes in relation to existing ones. While constructors seem like a natural fit for placing nodes before or after a given node, overloading them can lead to ambiguity and poor design choices. Instead, using distinct tag types or factory methods provides clearer intent, ensuring flexibility while respecting the constraints of guaranteed copy elision for node addresses.
Constructing Nodes of a Hand-made Linked List, How Hard Can it Be?
by Raymond Chen
From the article:
Suppose you are writing your own circular doubly-linked list structure.
struct node { node* prev; node* next; };A natural choice for the default constructor is to make the node the sole element of a circular doubly-linked list.
struct node { node* prev = this; node* next = this; };What if you also want to add a node after an existing node? Well, we could add a constructor for that.
struct node { node* prev = this; node* next = this; node() = default; // Construct a node after a specific node node(node* other) : prev(other), next(other->next) { prev->next = this; next->prev = this; } };(Note that the “construct after another node” constructor takes the other
nodeby pointer, rather than by reference, so that it won’t be mistaken for a copy constructor.)But maybe you also want to have a “before” constructor that inserts the new node before an existing node...
By Blog Staff | Oct 3, 2024 12:16 PM | Tags: None
Previously, I tried to answer the question: what’s so hard about constexpr allocation?. Today, we continue what will become a series of posts about attempting to explain the issues behind a bunch of hard problems we’re trying to solve. The next problem: class types as non-type template parameters.
What's So Hard About Class Types as Non-type Template Parameters?
by Barry Revzin
From the article:
Before C++20, the only types you could use as non-type template parameters were scalar types (like
intandenums, but not floating point), pointers (including pointers-to-members), and references. Notably, not class types.Floating point types were also added in C++20.
The hard question about handling class types is: how do you determine template argument equivalence? Class types can define their own equality. But you don’t really want to rely on that, since now matching specializations becomes a quadratic problem — you can’t really do much when determining the instantiation for some template
f<x>other than looping through every other valuevito see ifx == vi.The other problem is we need
==to really be strong enough. One very easy problem to run into in this space is violating the One Definition Rule (ODR). One essential, core requirement for templates is that instantiating the same template with the same arguments has to yield the same code.