Compare C Generic Techniques and C++ Smart-Pointer Ownership

Context

Systems software often requires reusable, generic data structures and strict, leak-free memory management. While C relies on manual idiom-based abstractions, C++ formalizes resource ownership in its type system.

In this technical discussion question, address the following sections in detail with brief code snippets illustrating the concepts:

Part 1: Generic Programming in C

1. Explain how C achieves type genericity using void*, function pointer callbacks (e.g., standard qsort), and macro metaprogramming (such as macro-instantiated containers or C11 _Generic).
2. Explain why C historically lacks native function overloading, referencing symbol generation, linkage, and compiler ABI design.
3. Identify the major safety, performance, and maintenance trade-offs of using void* casts versus macro-expanded inline generics.

Part 2: Modern C++ Ownership Semantics

1. Explain the concept of Resource Acquisition Is Initialization (RAII) and contrast exclusive ownership (std::unique_ptr) with shared ownership (std::shared_ptr). Detail why move semantics are mandatory for std::unique_ptr.
2. Describe the internal layout of std::shared_ptr, specifically explaining the role of the control block, reference counts (strong vs. weak), and memory allocation overhead (e.g., std::make_shared vs. separate allocations).
3. Explain how cyclic references occur with std::shared_ptr, how std::weak_ptr breaks cycles, and how a std::weak_ptr safely accesses the underlying object when ownership might have already expired.

Expected Response Format

Structure your answer systematically, addressing each numbered prompt under both parts. Provide short C and C++ code examples to demonstrate custom comparators in C and safe std::weak_ptr::lock usage in C++.