C++ - Reddit

Anyone else getting survey request from Microsoft about C++ in VSCode? Got a survey notification for C++ experience in VSCode. Which seems like a good sign Microsoft might actually be interested in improving support for it. Anyone else getting these or is this just a random thing they do every once in a while? https://redd.it/1purcv5 @r_cpp

Mastering Function and Class Templates in C++: A Complete Guide https://techfortalk.co.uk/2023/02/05/beginners-guide-to-c-templates-2/ https://redd.it/1pupsrn @r_cpp

Choosing the Right C++ Containers for Performance https://techfortalk.co.uk/2025/12/24/optimal-c-containers-for-performance-efficiency/ https://redd.it/1pup0ka @r_cpp

The real problem of C++ - Meeting C++ 2025 Talk from Klaus Iglberger https://www.youtube.com/watch?v=QmNkbUgADBE https://redd.it/1pumq0y @r_cpp

C++ moving semantics I am new to C++ coming from C I have seen this code and it doesn't mame sense to me how an object is returned ? like is it a pointer or what exactly. I have limited knowledge on value types `std::string take(std::string&& s) { std::string x = std::move(s); return x; } int main (){ const char* b {"hello, world"}; string a = take(b);}` https://redd.it/1pukem3 @r_cpp

Multidimensional algorithms? Hi, not sure where this should go? We will soon have submdspan in C++26, which is enough to make mdspan useful in practice. Now the next step required is multidimensional algorithms. People are apparently against having iterators, but you can just implement them yourself. The only standard md-algorithm is the Einstein summation notation. You can easily modify this notation to be a transformation reduction rather than a pure summation. Anyone working with mdstructures probably has that algorithm already. But my question is: are there any plans or thoughts on md-algorithms going forward? I mean, it's nice without it, but I am an early adaoptor and I used the reference implementation to replace an existing library. That was only possible by using submdspan and adding a few custom iterators. https://redd.it/1pukt78 @r_cpp

Galen Hunt's update on Rust, AI, C, C++ job post purpose https://www.linkedin.com/posts/galenh_principal-software-engineer-coreai-microsoft-activity-7407863239289729024-WTzf https://redd.it/1puiiyy @r_cpp

Are AI Doom Predictions Overhyped? https://youtu.be/pAj3zRfAvfc https://redd.it/1puh91q @r_cpp

Semantics Perfect Forwarding Smart Pointers constexpr Initializer Lists Delegating Constructors C++14 FEATURES Generic Lambdas Return Type Deduction Binary Literals Variable Templates C++17 FEATURES Structured Bindings if/switch with initializers std::optional std::variant std::any Fold Expressions Inline Variables C++20 FEATURES Concepts Ranges Coroutines Modules Three-way Comparison (<=>) std::span MEMORY MANAGEMENT Stack vs Heap RAII (Resource Acquisition Is Initialization) Smart Pointers - unique_ptr - shared_ptr - weak_ptr Custom Allocators Memory Pools EXCEPTION HANDLING try-catch blocks throw keyword Exception Classes Standard Exceptions noexcept specifier Exception Safety Guarantees FILE I/O Stream Classes - ifstream, ofstream, fstream File Operations Binary File I/O String Streams Formatting MULTITHREADING std::thread Mutexes and Locks Condition Variables Atomic Operations Thread-local Storage Futures and Promises async PREPROCESSOR Macros #include Header Guards #pragma once Conditional Compilation ADVANCED TOPICS Type Casting - static_cast - dynamic_cast - const_cast - reinterpret_cast RTTI (Runtime Type Information) Operator Overloading Copy Elision and RVO Perfect Forwarding Name Mangling Linkage COMPILATION AND BUILD Compilation Process Header Files Source Files Linking Build Systems - Make - CMake Compiler Options Requested a AI to provide a CPP roadmap to know CPP very thoroughly, and it has provided me this roadmap. Do you have additions? Or is this good for modern CPP? https://redd.it/1pug6hs @r_cpp

Any addition to my Roadmap. C++ PROGRAMMING Topics GENERAL ALGORITHMS AND DATA STRUCTURES Data structures - Arrays and Vectors - Linked Lists - Stacks and Queues - Trees (BST, AVL, Red-Black) - Graphs - Hash Tables - Heaps Algorithms - Sorting - Searching - Graph Algorithms - Dynamic Programming - Greedy Algorithms CODE QUALITY Core principles - SOLID Principles - DRY, KISS, YAGNI Design Patterns - Creational - Structural - Behavioral Clean Code - Naming Conventions - Code Organization Tools - Linters - Static Analyzers - Profilers C++ CORE BASIC SYNTAX Variables and Constants Data Types Operators Comments Input/Output (cin, cout) Namespaces CONTROL FLOW Conditional Statements - if, else if, else - switch-case Loops - for, while, do-while - Range-based for loop Jump Statements - break, continue, return - goto FUNCTIONS Function Declaration Function Definition Function Overloading Default Arguments Inline Functions Recursion Function Pointers Lambda Expressions OBJECT-ORIENTED PROGRAMMING Classes and Objects - Class Definition - Access Specifiers (public, private, protected) - Member Functions - Member Variables Constructors - Default Constructor - Parameterized Constructor - Copy Constructor - Move Constructor Destructors this Pointer Static Members Friend Functions and Classes Const Member Functions INHERITANCE Single Inheritance Multiple Inheritance Multilevel Inheritance Hierarchical Inheritance Virtual Base Classes Access Control in Inheritance Constructor/Destructor Order POLYMORPHISM Compile-time Polymorphism - Function Overloading - Operator Overloading Runtime Polymorphism - Virtual Functions - Pure Virtual Functions - Abstract Classes - Virtual Destructors Virtual Function Table (vtable) ENCAPSULATION AND ABSTRACTION Data Hiding Getter and Setter Methods Abstract Classes Interfaces POINTERS AND REFERENCES Pointers - Pointer Basics - Pointer Arithmetic - Pointers to Objects - this Pointer - Function Pointers References - Lvalue References - Rvalue References - Reference vs Pointer Dynamic Memory - new and delete - new[] and delete[] - Memory Leaks TEMPLATES Function Templates Class Templates Template Specialization Variadic Templates Template Metaprogramming SFINAE STANDARD TEMPLATE LIBRARY (STL) CONTAINERS Sequence Containers - vector - deque - list - array - forward_list Associative Containers - set, multiset - map, multimap Unordered Containers - unordered_set - unordered_map Container Adaptors - stack - queue - priority_queue ITERATORS Iterator Types Iterator Operations Iterator Invalidation Reverse Iterators ALGORITHMS Non-modifying - find, count, search Modifying - copy, move, transform Sorting - sort, stable_sort, partial_sort Binary Search Set Operations Heap Operations FUNCTORS AND LAMBDA Function Objects Lambda Expressions std::function std::bind MODERN C++ (C++11/14/17/20/23) C++11 FEATURES Auto keyword Range-based for loops nullptr Move

Any addition to my Roadmap. C++ PROGRAMMING Topics GENERAL ALGORITHMS AND DATA STRUCTURES Data structures - Arrays and Vectors - Linked Lists - Stacks and Queues - Trees (BST, AVL, Red-Black) - Graphs - Hash Tables - Heaps Algorithms - Sorting - Searching - Graph Algorithms - Dynamic Programming - Greedy Algorithms CODE QUALITY Core principles - SOLID Principles - DRY, KISS, YAGNI Design Patterns - Creational - Structural - Behavioral Clean Code - Naming Conventions - Code Organization Tools - Linters - Static Analyzers - Profilers C++ CORE BASIC SYNTAX Variables and Constants Data Types Operators Comments Input/Output (cin, cout) Namespaces CONTROL FLOW Conditional Statements - if, else if, else - switch-case Loops - for, while, do-while - Range-based for loop Jump Statements - break, continue, return - goto FUNCTIONS Function Declaration Function Definition Function Overloading Default Arguments Inline Functions Recursion Function Pointers Lambda Expressions OBJECT-ORIENTED PROGRAMMING Classes and Objects - Class Definition - Access Specifiers (public, private, protected) - Member Functions - Member Variables Constructors - Default Constructor - Parameterized Constructor - Copy Constructor - Move Constructor Destructors this Pointer Static Members Friend Functions and Classes Const Member Functions INHERITANCE Single Inheritance Multiple Inheritance Multilevel Inheritance Hierarchical Inheritance Virtual Base Classes Access Control in Inheritance Constructor/Destructor Order POLYMORPHISM Compile-time Polymorphism - Function Overloading - Operator Overloading Runtime Polymorphism - Virtual Functions - Pure Virtual Functions - Abstract Classes - Virtual Destructors Virtual Function Table (vtable) ENCAPSULATION AND ABSTRACTION Data Hiding Getter and Setter Methods Abstract Classes Interfaces POINTERS AND REFERENCES Pointers - Pointer Basics - Pointer Arithmetic - Pointers to Objects - this Pointer - Function Pointers References - Lvalue References - Rvalue References - Reference vs Pointer Dynamic Memory - new and delete - new and delete - Memory Leaks TEMPLATES Function Templates Class Templates Template Specialization Variadic Templates Template Metaprogramming SFINAE STANDARD TEMPLATE LIBRARY (STL) CONTAINERS Sequence Containers - vector - deque - list - array - forwardlist Associative Containers - set, multiset - map, multimap Unordered Containers - unorderedset - unorderedmap Container Adaptors - stack - queue - priorityqueue ITERATORS Iterator Types Iterator Operations Iterator Invalidation Reverse Iterators ALGORITHMS Non-modifying - find, count, search Modifying - copy, move, transform Sorting - sort, stablesort, partialsort Binary Search Set Operations Heap Operations FUNCTORS AND LAMBDA Function Objects Lambda Expressions std::function std::bind MODERN C++ (C++11/14/17/20/23) C++11 FEATURES Auto keyword Range-based for loops nullptr Move

All the other cool languages have try...finally. C++ says "We have try...finally at home." https://devblogs.microsoft.com/oldnewthing/20251222-00/?p=111890 https://redd.it/1pudexb @r_cpp

Why do I rarely come across 'using namespace std?' For context, I'm pretty new to this language. I'm about halfway through 'C++ A Beginners Guide by Herbert Schildt,' but I have explored the language past this book (embedded things). In the book, the standard namespace is used for every program. In C++ programs that I typically see, std:: is used (e.g., std::cout). Is there a disadvantage to using the namespace? Is it that it's outdated? (The book im reading is from the early 2000's) https://redd.it/1pubujb @r_cpp

C++ is actually a great language for LLMs I remember hearing a few months ago that c++ isn't a great language for tools like copilot, cursor or IDE replacements. Personally, it's really integrated into my workflow and I want to say I'm having a lot of positive experiences. So I wanted to share that a bit to those still in the mindset that these tools are a negative. For one, I keep my scope small. I try to provide just the context it needs. Sometimes I will checkout the code of a third party library just so it can pull in that context if it needs. I can't provide all the best advice on this, because some of it has nothing to do with the language, other people have written great articles, and this is a skill you develop over time. But for small and large wins, c++ is a great language. Questions like "are there any unnecessary string copies?", "are there any objects that are accidentally being passed by value?", to more beefy stuff like improving the performance of individual functions, or removing unnecessary blocks in your threading lifecycle. It understands the cost of memory allocations if you tell it that is important, flatten data structures to keep it contiguous, and it will adhere to the design of your codebase. Anyway, I'm having a lot of fun with cursor in a c++ codebase and just wanted to evangelize a little - if you haven't integrated this into your codebase then you really are missing a very fundamental shift in software engineering role. I will also say that there is such a variance in AI tools. I like neovim, but having to provide the context of individual files was painful. Cursor is able to use external tools to perform its job and search. The use of one vs the use of the other feel like performing a completely different role (neovim + plugins might be better now I don't know). And a caveat: these tools can be used negatively and carelessly. I'm not here to argue that some form of SWE hasn't degraded, especially when you're working with coworkers who aren't taking care in their use. The trick is to keep the scope small, tell it what is important to you in your codebase, and increase the scope as you get more comfortable with the tool. https://redd.it/1pu78s9 @r_cpp

Wait-Free Chunked I/O Buffer We’re building a database and recently implemented a custom `I/O buffer` to handle the Postgres wire protocol. We considered `folly::IOBuf` and `absl::Cord`, but decided to implement a specialized version to avoid mutexes and simplify "late" size-prefixing. **Key Technical Features:** * **Chunked Storage:** Prevents large reallocations and minimizes `memcpy` by using a chain of fixed-size buffers. * **Wait-Free:** Designed for high-concurrency network I/O without mutex contention. * **Uncommitted Writes:** Allows reserving space at the start of a message for a size prefix that is only known after the payload is serialized, avoiding data shifts. **Why custom?** Most generic "Cord" implementations were either slow or not truly concurrent. Our buffer allows one writer and one reader to work at the same time without locks and it actually works quite well to the benchmarks. **Code & Details:** * [Benchmarks & Blog Post](https://www.serenedb.com/blog/io-buffer) * [Source Code (GitHub)](https://github.com/serenedb/serenedb/blob/main/libs/basics/message_buffer.h) I'd love to hear your thoughts on our approach and if anyone has seen similar wins by moving away from `std::mutex` in their transport layers. https://redd.it/1pu8cfs @r_cpp

New 0-copy deserialization protocol Hello all! Seems like serialization is a popular topic these days for some reason... I've posted before about the c++ library "zerialize" (https://github.com/colinator/zerialize), which offers serialization/deserialization and translation across multiple dynamic (self-describing) serialization formats, including json, flexbuffers, cbor, and message pack. The big benefit is that when the underlying protocol supports it, it supports 0-copy deserialization, including directly into xtensor/eigen matrices. Well, I've added two things to it: 1) Run-time serialization. Before this, you would have to define your serialized objects at compile-time. Now you can do it at run-time too (although, of course, it's slower). 2) A new built-in protocol! I call it "ZERA" for ZERo-copy Arena". With all other protocols, I cannot guarantee that tensors will be properly aligned when 'coming off the wire', and so the tensor deserialization will perform a copy if the data isn't properly aligned. ZERA _does_ support this though - if the caller can guarantee that the underlying bytes are, say, 8-byte aligned, then everything inside the message will also be properly aligned. This results in the fastest 0-copy tensor deserialization, and works well for SIMD etc. And it's fast (but not compact)! Check out the benchmark_compare directory. Definitely open to feedback or requests! https://redd.it/1pu6zwe @r_cpp

Is this the end of C++ at Microsoft? Given the goals and push for Rust https://www.linkedin.com/posts/galenh_principal-software-engineer-coreai-microsoft-activity-7407863239289729024-WTzf https://redd.it/1pu6cf7 @r_cpp

tieredsort - 3.8x faster than std::sort for integers, header-only Made a sorting library that detects data patterns before sorting. Results (n=100k): Random: 3.8x faster than std::sort, 1.6x faster than ska_sort Dense data (ages, sensors): 30x faster than std::sort, 9x faster than ska_sort The idea: real data isn't random. Ages are 0-100. Sensors are 12-bit. When the range is small, counting sort beats everything. Detection cost: 12 comparisons + 64 samples. Negligible. C++17, header-only, no SIMD needed. GitHub: https://github.com/Cranot/tieredsort Looking for feedback on edge cases I might have missed. https://redd.it/1pu554f @r_cpp

A little Introduction to Control Flow Integrity - James McNellis - Keynote Meeting C++ 2025 https://www.youtube.com/watch?v=_eX7AVB4qzM https://redd.it/1pty5kj @r_cpp

iceoryx2 v0.8 released It’s Christmas, which means it’s time for the iceoryx2 "Christmas" release! Check it out: https://github.com/eclipse-iceoryx/iceoryx2 Full release announcement: https://ekxide.io/blog/iceoryx2-0.8-release/ iceoryx2 is a true zero-copy communication middleware designed to build robust and efficient systems. It enables ultra-low-latency communication between processes - comparable to Unix domain sockets or message queues, but significantly faster and easier to use. The library provides language bindings for C, C++, Python, Rust, and C#, and runs on Linux, macOS, Windows, FreeBSD, and QNX, with experimental support for Android and VxWorks. With this release we added the memory‑layout compatible types StaticString and StaticVector, which have Rust counterparts that let you exchange complex data structures between C++ and Rust without serialization. The blackboard messaging pattern – a key‑value repository in shared memory that can be accessed from multiple processes – is now fully integrated, and the C++ language bindings are complete. I wish you a Merry Christmas and happy hacking if you’d like to experiment with the new features! https://redd.it/1ptyu8a @r_cpp