Tagged articles
smart pointers
11 articles · Page 1 of 1
This article explains what memory leaks are in C++ on Linux, why they matter, how they occur, and provides practical guidance on detecting them with tools like Valgrind, AddressSanitizer, GDB, and mtrace, followed by concrete solutions such as proper new/delete usage, smart pointers, RAII, custom allocators, and memory pools.
C++LinuxMemory Leak
0 likes · 39 min read

This article explores why efficient memory management is crucial for C++ performance and presents practical strategies—including stack allocation, RAII, smart pointers, custom memory pools, optimal containers, move semantics, and diagnostic tools—to write faster, more robust programs.
C++RAIImemory pool
0 likes · 9 min read

This tutorial walks through Rust's core smart pointers—Box, RefCell, Rc/Arc, Mutex, and RwLock—showing how to set up the environment, use each pointer with concrete code examples, compare their concurrency behavior, and answer common questions about their proper usage.
ArCBoxMutex
0 likes · 9 min read

This article explains the core differences between C's malloc/free and C++'s new/delete, covering allocation mechanisms, object construction and destruction, error handling, common pitfalls, and best practices—including smart pointers—to help developers choose the right memory management approach for various programming scenarios.
C++allocationmalloc
0 likes · 32 min read

This article introduces C++ smart pointers—unique_ptr, shared_ptr, and weak_ptr—explaining their RAII‑based automatic memory management, usage patterns, performance considerations, common pitfalls such as cyclic references, and practical examples including factory patterns and GUI data sharing, while also covering size and custom deleters.
C++memory managementshared_ptr
0 likes · 24 min read

This article explains the fundamental differences between C's malloc/free and C++'s new/delete, covering their underlying mechanisms, proper usage patterns, common pitfalls, error‑handling strategies, and best‑practice recommendations such as smart pointers and memory‑pool techniques.
C++mallocmemory management
0 likes · 29 min read

This article walks through the most impactful C++11 enhancements—including initializer lists, auto type deduction, decltype, smart pointers, lambda expressions, move semantics, range‑based for loops, nullptr, constexpr, type aliases, and the thread library—explaining their syntax, benefits, and practical usage with clear code examples.
C++11Threadauto
0 likes · 27 min read

This article explains how C++ smart pointers—unique_ptr, shared_ptr, weak_ptr and the deprecated auto_ptr—use RAII and reference‑counting to automate memory management, avoid leaks and dangling pointers, and provide guidelines, performance analysis, and practical usage tips for modern C++ development.
C++RAIImemory management
0 likes · 36 min read

The article explains what memory leaks are, common causes, and presents practical techniques such as avoiding heap allocations, using smart pointers, employing arena allocators, leveraging coroutines, applying RAII, and debugging with tools like gperftools to detect and resolve leaks in C++ programs.
ArenaC++Memory Leak
0 likes · 12 min read

This article provides a comprehensive overview of C++11 enhancements, including list initialization, type deduction, constexpr, move semantics, perfect forwarding, lambda expressions, smart pointers, and new casting rules, with detailed explanations and code examples illustrating their syntax, behavior, and practical applications.
C++11CastingLambda Expressions
0 likes · 61 min read

C++11 smart pointers—unique_ptr, shared_ptr, and weak_ptr—replace manual new/delete by providing exclusive, shared, and non‑owning ownership semantics, automatically preventing leaks and dangling references, simplifying multithreaded code, and, when used with best‑practice guidelines, avoid common pitfalls such as double deletions and cyclic dependencies.
C++Multithreadingshared_ptr
0 likes · 24 min read
