cpp 215
- Implicit string conversions to booleans Nov 13, 2024
- Use std::span instead of C-style arrays Nov 6, 2024
- Who does what by how much by Josh Seiden and Jeff Gothelf Oct 19, 2024
- C++ Brain Teasers by Anders Schau Knatten Oct 16, 2024
- So shall we use static or dynamic linking? Oct 2, 2024
- Binary size: should we use static or dynamic linking? Sep 25, 2024
- Structs and constructors Sep 4, 2024
- What is std::ref? Aug 21, 2024
- Learn C++ by Example by Frances Buontempo Aug 14, 2024
- The rule of 5 and inheritance Aug 7, 2024
- Once more about the rule of 5 Jul 31, 2024
- 5 reasons why politics will ruin your career hopes Jul 24, 2024
- What to do if you don't want a default constructor? Jul 17, 2024
- Trip report: C++ On Sea 2024 Jul 10, 2024
- C++23: further small changes Jul 3, 2024
- Member ordering and binary sizes Jun 26, 2024
- Limit the number of library dependencies Jun 12, 2024
- The limits of `[[maybe_unused]]` Jun 5, 2024
- C++23: chrono related changes May 29, 2024
- Two cases when forward declaring is not enough May 15, 2024
- When and how variables are initialized? - Part 4 May 1, 2024
- When and how variables are initialized? - Part 3 Apr 24, 2024
- When and how variables are initialized? - Part 2 Apr 17, 2024
- When and how variables are initialized? - Part 1 Apr 10, 2024
- Upgrading the compiler: undefined behaviour uncovered Apr 3, 2024
- Should we move from fundamental types? Mar 27, 2024
- C++23: Encoding related changes Mar 20, 2024
- Three key philosophies behind C++ Mar 13, 2024
- My late discovery of std::filesystem - Part II Mar 6, 2024
- My late discovery of std::filesystem - Part I Feb 28, 2024
- How to write unit tests in C++ relying on non-code files? Feb 21, 2024
- C++23: More small changes Feb 7, 2024
- C++23 likes to move it! Jan 31, 2024
- C++23: bitwise operations Jan 17, 2024
- C++23: Allocator related changes Jan 10, 2024
- Late discovery of std::filesystem - Part I Jan 3, 2024
- DR20 - The Equality Operator You Are Looking For Jan 3, 2024
- How to use your namespaces to their best Dec 13, 2023
- C++23: The rise of new streams Dec 6, 2023
- C++23: Growing unicode support Nov 29, 2023
- Struct initialization Nov 22, 2023
- C++: The most important complexities Nov 15, 2023
- Extern templates to reduce binary size Nov 8, 2023
- C++23: Removing garbage collection support Nov 1, 2023
- My battle against signed/unsigned comparison: the worst violations Oct 25, 2023
- My battle against signed/unsigned comparison: the most usual violations Oct 18, 2023
- How to compare signed and unsigned integers in C++20? Oct 11, 2023
- Trip report: Dev Talks Cluj 2023 Oct 4, 2023
- Constexpr functions for smaller binary size? Sep 13, 2023
- C++23: some changes related to templates Sep 6, 2023
- C++23: compatibility with C Aug 23, 2023
- C++23: mdspan Aug 15, 2023
- C++23: multidimensional operator[] Aug 9, 2023
- The Power of Tenure: 7 reasons to stay at your job Aug 2, 2023
- C++23: static operator() and static operator[] Jul 26, 2023
- Binary sizes and compiler flags Jul 19, 2023
- C++23: Alias declarations in for loop init-statements Jul 12, 2023
- Trip report: C++ On Sea 2023 Jul 5, 2023
- The 3 best books to level up your C++ Jun 21, 2023
- Fold expressions in C++ Jun 14, 2023
- C++23: two additional noexcept functions May 31, 2023
- C++23: Even more constexpr May 24, 2023
- Is this dynamic_cast needed? May 10, 2023
- Variadic functions vs variadic templates May 3, 2023
- Without RTTI your code will be cleaner Apr 26, 2023
- Vectors and unique pointers Apr 12, 2023
- Binary sizes and passing functions to functions Apr 5, 2023
- Binary size and exceptions Mar 29, 2023
- The observer pattern and binary sizes Mar 15, 2023
- The decorator pattern and binary sizes Mar 8, 2023
- Binary sizes and RTTI Mar 1, 2023
- What's the easiest way to add custom code to your WordPress site without breaking it? Feb 27, 2023
- The evolution of enums Feb 15, 2023
- Virtual functions and binary sizes Feb 8, 2023
- Special functions and binary sizes Feb 1, 2023
- Object initialization and binary sizes Jan 18, 2023
- What's an executable and how is it structured Jan 11, 2023
- The run-time, compile-time, binary size triangle Jan 4, 2023
- Class templates versus constructor templates Dec 21, 2022
- C++ Software Design by Klaus Iglberger Dec 17, 2022
- C++23: attributes Dec 14, 2022
- C++23: std::out_ptr and std::inout_ptr Dec 7, 2022
- C++23: auto(x) and decay copy Nov 30, 2022
- C++23: How lambdas are going to change? Nov 23, 2022
- C++23: The <expected> header; expect the unexpected Nov 16, 2022
- Why to use C++ in 2022 Nov 9, 2022
- The evolution of statements with initializers in C++ - part 2 Nov 2, 2022
- The evolution of statements with initializers in C++ Oct 26, 2022
- C++23: flat_map, flat_set, et al. Oct 5, 2022
- C++23: The stacktrace library Sep 21, 2022
- C++23: Preprocessing directives Sep 7, 2022
- The Template Method Pattern and the Non-Virtual Idiom Aug 24, 2022
- The copy and swap idiom in C++ Aug 10, 2022
- Trip report: C++ On Sea 2022 Jul 27, 2022
- 6 C++23 features improving string and string_view Jul 20, 2022
- What are string_views and why should we use them? Jul 13, 2022
- Won't extend it more than once! Jul 6, 2022
- C++: standardized Jun 29, 2022
- Bitwise enumerations Jun 22, 2022
- C++23: Narrowing contextual conversions to bool Jun 15, 2022
- Smart pointers and their deleters Jun 8, 2022
- C++23: Consteval if to make compile time programming easier Jun 1, 2022
- C++23: Literal suffix for (signed) size_t May 25, 2022
- C++ basics: scopes, linkage, names May 18, 2022
- Tipi, a new solution to build C++ projects easier May 9, 2022
- Make declaration order layout mandated May 4, 2022
- The 4 use of using in C++ Apr 27, 2022
- The infamous bug of range-based for loops Apr 20, 2022
- Beautiful C++: 30 Core Guidelines for Writing Clean, Safe and Fast Code by J. Guy Davidson and Kate Gregory Apr 16, 2022
- My first work experience with C++20 Apr 13, 2022
- Use strong types instead of bool parameters Apr 6, 2022
- Storing references of pointers in containers in C++ Mar 30, 2022
- C++ basics: Pointers vs iterators Mar 16, 2022
- Mocking non-virtual and free functions with gMock Mar 9, 2022
- Mocking virtual functions with gMock Mar 2, 2022
- The big STL Algorithms tutorial: wrapping up Feb 23, 2022
- C++23: Deducing this Feb 16, 2022
- The big STL Algorithms tutorial: the memory header Feb 2, 2022
- The big STL Algorithms tutorial: *numeric* scans Jan 19, 2022
- The big STL Algorithms tutorial: more numeric algorithms Jan 5, 2022
- What is the most vexing parse? Dec 22, 2021
- Trip Report: CPPP 2021 Dec 15, 2021
- I broke production 3 times in 3 weeks - Part II Dec 1, 2021
- I broke production 3 times in 3 weeks - Part I Nov 24, 2021
- Trip Report: Meeting C++ 2021 Nov 17, 2021
- The big STL Algorithms tutorial: permutation operations Nov 10, 2021
- Functions to be called only once in C++ Oct 27, 2021
- The big STL Algorithms tutorial: reduce operations Oct 20, 2021
- C++ Concepts and the Core Guidelines Oct 13, 2021
- Replace std::find_if in 80% of the cases Sep 29, 2021
- The big STL Algorithms tutorial: comparison operations Sep 22, 2021
- Do we correctly calculate min and max? Sep 8, 2021
- The big STL Algorithms tutorial: Minimum/maximum operations Sep 1, 2021
- const rvalue references Aug 18, 2021
- The big STL Algorithms tutorial: heap operations Aug 4, 2021
- const and smart pointers Jul 21, 2021
- The big STL Algorithms tutorial: set operations Jul 14, 2021
- 2 ways to use static with functions in C++ Jul 7, 2021
- The big STL Algorithms tutorial: merge and inplace_merge Jun 23, 2021
- Multiple destructors with C++ concepts Jun 16, 2021
- C++ Best Practices by Jason Turner Jun 5, 2021
- Different ways to achieve SFINAE Jun 2, 2021
- The big STL Algorithms tutorial: binary_search et al. May 19, 2021
- C++ Concepts and logical operators May 5, 2021
- How to use type traits? Apr 14, 2021
- What are type traits? Apr 7, 2021
- C++ 20: Get the details by Rainer Grimm Apr 3, 2021
- C++ concepts in real life Mar 24, 2021
- How to write your own C++ concepts? Part II. Mar 17, 2021
- How to write your own C++ concepts? Part I. Mar 10, 2021
- Concepts shipped with the C++ standard library Mar 3, 2021
- C++ concepts with classes Feb 24, 2021
- 4 ways to use C++ concepts in functions Feb 17, 2021
- The concept behind C++ concepts Feb 10, 2021
- I released my first book: How to use const in C++ Feb 6, 2021
- The big STL Algorithms tutorial: sorting operations Feb 3, 2021
- Can virtual functions have default arguments? Jan 27, 2021
- The big STL Algorithms tutorial: partitioning operations Jan 20, 2021
- Three ways to use the = delete specifier in C++ Jan 6, 2021
- What is virtual inheritance in C++ and when should you use it? Dec 23, 2020
- A story of nasty a bug: AWS DynamoDB UI special character escaping Dec 16, 2020
- The big STL Algorithms tutorial: modifying sequence operations - rotate functions Dec 9, 2020
- When to use const in C++? Part IV: parameters Nov 25, 2020
- When to use const in C++? Part III: return types Nov 18, 2020
- When to use const in C++? Part II: member variables Nov 11, 2020
- When to use const in C++? Part I: functions and local variables Nov 4, 2020
- User-defined literals in C++ Oct 21, 2020
- Strong types for containers Oct 14, 2020
- Cmake Project Creator at your disposal Sep 30, 2020
- The big STL Algorithms tutorial: modifying sequence operations - how to get distinct elements Sep 8, 2020
- Let me introduce Daily Cpp Interview Sep 2, 2020
- Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library by Scott Meyers Aug 26, 2020
- Covariant return types Aug 19, 2020
- The big STL Algorithms tutorial: modifying sequence operations - rotate functions Aug 12, 2020
- Virtual Trip Report: C++ On Sea 2020 Jul 29, 2020
- Why should we always catch exceptions by reference? Jul 22, 2020
- The big STL Algorithms tutorial: modifying sequence operations - turn things around Jul 15, 2020
- Try-catch everything without macros Jun 24, 2020
- The big STL Algorithms tutorial: modifying sequence operations - remove calls Jun 3, 2020
- Functional Programming in C++ by Ivan Cukic May 28, 2020
- Loops are bad, algorithms are good! Aren't they? May 13, 2020
- The big STL Algorithms tutorial: replace N elements Apr 22, 2020
- The quest of private inheritance in C++ Apr 1, 2020
- The big STL Algorithms tutorial: modifying sequence operations - fill and generate Mar 11, 2020
- Immediately invoked lambda functions Feb 19, 2020
- The big STL Algorithms tutorial: modifying sequence operations - replace* Jan 29, 2020
- Default Member Initializers in C++ Jan 8, 2020
- The big STL Algorithms tutorial: transform's undefined behaviour Dec 18, 2019
- Does this string declaration compile? Nov 27, 2019
- The big STL Algorithms tutorial: transform Nov 6, 2019
- The big STL Algorithms tutorial: modifying sequence operations - move and swap Sep 25, 2019
- The dead singleton and three ways to overcome it Sep 4, 2019
- The big STL Algorithms tutorial: modifying sequence operations - copy et al. Aug 14, 2019
- The big STL Algorithms tutorial: the rest of non-modifying sequence operations Jul 24, 2019
- The C++ Standard Library: A Tutorial and Reference by Nicolai Josuttis Jul 10, 2019
- Travel report: CPPP 2019 Jun 26, 2019
- The big STL Algorithms tutorial: find et al. May 15, 2019
- Parameterized testing with GTest Apr 24, 2019
- The big STL Algorithms tutorial: for_each Apr 3, 2019
- Effective Modern C++ by Scott Meyers Mar 27, 2019
- The Curiously Recurring Template Pattern (CRTP) Mar 13, 2019
- The big STL Algorithms tutorial: all_of, any_of, none_of Feb 20, 2019
- The big STL Algorithms tutorial: Introduction Jan 30, 2019
- Optimized C++ by Kurt Gunteroth Jan 23, 2019
- Lambda Expressions in C++ Dec 19, 2018
- The best 13 books I read this year Dec 12, 2018
- How to use ampersands in C++ Nov 25, 2018
- How do you declare a function in C++? Nov 7, 2018
- Deliberate practice and memory management Aug 29, 2018
- Gilded Rose kata revisited Aug 8, 2018
- The cost of CPU operations Jul 25, 2018
- Why to use the override specifier in C++ 11? Jul 5, 2018
- How to automatically format your C++ code regardless the IDE you use May 30, 2018
- Class initialization and nasty cores Apr 11, 2018
- TDD as if you meant it Jun 7, 2017