Abstract:

This video presents five practical tips for improving C++ code, derived from a review of a modern engine project. The recommendations focus heavily on optimizing performance, clarity, and memory management in core application frameworks. Key improvements include replacing string identifiers with more efficient enums and UUIDs, simplifying common design patterns like singletons, and critically, managing the overhead associated with smart pointers. The author advises moving high-frequency, transient objects (like events) off the heap, strictly avoiding unnecessary copies of std::shared_ptr, and establishing clear ownership semantics when passing around raw pointers, especially in multithreaded architectures where data and rendering loops may be decoupled.

5 Easy Ways to Improve This C++ Code

• 0:24 Tip 1: Avoid Excessive String Usage for IDs and Types.
  • Detail: The submitted code uses strings for asset types and UI element IDs, which requires costly operations (e.g., string comparisons, transforming to lowercase).
  • Takeaway: Replace strings with enums (e.g., uint16_t) for asset types or 64-bit UUIDs for unique IDs. These integer-based identifiers are faster, safer, and cleaner, and should be used everywhere except the human-interfaceable parts of the runtime application.
• 5:18 Tip 2: Improve Singleton Design and Deletion Safety.
  • Detail (5:55): The logic in the singleton’s GetInstance() method can be simplified by checking if the instance is null (if (!instance)), creating it if necessary, and then returning the instance, eliminating the need for an else block.
  • Detail (6:38): When deleting a pointer in a destructor (or elsewhere), the explicit null check (if (instance)) is unnecessary because C++ guarantees that calling delete on a null pointer is safe and performs no action.
  • Takeaway (7:19): For cleaner header files, define the static instance variable inside the .cpp file (marking it static for internal linkage), or use inline static (C++17) if it must remain in the header.
• 8:04 Tip 3: Allocate Transient Events on the Stack.
  • Detail: The event system uses heap-allocated std::shared_ptr for high-frequency events (like mouse or key presses). This introduces overhead from heap allocation, atomic reference counting, and dynamic casting.
  • Takeaway: For temporary objects that live briefly and are passed along, create them directly on the stack and pass them by reference (Event&). This drastically improves performance in performance-sensitive code paths.
• 9:43 Tip 4: Avoid Unnecessary Smart Pointer Copies.
  • Detail: When iterating through or creating an alias for an existing std::shared_ptr using auto instead of auto&, the code inadvertently creates a copy of the smart pointer. This copy triggers a performance-intensive atomic increment of the reference count.
  • Takeaway: Be mindful of copying smart pointers. Use auto& to ensure you are creating a reference (alias) to the existing smart pointer, avoiding the reference counting overhead.
• 11:11 Tip 5: Be Aware of Raw Pointer Ownership Semantics.
  • Detail: The code passes raw pointers (this) into dependent objects (e.g., passing a Scene pointer to a RenderLayer) without defining ownership or lifetime semantics. This makes it impossible to know if the object is still alive before access.
  • Takeaway: When objects depend on the lifetime of others, especially when rendering and data are separated (potentially multithreaded), use clear ownership tools like std::weak_ptr (if the source is a shared_ptr) or an intrusive reference counting system to ensure memory safety and object validity.