Tagged articles
C++20
24 articles · Page 1 of 1
The article analyzes C++ complexities through variable initialization syntax variations, random number generation pitfalls and modern solutions, explicit type casting operators, and the multiple meanings of the static keyword, illustrating how backward compatibility drives language complexity.
C++C++11C++20
0 likes · 11 min read

The vLLM 0.21.0 release brings five major updates—including Transformers v4 deprecation, a C++20 build requirement, KV offload with hybrid memory, speculative decoding that respects thinking budgets, and a Blackwell token‑speed backend—while offering detailed upgrade guidance for different user groups.
C++20KV CacheTransformers
0 likes · 12 min read

FinceptTerminal, an open‑source financial analysis terminal built with C++20, Qt6, and Python 3.11+, offers a free, modular platform that combines CFA‑level market tools, AI automation, and unlimited data connections, aiming to lower the barrier for independent investors, quant developers, and finance students.
AIC++20FinceptTerminal
0 likes · 6 min read


TonyBaiApr 15, 2026 · Industry Insights
A recent r/cpp discussion reveals three distinct C++ developer mindsets—legacy‑code loyalists, modern‑feature enthusiasts, and mixed‑approach pragmatists—debating whether C++20/23 innovations boost productivity or merely pile on complexity, and proposes incremental modernization as a balanced path forward.
C++C++20C++23
0 likes · 11 min read


21CTONov 29, 2025 · Fundamentals
GCC has officially made C++20 the default language standard, a shift that reshapes codebases, tooling, and developer habits, requiring both newcomers and seasoned programmers to adapt to new features like modules, concepts, and coroutines while managing potential build issues.
C++C++20Compiler
0 likes · 5 min read

This article traces the evolution of C++ template constraints—from the cryptic SFINAE and enable_if techniques, through the clearer constexpr if introduced in C++17, to the expressive and user‑friendly Concepts of C++20—showing how each step makes generic programming more readable and maintainable.
C++C++20Concepts
0 likes · 7 min read

This article explains how C++ template metaprogramming (TMP) and SFINAE let developers move calculations and type checks to compile time, providing zero runtime cost, and demonstrates practical techniques with clear code examples and modern language features up to C++20.
C++C++20SFINAE
0 likes · 23 min read

This article explains what C++ lambda expressions are, their syntax, capture mechanisms, mutable keyword, return type deduction, generic and template lambdas, and demonstrates practical uses with STL algorithms, event handling, and asynchronous programming, while offering best‑practice guidelines.
Anonymous FunctionsC++C++11
0 likes · 12 min read

This article reviews the evolution of C++ from its 2011 C++11 overhaul through C++14, C++17, C++20, and the upcoming C++23, highlighting each standard’s key features, code examples, and the impact on modern software development.
C++C++11C++20
0 likes · 8 min read

This article explores the significance of C++20, detailing its major new features such as modules and coroutines, explains how they improve compilation speed, code organization, and asynchronous programming, and provides practical examples and migration strategies for modern C++ development.
Asynchronous ProgrammingC++20Coroutines
0 likes · 41 min read

This article provides a concise overview of the most commonly used new features introduced in C++11 through C++20, including auto type deduction, range‑based for loops, smart pointers, lambda expressions, move semantics, structured bindings, concepts, ranges, coroutines, the spaceship operator, and more, with clear code examples.
C++C++11C++14
0 likes · 6 min read

This article introduces ten widely used modern C++ features—including range‑based for loops with initializers, structured bindings, inline variables, std::optional, std::variant, std::visit, constexpr if, default/delete functions, [[nodiscard]] and std::string_view—explaining their benefits and providing concise code examples.
C++C++17C++20
0 likes · 14 min read

This article explains the fundamentals of C++20 coroutines, describing their lightweight asynchronous execution model, key language constructs such as co_await, co_yield, and co_return, the underlying components like promise objects and coroutine handles, and demonstrates real‑world usage through comprehensive code examples for networking, file I/O, generators, and task scheduling.
C++20Coroutinesco_await
0 likes · 32 min read

This article provides a comprehensive introduction to C++20 coroutines, covering fundamental concepts, stackful versus stackless implementations, detailed code demos—including a simple coroutine, a generator for Fibonacci numbers, and a task framework—while explaining the underlying compiler transformations and practical usage.
C++20CoroutinesStackless
0 likes · 31 min read

This article provides a comprehensive overview of C++20's major new features—including concepts, modules, coroutines, ranges, three‑way comparison, constexpr enhancements, and the updated standard library—along with practical code examples, explanations of their significance, and frequently examined interview topics.
C++20ModulesNew Features
0 likes · 35 min read

C++20 coroutines turn functions containing co_await, co_yield, or co_return into suspendable tasks, requiring a promise_type that defines get_return_object, initial_suspend, final_suspend, yield_value, return handling, and exception management, while handles manage resumption, and custom awaiters enable asynchronous I/O such as non‑blocking TCP connections.
C++20Promiseasync
0 likes · 13 min read

The article explains how Asio implements C++20 coroutine support by converting callback‑based async operations into awaitables with use_awaitable, launching them via co_spawn and co_spawn_entry_point, handling result propagation and thread dispatch, and providing parallel composition operators (&&, ||) for concurrent awaiting.
AsioC++C++20
0 likes · 26 min read

The article explains how C++20 coroutines and the emerging execution framework are used to redesign a single‑threaded game‑server architecture, detailing custom async wrappers, integration with asio and libunifex, job‑type scheduling, example coroutine code, current limitations, and a roadmap toward a simpler, sender/receiver‑based async library.
C++20asynchronouscoroutine
0 likes · 19 min read

This article explores the evolution of C++ templates, explains the purpose and syntax of concepts, demonstrates how they replace SFINAE and enable_if with clearer compile‑time checks, and shows practical ways to define and use concepts for safer generic programming.
C++C++20Concepts
0 likes · 10 min read

This article walks through C++20 coroutines with clear explanations, three runnable examples, deep dives into promise_type, coroutine_handle, co_await, co_yield and co_return, and shows how to build both void‑returning and int‑returning coroutines while illustrating the compiler‑generated control flow.
Async ProgrammingC++C++20
0 likes · 21 min read

The article walks through C++20 coroutines—from basic suspension mechanics and the roles of coroutine_handle, promise_type, and awaitable methods—to constructing a lightweight game scheduler that manages task lifetimes, await modes, and RPC integration, and demonstrates how this approach mirrors Python’s yield‑based skill system while offering clearer, high‑performance native code.
C++20asynchronousawaitable
0 likes · 29 min read

Last week’s developer newsletter spotlights the official C++20 standard launch, a surprising over‑100% growth in China’s AI cloud market, Nature’s discovery of universal facial expressions, DeepMind’s rule‑free MuZero game mastery, JD Cloud’s 99.995% SLA upgrade, mimik‑IBM edge‑computing partnership, a Fudan microservice fault‑localization thesis, and an AAAI paper on semantic relation modeling.
C++20Edge Computingartificial intelligence
0 likes · 9 min read

This roundup covers Red Hat's defense of ending CentOS, a spam attack on VS Code's GitHub issues, a Windows 10 update that can corrupt SSDs, a Rust usage survey, the C++20 standard release, security incidents, and other notable developments in the tech industry.
C++20CentOSVS Code
0 likes · 11 min read


21CTODec 26, 2020 · Fundamentals
In a recent global C++ conference, Bjarne Stroustrup outlined the major features of C++20, explained his design philosophy of simplicity, balance, freedom and friendliness, and highlighted how C++ continues to serve a wide range of domains while offering guidance for learning and future evolution.
Bjarne StroustrupC++C++20
0 likes · 14 min read
