San Diego C++ Meetup #83: February 2026 Edition

Posted on by Kobi

Last night we held our 83rd San Diego C++ Meetup. It was a fantastic evening filled with deep technical discussions and a significant announcement regarding the future of our community infrastructure.

The Big Announcement: Moving to Luma

The biggest news from this meeting is that we are officially moving away from Meetup.com. To streamline our event management and provide a better experience for our members, we have transitioned to Luma.

We now have a dedicated San Diego C++ Meetup calendar on Luma where you can see all upcoming sessions, register for events, and sync them directly to your personal calendar.

Please register on our new platform here: https://luma.com/sdcppmu

The Main Presentation: Hidden Dangers in Static Polymorphism

I delivered a deep dive into the “Hidden Dangers in Static Polymorphism.“

The event page on Luma.com: https://luma.com/24rt9aa0 (also on meetup: https://www.meetup.com/san-diego-cpp/events/313044656)

A major highlight of the talk was debunking the myth that static polymorphism is a “cure-all” for the issues found in dynamic polymorphism. Specifically, I demonstrated that slicing remains a significant threat in both worlds.

Slicing, CRTP, and std::tuple

We explored how slicing occurs when a derived object is copied into a base class storage, resulting in the loss of derived data and behavior. Even when using the Curiously Recurring Template Pattern (CRTP), developers can inadvertently trigger slicing if they aren’t careful with how objects are stored or passed.

I showed specific examples of how std::tuple can lead to slicing issues when attempting to store heterogeneous types that share a CRTP base. The talk covered:

  • Detection: How to use static_assert and deleted constructors to catch slicing at compile time.
  • Avoidance: Strategies for maintaining type identity without falling into the “value-based” slicing trap.

Modern C++ Solutions

The presentation moved beyond the “dangers” to show how modern C++ features provide safer alternatives for polymorphism:

std::apply and Variadic Templates: Powerful techniques for processing heterogeneous collections (like tuples) in a generic and type-safe manner.

C++20 Concepts: Using concepts to constrain template parameters, providing better error messages and ensuring that types satisfy the required interface without requiring a common base class.

std::variant and std::visit: An exploration of “closed” polymorphism where type safety is guaranteed and slicing is avoided by providing a type-safe union.

Recording

If you missed the live session or want to revisit the technical details, you can watch the full recording here:

Special Thanks to Our Sponsors

This community continues to thrive thanks to the generous support of our partners.

I would like to extend a huge thank you to JetBrains for their ongoing support in covering our meetup fees and dues. Their contribution ensures that our platform remains accessible to everyone.

I also want to thank Packt Publishing for partnering with us and providing excellent technical resources and books to our community members.

Closing Thoughts

It was great to see everyone and engage in such high-quality C++ discourse. Don’t forget to join our new Luma calendar to stay updated on our March meeting and beyond.

See you at #84!

Kobi

San Diego C++ Meetup #82 – January 2026 Edition

Posted on by Kobi

Hello everyone and Happy New Year!

I hope you all had a wonderful holiday season and are ready for another year of deep diving into our favorite language.

We kicked off 2026 this past Tuesday, January 13th, with our 82nd session. It was great to see everyone again; our community continues to grow, now reaching 1,874 members!

Our Supporters

Before we jump into the technical highlights, I want to take a moment to thank our sponsors who keep this community thriving.

A huge thank you to JetBrains for sponsoring our meetup fees. These costs aren’t small (reaching into the hundreds), and having their support allows us to focus entirely on the C++ content and our members.

We also want to acknowledge Packt Publishing. I’ve been spending my free time recently with a copy of Software Architecture with C++. It is a massive book – around 700 pages – and while the first few chapters cover the theoretical ground, it gets incredibly advanced from chapter five onwards. If you’re looking to push your boundaries in C++20 and beyond, I highly recommend it. Packt has been kind enough to provide a CPP20 discount code for the ebook if you want to check it out yourself!

The Main Event: C#-Style Properties in C++

Our special guest for the evening was our very own Martin Vorbrodt. Martin has been a staple of the C++ community for years, with a career spanning computer forensics, automated trading, and storage drivers.

Aside from his technical prowess, we also had something to celebrate: Martin is starting a new position next week! Congrats, Martin!

The Motivation

Martin’s talk was based on his recent work implementing C#-style properties in C++. The goal was simple but ambitious: provide the encapsulation of a getter/setter mechanism while maintaining the clean, intuitive syntax of a public data member.

We’ve all been told that public data members are a “big no-no” because you lose control over how data is accessed or modified. Martin’s implementation solves this by using a policy-based design that intercepts read and write operations without requiring the user to call get_x() or set_x() explicitly.

Implementation Highlights

Martin walked us through the <em>property.hpp</em> and <em>property.cpp</em> files from his blog repository. The implementation is a masterclass in modern C++20:

  • Policy-Based Design: The property<T> class template uses policies to control storage and access. The default policy stores the value in memory, but Martin demonstrated an FS Property (File System) policy where the value is actually stored and retrieved from disk.
  • C++20 Concepts: The code uses concepts heavily to enable or disable member methods and operators based on whether the underlying type is a primitive, a container, or a smart pointer.
  • Zero Overhead (Mostly): By default, sizeof(property<T>) is equal to sizeof(T). This is achieved by avoiding storing extra state inside the property itself when possible.
  • Event Dispatching: One of the “killer features” is the ability to register an update procedure. You can subscribe to a property, and whenever its value is modified, your lambda or function is triggered – much like property changed events in C#.
  • Explicit vs. Implicit Access: While it behaves like a variable, Martin specifically made the cast to a non-const reference explicit. This ensures that you don’t accidentally bypass the setter mechanism without meaning to.

Code: https://github.com/mvorbrodt/blog/blob/master/src/property.cpp

Q&A and Caveats

The session included some great discussion. One of the questions raised was about thread safety. Martin noted that the current event dispatching uses a static map, which isn’t thread-safe out of the box, though it could be adapted for thread-local storage or protected with a mutex if needed.

We also talked about “caching” for the File System policy. Currently, it reads/writes to disk on every access, but the beauty of the policy-based design is that a user could easily inherit from the policy to add a caching layer.

Resources and Wrap-up

f you missed the live session or want to revisit the details, you can find the event page, recording, and source code below:

Thank you again to Martin for sharing his work and to everyone who attended and asked questions. It’s a fantastic way to start the year.

See you all in February!

Kobi