Practical Modern C++

32nd San Diego C++ Meetup

Posted on November 17, 2021 by Martin

Agenda:

1. Welcome slides – goals we would like to achieve in San Diego C++ Meetup
2. C++ quiz
3. Do you know what your std::remove(_if) does?
4. Stackoverflow questions and discussions
4a. How does the C++ compiler evaluate recursive constexpr functions so quickly?
4b. How to check if int32_t number can fit in int8_t and int16_t?
5. Quora question discussion – Arrays, references and pointers
6. Book – Large-Scale C++ Volume I: Process and Architecture by John Lakos
7. Discuss few slides from walletfox website
8. Talk – My Quest for a Quick QuickSort

Event link on Meetup.

= delete; // not just for special member functions

Posted on September 16, 2021September 16, 2021 by Martin

During the 29th San Diego C++ Meetup fellow C++ enthusiast and contributor to my blog, Kobi, brought up something interesting about deleted functions and I wanted to share this little gem with you…

To my surprise the = delete; postfix can be applied not only to special member functions like constructors or assignment operators, but to any free standing or member function!

Why would you want such sorcery you ask? Imagine you have a function like this:

void foo(void*) {}

On its own foo can be called with a pointer to any type without the need for an explicit cast:

foo(new int); // LEGAL C++

If we want to disable the implicit pointer conversions we can do so by deleting all other overloads:

template<typename T> void foo(T*) = delete;

Or the short and sweet C++20 syntax:

void foo(auto*) = delete;

To cast a wider net and delete all overloads regardless of the type and number of parameters:

template<typename ...Ts> void foo(Ts&&...) = delete;

Kobi found this on stack overflow of course 🙂

Example program:
delete.cpp

#include <iostream>
#include <ios>
using namespace std;

void any_type(void* p) { cout << "any_type(void* p = " << hex << p << ")\n"; }

void void_only(std::nullptr_t) { cout << "void_only(std::nullptr_t)\n"; }
void void_only(void* p) { cout << "void_only(void* p = " << hex << p << ")\n"; }

#if __cplusplus >= 202002L
void void_only(auto*) = delete; // C++20 and newer...
#else
template<typename T> void void_only(T*) = delete; // prior to C++20...
#endif

// ALL other overloads, not just 1 pointer parameter signatures...
template<typename ...Ts> void void_only(Ts&&...) = delete;

int main()
{
    any_type(new char);
    any_type(new short);
    any_type(new int);

    void_only(nullptr);      // 1st overload
    void_only((void*)0xABC); // 2nd overload, type must be void*

    // void_only(0); // ERROR, ambiguous
    // void_only(NULL); // ERROR, ambiguous
    // void_only((long*)0); // ERROR, explicitly deleted
    // void_only((int*)1, (int*)2); // ERROR, also explicitly deleted
}

#include <iostream>

#include <ios>

using namespace std;

void any_type(void* p) { cout << "any_type(void* p = " << hex << p << ")\n"; }

void void_only(std::nullptr_t) { cout << "void_only(std::nullptr_t)\n"; }

void void_only(void* p) { cout << "void_only(void* p = " << hex << p << ")\n"; }

#if __cplusplus >= 202002L

void void_only(auto*) = delete; // C++20 and newer...

#else

template<typename T> void void_only(T*) = delete; // prior to C++20...

#endif

// ALL other overloads, not just 1 pointer parameter signatures...

template<typename ...Ts> void void_only(Ts&&...) = delete;

int main()

{

any_type(new char);

any_type(new short);

any_type(new int);

void_only(nullptr); // 1st overload

void_only((void*)0xABC); // 2nd overload, type must be void*

// void_only(0); // ERROR, ambiguous

// void_only(NULL); // ERROR, ambiguous

// void_only((long*)0); // ERROR, explicitly deleted

// void_only((int*)1, (int*)2); // ERROR, also explicitly deleted

}

26th San Diego C++ Meetup

Posted on May 24, 2021 by Martin

The 26th Meetup of the San Diego C++ Group was held on May 18th, 2021 and featured guest speaker Arno Schödl, Founder & CTO of think-cell who spoke about A Practical Approach to Error Handling.

25th San Diego C++ Meetup

Posted on May 3, 2021 by Martin

The 25th Meetup of the San Diego C++ Group was held on April 27th, 2021 and featured guest speaker Jerry Wiltse from the Conan Package Manager Team. The recording and slides of the presentation can be found here.

San Diego C++ Meetup

Posted on April 4, 2021April 10, 2021 by Kobi

San Diego C++ Meetup 25th meeting featuring JFrog and Conan!

https://www.meetup.com/San-Diego-CPP/

https://www.meetup.com/San-Diego-CPP/events/277115020/

Agenda

Welcome slides – goals we would like to achieve in San Diego C++ Meetup
This meeting – Hosting JFrog: Conan Package Manager for C++ in Practice

If time permits:
* Shout Out to a great C++ blog – “Vorbrodt’s C++ Blog”
* 3 cppquiz questions
* 2 years of San Diego C++ Books recommendations – a recap!
* An additional New book for this month – “Ace the Trading Systems Developer Interview” With an example of one of the questions

Featuring:
* Conan Package Manager for C++ in Practice

The Conan package manager for C++ is useful in both simple and advanced development environments. Join the Conan team to see it in action, with a simple demo using OSS libraries and tools from ConanCenter, and a more complete demo showing how to create and upload a package including different binaries for different platforms to a private repository. Also, learn about many other unique and innovative advanced Conan features along the way.

Jerry Wiltse Bio: Jerry is a member of the Conan development team, and has been dedicated to build engineering for C and C++ since 2016. He is an avid open-source enthusiast but also deeply focused on enterprise development environments. He is also the narrator and creator of the Conan learning track on the JFrog Academy.

Practical Modern C++

Category: San Diego C++ Meetup