Hello everyone!

Another month, another San Diego C++ Meetup! We recently hosted our 86th session for May 2026. I got the announcement out a bit late this time around, so it ended up being a very small, intimate session. Still, we had a good time going over the material!

As mentioned in our previous sessions, we are fully settled into our new home on Luma! We are not actively seeking additional sponsorships right now, as our main focus is on growing and engaging with our community directly through this streamlined platform. You can find our dedicated San Diego C++ Meetup calendar here to sync with your personal calendar and check out all past and upcoming sessions: San Diego C++ Luma meetup calendar

Here is a short summary of the topics and discussions we went over during this meetup:

  • C++ Quiz: We kicked things off with a warmup, testing our knowledge on some tricky edge cases and language quirks. We covered three specific questions from CppQuiz:
    • Question 298: We looked at a struct S with a destructor that throws an exception. We discussed whether it’s no_throw_constructible and destructible, and the behavior when a destructor throws an exception while marked noexcept (which typically leads to std::terminate).
    • Question 135: We discussed std::map behavior by comparing the size of a std::map<bool, int> and a std::map<int, int> after inserting identical sets of values (1, 3, and 5). Since 1, 3, and 5 all evaluate to true in boolean contexts, the map<bool, int> only has a size of 1, whereas the map<int, int> has a size of 3.
    • Question 174: We explored references and const. The question shows a function taking an int& and a const int& pointing to the same variable x. We discussed how modifying the non-const reference also changes the value observed through the const reference, as they point to the same memory location.
  • Main Talk: Modern Error Handling, Type Safety, and C++26 Updates: We spent time looking at practical code examples, discussing the motivation behind different approaches, and exploring how to avoid common pitfalls in modern C++.
    • void** ≠ void*: We explored the C type system, specifically why void* is a universal pointer but void** is not, and how genericity stops at one level of indirection to prevent silent memory corruption.
    • Copy-then-Mutate vs. Designated Init: We examined the hidden dangers of designated initializers when modifying existing objects (like network packets) and why a copy-then-mutate approach is often safer for preserving default or inherited values.
    • std::expected: We took a deep dive into C++23’s std::expected, looking at how it provides a zero-overhead, composable alternative to exceptions and error codes, complete with monadic chaining (and_then, transform). Also tl::expected library for pre-23.
    • Interesting News & Links: We wrapped up by reviewing some recent C++ community articles, covering topics like upcoming C++26 features (structured bindings in conditions, standard library hardening), GCC 16 improvements, and best practices for things like std::span and container filtering.

If you missed the live session or just want to re-watch the code demonstrations, you can find the full 48-minute recording on our YouTube channel here:

You can also find the specific Luma event details for this session right here: San Diego C++ Meetup #86

Want to keep the conversation going? We have a very active Discord community! I will provide a Discord update and an invite link per request.

Thanks for sticking with us, and I hope to see more of you at the next one with a bit more advance notice!

Kobi

Leave a Reply