Skip to content

2025

  • January

    🗓   27.01.2025 at 16:30
    🗺   FIAS 0.200 and on Zoom
    📈   Intermediate

    Forwarding references

    This will complete the planned discussion for last meeting. In particular we will try to define what a forwarding (AKA universal) reference is and what std::forward exactly does. Then we will finally implement the special member functions of a ResourceOwner class, discussing on the way the copy-and-swap idiom and applying what previously introduced.

  • February

    🗓   24.02.2025 at 16:30
    🗺   FIAS 0.101 and on Zoom
    📈   Basic to intermediate

    C++17 flashy introduction

    Although not that recent anymore, the C++17 standard introduced many useful and interesting features. In this meeting, Alessandro will give a flashy introduction to some of them. This talk might be used to select topics for future meetings, too. Although discussion is always possible and welcome, this time material will be presented and discussed using slides.

  • March     No meeting taking place!

    March

  • April

    🗓   28.04.2025 at 16:30
    🗺   FIAS 0.101 and on Zoom
    📈   Intermediate

    std::variant and std::visit

    This time we will have an external guest, Johannes Misch, giving a presentation followed by open discussion.

    Following the practical example of a JSON type, we will discriminate C++'s type-safe union against polymorphism and visit the most important features of std::variant and std::visit, including brief looks at features added in newer C++ standards that improve the usability of variant.

  • May

    🗓   26.05.2025 at 16:30
    🗺   FIAS 0.101 and on Zoom
    📈   Basic to Intermediate

    The visitor design pattern

    As a follow-up of the previous meeting, we will explore the visitor design pattern, focussing on an example of a standard implementation. After having understood how it works, we will take advantage of std::variant to refactor the code in a more modern way.

  • June

    🗓   30.06.2025 at 16:30
    🗺   FIAS 0.101 and on Zoom
    📈   Basic

    Polymorphism

    While discussing the visitor design pattern we decided to use this meeting to revise and further explore the realm of polymorphism. After having recalled the basic rules of the game, some more real-life oriented question will be addressed. What is a dynamic_cast and when is it acceptable to be used? Andrew Hunt and David Thomas in book "The Pragmatic Programmer" wrote: «Inheritance is Rarely the Answer.» - why? Arguments in favour and against inheritance will be discussed.

  • July     No meeting taking place!

    July

  • August     No meeting taking place!

    August

  • September

    🗓   29.09.2025 at 16:30
    🗺   GSC 0|08 and on Zoom
    📈   Basic

    Core guidelines: Open discussion

    This time we will have a look into the C++ Core Guidelines project, which was started by Bjarne Stroustrup and Herb Sutter about 10 years ago. The spirit of the meeting can be summarized with Bjarne's official quote about the project:

    "Within C++ is a smaller, simpler, safer language struggling to get out."

  • October

    🗓   27.10.2025 at 16:30
    🗺   FIAS 0.101 and on Zoom
    📈   Basic to Intermediate

    The strategy design pattern

    This time we will explore the strategy design pattern, focussing on an example of a standard implementation. After having understood how it works, we will take advantage of std::function to refactor the code in a more modern way, discussing possible limitations, too.

  • November

    🗓   24.11.2025 at 16:30
    🗺   FIAS 0.101 and on Zoom
    📈   Intermediate to Advanced

    Some techniques to write type traits

    Although C++20 concepts revolutionized them, type traits are a powerful tool. After some preliminary introduction of basic ideas and ingredients, we will discuss a few techniques to implement type traits and apply them in a dedicated exercise for each case. This discussion will also be a good opportunity to recall some properties of the C++ template system.

  • December

    🗓   15.12.2025 at 16:30
    🗺   FIAS 0.101 and on Zoom
    📈   Intermediate

    Making user-defined objects iterable

    What properties should a class have in order to be able to write range-based for loops on its instances? After having discussed the basic requirements, standard good habits used in the STL will be explored. A demonstrative example about a custom vector with a small buffer optimization will be presented. This will also be a good opportunity to go through different types of iterators and recall how the placement new operator works.