This article explains how Taro leverages C++ and the HarmonyOS C‑API to build a high‑performance, multi‑language event system that bridges ArkTS, JavaScript and native components, detailing architecture considerations, implementation details, and future directions for improving cross‑language event handling.
This article details JD's custom HarmonyOS image library built with C++ and Taro, covering its background, technical design, core modules, performance monitoring, optimization techniques, quality assurance mechanisms, and future development plans to achieve high‑performance cross‑platform image loading for mobile applications.
This article explains how Taro leverages C‑API to move runtime logic to C++ and builds a cross‑language event system that unifies ArkTS, JavaScript and C++ on Harmony OS, improving rendering performance, lifecycle management, and developer productivity.
This article explains the concept of spin locks, compares them with mutexes, shows how to use the pthread API and C++ atomic_flag to implement them, outlines suitable scenarios, highlights CPU‑usage pitfalls, and provides practical code examples.
Herb Sutter, ISO C++ chair and former Microsoft veteran, announced at CppCon that the upcoming C++26 standard will introduce four major features—enhanced std::execution, stronger type and memory safety, powerful reflection and code generation, and contracts—aimed at boosting concurrency, safety, and compile‑time programming.
US agencies CISA and FBI have issued a hard‑line directive urging software vendors to abandon non‑memory‑safe languages like C/C++ for critical infrastructure, mandating a clear migration roadmap by Jan 1 2026, while industry leaders debate the practicality and costs of such a shift.
The article examines the Safe C++ proposal—a collaborative effort by Sean Baxter and Christian Mazakas to add Rust‑inspired ownership and borrowing checks to C++ through a safe standard library—while discussing its 18‑month development timeline, toolchain extensions, community reactions, and broader implications for memory‑safe programming.
This article presents a curated collection of C++ open‑source projects ranging from beginner-friendly tutorials and simple games to intermediate libraries and advanced frameworks, offering detailed descriptions, difficulty levels, and GitHub links to help developers progressively enhance their coding skills and understand complex system design.
This article explains the difference between shallow and deep copying in C++, shows why the default copy constructor can cause double‑deletion when a class holds pointers, and demonstrates how to implement a proper deep‑copy constructor with clear code examples.
This guide explains the difference between shallow and deep copying in C++, shows how the compiler‑generated copy constructor performs a shallow copy, demonstrates the pitfalls with pointer members, and provides a custom copy constructor example that safely implements deep copying.
C++ graduates often fail backend interviews at major internet firms because those companies favor Java or Go and expect experience with databases, caches, and message queues, so candidates should either acquire those backend skills, switch to the dominant languages, or target C++‑friendly domains such as embedded, AV, gaming, or client‑side networking.
The article explains why network protocols use layered design, details TCP's reliability and congestion‑control mechanisms, outlines HTTP status‑code categories, reviews MySQL lock scopes from global to row‑level, provides a C++ breadth‑first binary‑tree traversal example, and describes a three‑step weighing puzzle to find an odd ball.
Amid rising memory‑safety concerns highlighted by Chrome’s vulnerabilities and high‑profile attacks, the C++ community proposes a Safe C++ Extension to add memory‑safety features, while experts compare it to Rust and discuss challenges, adoption pressures, and DARPA’s AI‑driven code‑conversion efforts.
The article analyzes why C++‑focused graduates receive few backend interview opportunities at major internet firms, highlights the mismatch between C++ skill sets and common backend components, and offers practical advice on switching languages or augmenting projects to better align with industry demands.
The article first shares a frustrated JD interview experience regarding a 'personality' assessment, then introduces LeetCode problem 814 – Binary Tree Pruning – detailing the problem statement, examples, and providing concise post‑order traversal solutions in Java, C++, and Python.
The C++ Alliance and engineer Sean Baxter have proposed a “Safe C++” extension, to be submitted to ISO, that introduces memory‑safety checks and a Safe Standard Library with secure data structures, responding to industry and government calls for safer code and echoing DARPA’s Rust‑translation efforts.
This article explains the structure and operation of modern CPU multi‑level caches, the write‑back caching policy, cache‑coherence mechanisms, atomic operations, and various memory‑ordering models in C++ multithreaded programs, providing detailed concepts, hardware and software solutions, and practical code examples.
This article examines the challenges of rendering long lists on HarmonyOS across iOS, Android, and Web platforms, explains the ForEach and LazyForEach mechanisms, and presents practical ArkTS and C++ solutions—including cacheCount, component reuse, and performance optimizations—to achieve smoother UI and lower memory usage.
These guidelines detail C++ client-side naming conventions using Hungarian notation, modular and component-based development principles, and comprehensive coding style rules—including variable prefixes, class naming, indentation, brace placement, macro safety, and interface design—to promote readable, maintainable, and robust software.
An overview of the Safe C++ extension proposal, developed by the C++ Alliance and Sean Baxter, which aims to add memory‑safety features to C++, includes example code, discusses its significance for software security, and references industry and governmental interest in safer programming languages.
The C++ community has unveiled a groundbreaking “Safe C++ Extensions” proposal that borrows Rust’s borrow‑checking and initialization analysis to add memory‑safety features, sparking debate over its impact on C++’s identity while addressing industry demand for safer code.
This article explains the limitations of traditional RPC, introduces gRPC and Protocol Buffers, details their architecture and performance advantages, provides step‑by‑step C++ server and client code, and discusses practical scenarios such as microservices, real‑time data processing, and a file‑storage service example.
The article shares a candid interview anecdote about reasons for leaving a job, then presents LeetCode problem 542 “01 Matrix”, explains its DP and BFS approaches, and provides full Java, C++, and Python implementations.
This article introduces five widely used, free C/C++ compilers—GCC, Clang/LLVM, Tiny C Compiler, Microsoft Visual C++, and Digital Mars—detailing their main features, platform support, typical usage commands, and ideal application scenarios for developers seeking lightweight or powerful compilation tools.
This extensive guide covers essential C++ interview topics, including process/thread/coroutine differences, new vs new[], C++11 multithreading primitives, C++20 features, static and const usage, inline functions, object‑oriented principles, pointer vs reference, struct nuances, memory management techniques, common algorithms for selecting top elements, sorting complexities, linked‑list cycle detection, and multithreading fundamentals such as thread pools, lifecycle states, and synchronization mechanisms.
This article provides an extensive overview of embedded software fundamentals, covering heap vs. stack differences, wild pointers, DMA roles, inter‑process communication methods, memory allocation strategies, malloc vs. new, volatile usage, pointer concepts, Linux kernel locks, FreeRTOS mechanisms, stack overflow prevention, compilation stages, quick‑sort algorithm, header inclusion, CAN identifiers, struct memory optimization, STM32 interrupt handling, user‑to‑kernel transitions, and condition‑variable thundering‑herd effects.
This article provides an extensive guide to C/C++ fundamentals, covering static and const qualifiers, references versus pointers, memory‑management techniques, STL container implementations, iterator behavior, object‑oriented principles, virtual functions, smart pointers, and modern C++11 features for both beginner and experienced developers.
This article compiles a series of technical interview questions and answers covering C++ and Go language differences, thread communication methods on Linux and Windows, stack versus heap memory, orphan processes, read‑write locks, Go goroutine concurrency, TCP three‑way handshake, and a sample SQL query for gender‑based grouping.
This guide provides an extensive overview of essential C++ concepts for interview preparation, covering variable definitions, static and const keywords, type conversions, pointers versus references, scope, exception handling, function overloading, templates, initialization lists, as well as memory management techniques, STL containers and algorithms, as well as multithreading and concurrency mechanisms.
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.
The article examines how the Chinese AAA title “Black Myth: Wukong” leverages Unreal Engine 5, C++, Blueprint visual scripting, and even a custom C#‑based USharp plugin to deliver cutting‑edge graphics, physics, AI, and culturally rich gameplay, illustrating the convergence of advanced technology and Chinese heritage in modern game development.
This article presents a comprehensive collection of twenty essential C++ interview topics covering hash maps vs. maps, vector internals, red‑black trees, hashing, binary trees, smart pointers, LRU cache, memcpy, linked‑list operations, TCP/UDP differences, multithreading, process‑thread distinctions, MySQL indexing, Redis caching, locking mechanisms, async vs. sync, blocking vs. non‑blocking, and Bloom filters, each explained with key concepts and code examples.
This article recounts a developer's journey from a fresh graduate to a senior backend engineer, detailing two real‑world incidents—a pseudo‑memory‑leak in a C++ service and a uint overflow that caused traffic bursts—showing the analysis steps, code fixes, and lessons learned for reliable backend development.
This article presents LeetCode problem 112 "Path Sum", detailing the problem statement, example inputs and outputs, constraints, a recursive analysis, and complete reference implementations in Java, C++, and Python for determining whether a root‑to‑leaf path equals a given target sum.
This article provides a comprehensive overview of common C++ interview questions, covering smart pointer implementations, memory management techniques, object-oriented concepts such as polymorphism and virtual functions, STL containers, threading, and modern C++ features like move semantics and coroutines.
This article explores the classic “Hello World” program across five popular programming languages—Python, C#, C++, JavaScript, and PHP—detailing each language’s syntax, key functions, and code snippets, while reflecting on the significance of this introductory example for beginners.
This article compiles over a thousand common C/C++ interview questions spanning language fundamentals, data structures, algorithms, system programming, networking, databases, design patterns, RPC, and audio‑video development, providing a thorough study guide for backend and systems engineers.
This article explains the concept, benefits, and implementation details of memory pools in the Linux kernel, covering allocation functions, design principles, common strategies, and a thread‑safe C++ memory‑pool class with example code.
This article provides a detailed, categorized catalog of widely used open‑source C++ libraries and tools covering standard libraries, frameworks, AI, networking, graphics, databases, testing, and many other domains, helping developers quickly discover suitable components for their projects.
The newly founded non‑profit Ladybird project is building a privacy‑focused browser with its own engine, funded by industry veterans, open‑sourced under BSD‑2‑Clause, and aiming to challenge the dominance of Chromium‑based and WebKit browsers despite being in a pre‑alpha developer stage.
This article surveys the most suitable programming languages for artificial intelligence, examining Python, R, Java, LISP, Prolog, C++, Haskell, JavaScript, and Julia, and outlines their strengths, ecosystem support, and use cases to help developers choose the right tool for AI projects.
Google’s Android engineering director revealed that migrating services from Go or C++ to Rust doubled productivity, slashed memory consumption, lowered defect rates, and boosted developer confidence, highlighting a broader industry move toward memory‑safe languages.
This article explains the concept of type erasure in C++, demonstrating how to achieve polymorphic behavior without a common base class by using wrapper classes, templates, and container storage, and provides multiple implementation approaches with complete code examples.
This article documents the design, iterative evolution, and performance optimizations of a cross‑platform self‑rendering engine that started with QuickJS and Flutter, progressed through a C++‑based render tree, and now adopts a React Native‑style self‑draw approach using Skia, detailing architecture, code, and results.
This article explains why multithreaded programs often feel like untamable beasts, introduces the core concept of thread safety, distinguishes private and shared resources, shows concrete C/C++ examples of safe and unsafe patterns, and outlines practical techniques such as thread‑local storage, read‑only globals, atomic operations and synchronization to write reliable concurrent code.
While Rust’s safety and performance promise significant productivity gains over C++ for low‑latency trading systems, steep learning curves, scarce talent, and lower salaries hinder its adoption in finance, with industry leaders noting both its advantages and the challenges of transitioning legacy codebases.
This article explains the Windows I/O Completion Port (IOCP) model, its architecture, advantages, workflow, key data structures, sample C/C++ code, and practical considerations for building high‑concurrency network servers using asynchronous I/O and thread pools.
This article provides a comprehensive overview of C++ memory management, covering stack vs heap allocation, deep vs shallow copying, common errors such as leaks, dangling pointers, double frees, and offers practical techniques like custom new/delete overloads, smart pointers, RAII, and tools for detecting memory problems.
This article presents LeetCode problem 797, which asks for all possible paths from node 0 to node n‑1 in a directed acyclic graph, explains the DFS approach, lists constraints and examples, and provides complete implementations in Java, C++, C, and Python.
This article introduces the open‑source learning_mind_map project, offering 81 curated mind maps that cover topics from C/C++ and Golang to Linux, cloud‑native, databases, DPDK, audio‑video development, and core computer principles, with links to the GitHub repository.
The April TIOBE Index shows Python gaining market share while C and C++ lose ground due to memory‑safety concerns, PHP slipping to historic lows, and a broader shift in developer preferences driven by AI, web frameworks, and security considerations.
This comprehensive guide explains what callback functions are, their purposes and common use cases, multiple implementation techniques such as function pointers, functors, and lambda expressions, and provides practical C++ examples, advantages, drawbacks, and best‑practice recommendations.
This article details the design and implementation of a unified, real‑time monitoring solution for a multi‑node distributed trading system, covering data modeling, low‑intrusion data flow, Kafka‑based architecture, C++ consumer components, performance testing, and future optimization directions.
This comprehensive guide covers 40 common C++ interview topics, including procedural vs. object‑oriented programming, differences between C and C++, static and const keywords, pointer versus reference semantics, memory allocation with malloc/new, function overloading, inheritance, virtual functions, templates, smart pointers, and modern C++11 features, providing clear explanations and example code.
This article chronicles the author's six‑month journey creating the Pinecone programming language, covering its core features, design decisions about compilation versus interpretation, custom lexing and parsing, implementation choices, and practical advice for anyone wanting to build their own language.
The article presents a Huawei OD interview problem where numbered basketballs are inserted into a linear bucket and can be removed from either end, describes the input and output formats, provides a simulation-based solution using double‑ended queues, and includes reference implementations in C++ and Java.
This article outlines the key programming languages—Python, Julia, and C++—that are essential for quantum computing development, explains their strengths, and offers practical advice for developers eager to enter the field.
Amid a US government report urging developers to abandon C and C++ for memory‑safe languages, C++ creator Bjarne Stroustrup argues that modern C++ already incorporates strong safety guarantees, cites ongoing standards work, and warns that abandoning the language overlooks its evolving security features.
The White House Office of the National Cyber Director released a 19‑page report urging developers to adopt memory‑safe programming languages, citing the security risks of C and C++ and calling for both software and hardware improvements to reduce attack surfaces and improve software measurability.
This guide explains the purposes and effects of the C/C++ static and volatile keywords, compares the sizeof operator with strlen, describes reliable methods for comparing floating‑point numbers, outlines how floating‑point operations affect STM32 interrupt performance, and provides a concise overview of the I²C protocol and address configuration on STM32 devices.
The White House’s ONCD report urges developers to replace C and C++ with memory‑safe languages like Rust, Go, and Java, citing alarming vulnerability statistics and a strategic shift that moves software‑security responsibility from individuals to large organizations and the federal government.
The article outlines practical, continuous performance‑optimization tactics for high‑throughput back‑end services—replacing Protobuf with lightweight C++ classes, using cache‑friendly data structures, adopting jemalloc/tcmalloc, employing lock‑free double buffers, tailoring data formats, and leveraging profiling tools—to achieve multi‑fold speedups while balancing maintainability.
The article humorously discusses Huawei cafeteria competition before presenting LeetCode problem 102, which requires a breadth‑first level order traversal of a binary tree, and provides complete Java, C++, C, and Python implementations that use a queue to process each tree level.
This article humorously references recent layoff memes before presenting a detailed tutorial on solving LeetCode problem 392—checking whether string s is a subsequence of t—using a two‑pointer algorithm, complete with step‑by‑step explanation, complexity analysis, visual illustrations, and reference implementations in C++, Java, and Python.
This article reviews common interview questions covering URL request processing, TLS handshake steps, the three‑way TCP handshake and four‑way termination, page‑fault handling, differences between TCP and UDP, HTTP/1.0 vs 1.1, thread‑safety mechanisms in C++, and a hands‑on example of building a thread pool.
This article reviews binary tree traversal methods, clarifies the correct postorder sequence, and provides Morris traversal implementations in C++, C, and Python, while also discussing common interview misconceptions and offering illustrative examples.
The Haro Street Cat mobile team created a custom multimedia framework that wraps FFmpeg 4.2.2 in a C++ core library with Android/iOS compatibility layers and Java wrappers for transcoding, live streaming, and composition, delivering hardware‑accelerated decoding, flexible filter pipelines, and reliable transcoding that boosted coverage to over 99 %, cut storage by more than 30 %, accelerated video start‑up, and improved streaming and watermarking performance.
The iconic 1990s real‑time strategy game Red Alert has had its original C++ source code released on GitHub, offering modders a rare glimpse into Westwood’s legacy code while explaining the historical context, the limited scope of the release, and why Red Alert 2 remains unavailable.
A comprehensive collection of over 100 Linux system and kernel interview questions, covering topics such as distributions, package management, process monitoring, memory management, file systems, system calls, concurrency, C/C++ language features, data structures, algorithms, and practical code examples for developers preparing for technical interviews.
The article outlines backend exception‑handling best practices, detailing business requirements such as memory‑safe multithreaded throws, clear separation of concerns, framework fallback strategies, simple macro‑based APIs, unified error‑code monitoring, rich debugging information, extensible type‑erased models, and appropriate handling of critical, recoverable, and checked exceptions across development and production environments.
This article compiles common technical interview questions for bank software positions, covering Java fundamentals, MySQL storage engines and indexes, thread‑pool parameters, HTTP GET/POST differences, TCP vs UDP characteristics, session and cookie handling, Redis data types, and C++ memory management, providing concise explanations and examples for each topic.
This article explains why reusable code should be packaged into libraries, compares static (.a) and dynamic (.so) libraries on Linux, and provides detailed commands, code examples, and troubleshooting steps for building and linking both types of libraries in C++ projects.
The article traces C++’s four‑decade evolution—from its 1979 birth as an object‑oriented extension of C, through landmark standards like C++11, to its pervasive role in systems, games and AI—while highlighting Bjarne Stroustrup’s philosophy of incremental, hardware‑focused development and recent promotional efforts.
This article presents a comprehensive C++ interview guide covering dynamic polymorphism, vtable mechanics, static vs virtual functions, memory alignment benefits, iterator invalidation in vector and map, erase‑remove idiom, map implementation details, and common synchronization primitives used in multithreaded programming.
This article presents a comprehensive overview of C++ backend interview topics, covering web server fundamentals, concurrency models, thread pool sizing, epoll integration, I/O multiplexing, HTTP methods, TCP connection handling, debugging techniques, and related networking concepts essential for backend development.
The article explains how object‑oriented analysis and design should treat exceptions by using RAII for automatic resource cleanup, avoiding error‑code patterns, and adopting a throw‑by‑default policy with strongly‑typed exceptions, illustrating concepts with C++ and VB.NET examples and framework design recommendations.
This article explains why CPU caches are needed, describes the hierarchy and internal structure of cache lines, compares direct‑mapped, set‑associative and fully‑associative caches, and shows how cache‑aware coding can dramatically improve program execution speed.
This article presents a comprehensive collection of CVTE embedded engineering interview questions and answers, covering project introductions, C/C++ operators, the static keyword, pointers vs. references, copy constructors, Linux sed usage, file system types, I²C limits, interrupt handling, recursion, IPC, GPIO modes, and compilation stages, providing clear explanations and code examples for each topic.
This article explains the concept of coroutines as lightweight user‑level threads, compares them with traditional threads, details various implementation mechanisms in C/C++ (including libco and NtyCo), and demonstrates how they improve I/O‑bound server performance through examples and code snippets.
Herb Sutter’s latest report reveals that the upcoming C++26 standard will introduce major enhancements such as contracts, static reflection, BLAS‑based linear algebra, debugging APIs, and SIMD parallelism, while also addressing safety concerns and exploring experimental projects like Cppfront and Google’s Carbon to simplify and modernize C++.
This guide walks through essential C++ class design techniques—including header guards, private data encapsulation, const-correctness, initializer lists, reference parameters, operator overloading, static members, the Big Three, deep vs shallow copying, and singleton patterns—to help you write robust, maintainable code.
This guide explains static code scanning concepts, compares popular tools, introduces Tencent’s open‑source TscanCode, details its supported languages and detection capabilities, and provides step‑by‑step instructions for running the tool on Linux and Windows with example code and results.
WebAssembly (Wasm) is a fast, binary bytecode format that lets browsers execute near‑native code written in languages like C, C++ or Rust, offering superior performance for CPU‑intensive tasks such as games and data processing, and can be integrated into front‑end projects via fetch, instantiateStreaming, and toolchains like Emscripten or wasm‑pack.
The article explains how C++ value categories—lvalue, prvalue, and xvalue—govern function return handling, parameter passing, and object lifetimes, detailing hidden out‑parameters, copy‑elision, const‑reference lifetime extension, rvalue references, and the role of std::move in enabling move semantics.
Profile‑Guided Optimization (PGO) collects runtime profiling data to recompile programs for higher performance, reducing branch mispredictions and improving code layout; Go gained built‑in PGO in 1.21 with typical 5 % gains, while C++ sees 15‑18 % QPS improvements and devirtualization benefits, and future work aims at deeper block ordering and register allocation.
This article provides a comprehensive overview of the C++ Standard Template Library, detailing the differences between vectors and lists, memory management, iterator validity, container operations, and implementations of various containers such as deque, set, map, and slist, along with code examples.
This article provides a step‑by‑step guide to using CMake for cross‑platform builds, covering fundamental concepts, basic project setup, adding versioning and configuration headers, creating libraries, optional components, installation, testing, packaging with CPack, dashboard integration, and practical usage within JetBrains CLion for C/C++ development.
This article explores how C++ programs start, detailing the role of the _start entry point, the initialization of global objects via .init_array, __libc_csu_init, and constructors, and provides practical techniques—including linking with crt files and using init_priority—to control and debug initialization order and avoid crashes.
Renowned C++ creator Bjarne Stroustrup shares concise career wisdom, urging developers to avoid over‑specialization, embrace flexibility, communicate with users, balance technical depth with broader education, and stay prepared for opportunities, while also recounting his own journey and the impact of C++ on software engineering.
Discover ten practical C++ class design guidelines—from embracing modern standards and namespace modularization to minimizing class size, ensuring low coupling, high cohesion, immutability, and leveraging tools like CppDepend—to write cleaner, more maintainable, and thread‑safe code.
By replacing over 90 fragmented micro‑services with a single‑process, plugin‑based monolith, QQ Browser’s content ingestion pipeline achieved up to ten‑fold throughput gains, near‑100 % CPU utilization, dramatically lower latency, and an 82 % reduction in development lead‑time through modern C++ design, fault‑tolerant Kafka buffering, and streamlined CI/CD.
The Tweetable Mathematical Art contest challenges participants to craft three ultra‑compact C++ functions—each under 140 characters—to compute red, green, and blue values for every pixel of a 1024×1024 image, yielding striking patterns ranging from trigonometric color wheels to Mandelbrot fractals and diffusion‑limited aggregations.
This article presents a comprehensive design and implementation of a high‑concurrency memory pool in C++, covering concepts such as fixed‑size block allocation, thread‑local caches, central and page caches, lock‑free techniques, span management, and performance benchmarking against standard malloc.
This article reviews a C++ interview covering object‑oriented programming basics, STL container behaviors, networking protocols, inter‑process communication mechanisms, memory layout, and common interview questions, providing concise explanations and code examples for each topic.
This article explains how to dramatically reduce C++ compilation time by distributing build jobs with distcc, caching results with ccache, and orchestrating the setup using Docker containers, providing step‑by‑step configuration, performance comparisons, and practical tips for heterogeneous machine clusters.
This article explains how unstable network conditions cause TCP disconnections in video conferencing, then details TCP/IP heartbeat mechanisms, ACK handling, keepalive parameter tuning, libwebsockets integration, packet loss retransmission, and non‑blocking socket connect timeout control with code examples.
This article explains the low‑level mechanics of extern "C", why placing #include directives inside an extern "C" block can cause name‑mangling and linkage errors, and provides practical guidelines and code examples for safely mixing C and C++ headers.
Herb Sutter reveals that the ISO C++ committee has approved the C++26 schedule, promising major concurrency and parallelism enhancements, new language features like wildcard support and dangerous pointers, while discussing competition from Rust, Google’s Carbon, and his experimental cppfront project.
This article explains the fundamentals of Linux memory allocation, introduces Jemalloc’s core algorithms and data structures, and provides concrete optimization steps—including arena tuning, tcache configuration, and slab size adjustments—to achieve measurable CPU savings in high‑concurrency C++ services.
This article provides an introductory overview of several widely used programming languages—including Python, Go, C, C++, Java, PHP—and explains why Windows is primarily developed in C++, highlighting each language's origins, key advantages, and typical use cases.
