2Back to Basics: Pointers Mike Shah, Ph.D. @MichaelShah | mshah.io | www.youtube.com/c/MikeShah 3:15 pm MDT, Mon. October 25 60 minutes | Introductory Audience 3Abstract Pointers are scary. Unfortunately Unfortunately that previous statement is what many beginners take away when first learning about pointers and the C++ language. In this talk, we will discuss the low level foundations of what a raw pointer examples of raw pointers for creating data structures, passing data into functions, dynamically allocated arrays, and function pointers. This portion will cover capabilities of raw pointers and syntax:

Smart Pointers Back to Basics Rainer Grimm Training, Coaching, and Technology Consulting www.ModernesCpp.netSmart Pointer A First Overview std::unique_ptr – Exclusive Ownership std::shared_ptr – Concurrency Function Arguments and Return ValuesOverview 4 Smart pointers automatically manage the lifetime of its resource. ▪ Smart Pointers ▪ Allocate und deallocate their resource in the constructor the lifetime of its resource. ▪ std::unique_ptr ▪ Is the replacement for the deprecated Smart Pointers std::auto_ptr std::unique_ptr doesn't support copy semantic ▪ Can be used in the containers and

does and what it is used for • You’ve heard of shared_ptr Things we won’t cover • Alias pointers, weak pointers4 Daniel Anderson -- danielanderson.net What we’ll learn today • How shared_ptr is implemented does and what it is used for • You’ve heard of shared_ptr Things we won’t cover • Alias pointers, weak pointers5 Daniel Anderson -- danielanderson.net Why is this important?6 Daniel Anderson -- _ptr>16 Daniel Anderson -- danielanderson.net std::atomic • Atomic shared pointers were introduced to answer the age-old question…17 Daniel Anderson -- danielanderson.net std

in-range (often a run-time check) • That • Implies range checking and elimination of dangling pointers (“memory safety”) • Is just what C++ requires • Is what most programmers have tried to ensure and safer argument passing Stroustrup - C++ safety -CppCon - October 2023 23 Problem: Too many pointers in interfacesLater (1988 – 2011) • Templates • Compile-time selection of implementations • C++20 to fiddle with arrays (and pointers) • Enable range checking • Algorithms • C++98: sort(begin(v),end(v)) • C++20: sort(v) • “smart pointers” (resource management pointers) • unique_ptr, shared_ptr

XOffsetDatastructure • X + Offset + Datastructure • Offset • Offset-based Pointers • Memcopyable // We use Offset-based pointers instead of raw pointers. This approach allows us to create data structures that are XOffsetDatastructure • X + Offset + Datastructure • Offset • Offset-based Pointers • Memcopyable // We use Offset-based pointers instead of raw pointers. This approach allows us to create data structures that are structure. • As shown in the diagram on the right, the lines connecting different elements represent Pointers and References, which is designed with Time and Space considerations. Fanchen Su, XOffsetDatastructure

• Atomic smart pointers 5 © 2021. 6 Since Concurrency TS1? • Improvements to std::future: some adapted into C++ 17 • Latches and Barriers: Adapted into C++ 20 • Atomic smart pointers: Adapted into C++17 away! Use Structured Deferral 4.Shared_ptr vs atomic_shared_ptr vs hazard pointers vs Read Copy Update (RCU) 5.Hazard Pointers 6.Read Copy Update 7.A Concurrency Toolkit for C++ 7 7 © 2021. 8 Since suspect this part may be controversial, so would ask for discussion on this topic. • P1121R3. Hazard Pointers: Proposed Interface and Wording for Concurrency TS 2. • P1122R4 - Proposed Wording for Concurrent

Pointerstemplate struct remote_ptr { ... private: size_t rank_; size_t offset_; }; Remote Pointers void memcpy(void* dest, remote_ptr src, size_t count) { // Issue remote get operator*() { return remote_ref(*this); } private: size_t rank_; size_t offset_; }; Remote Pointers Cannot return T&, since memory may be remote.template struct remote_ptr { remote_ref const { return remote_ref(*this); } private: size_t rank_; size_t offset_; }; Remote Pointers template struct remote_ref { T& operator=(const T& value) { memcpy(ptr_, &value

Synchronous Reclamation Beyond Concurrency TS2 – Maged Michael Protector Remover / Reclaimer Hazard pointers protect access to objects that may be removed concurrently. SAFE RECLAMATION Concurrency TS2 Essential objects template class hazard_pointer_obj_base { void retire() noexcept; }; Hazard pointers class hazard_pointer { template T* protect(const std::atomic& src) noexcept; Maged Michael See N4895 (wg21.link/n4895) for working draft of Concurrency TS2 Example Using Hazard Pointers class Foo : public hazard_pointer_obj_base { /* Foo members */ }; Result read_and_use(std::atomic&

class mechanisms: • C++ Onion, inheritance and polymorphic mechanisms, • Member Data Pointers, • Member Function Pointers, • * Stack Frame / Base Pointer mechanics • * Construction/Destruction order, • * Pointer to Member Data int(Foo::*)(int) Pointer to Member Function 65C++ Under the Hood - ‘C’ Style Pointers - Pointer to Data(aka object) 66 godbolt.org/z/rKzdTsejzC++ Under the Hood ‘C’ Pointer types Under the Hood 68C++ Under the Hood - ‘C’ Style Pointers - Pointer to Function (PFN) 69 godbolt.org/z/hvYM1no1bC++ Under the Hood – ‘C’ Style Pointers - Pointer to Function (PFN) 70 godbolt.org/z/Y1c7eWjb671

But std::vector has a problem …Iterator Invalidation ● Everytime when memory is reallocated, pointers are invalidated. ● We can reserve up front but what if the size to reserve is unknown?. ○ What point of the erase are invalidated.Iterator Invalidation ● Everytime when memory is reallocated, pointers are invalidated. ● We can reserve up front but what if the size to reserve is unknown?. ○ What point of the erase are invalidated.Iterator Invalidation ● Everytime when memory is reallocated, pointers are invalidated. ● We can reserve up front but what if the size to reserve is unknown?. ○ What