Design Patterns VS Design Principles: Template Method
▻https://www.fluentcpp.com/2021/11/17/design-patterns-vs-design-principles-template-method
In today’s episode of “Design Pattens VS Design Principles” series, we relate the Template Method design patterns to more general design principles. We’re showing how it relates to the Polymorphism design principle. The GoF Meets the GRASP If you’re just joining us in the series, here is what it’s about: we’re going over each of the […]
CPPP – An international C++ Conference with a hint of French accent
▻https://www.fluentcpp.com/2021/11/10/cppp-an-international-c-conference-with-a-hint-of-french-accent
Here is a quick update on a conference that I like. It has a very attractive program, a very reasonable ticket price, and is held in Paris. A nice reason to come around and visit the city and improve your C++ skills at the same time! The CPPP conference will hold its second edition fully […]
Strong Types for Safe Indexing in Collections – Part 2
▻https://www.fluentcpp.com/2021/11/04/strong-types-for-safe-indexing-in-collections-part-2
In the previous article on strong types, we set out to find how to use strong types for safe indexing in collections. More precisely, if we have two vectors with two indices to access them, how can we use strong types to make sure we use the right index for the right vector, and that […]
Strong Types for Safe Indexing in Collections – Part 1
▻https://www.fluentcpp.com/2021/10/31/strong-types-for-safe-indexing-in-collections-part-1
Strong types make code safer and more expressive by using the type system to identify individual objects. For example, to instantiate a class Rectangle with a certain width and height, we could write this: Rectangle myRectangle4, 5; But then it isn’t clear for a reader of the code which of the two parameters is the […]
Design Patterns VS Design Principles: Observer, State and Strategy
▻https://www.fluentcpp.com/2021/10/19/design-patterns-vs-design-principles-observer-state-and-strategy
In this series of articles on design patterns and design principles, we analyse how the 23 GoF design patterns relate to the 9 GRASP design principles. In a previous article, we classified the GRASP patterns like this (excluding “Managing complexity”): The study we perform in this series is helpful to understand better both the GoF […]
A Recap on User Defined Literals
▻https://www.fluentcpp.com/2021/10/08/a-recap-on-user-defined-literals
User defined literals were introduced in C++11, evolved in C++14 and C++17, and are a nice way to write more expressive code. The general idea behind user defined literals is that they allow to write a value and tack on a term describing what this value represents. For example: auto const quantity = 42_bottles_of_water; In […]
A Case Study for the Quickest Way to Find the Source of a Bug
▻https://www.fluentcpp.com/2021/09/27/a-case-study-for-the-quickest-way-to-find-the-source-of-a-bug
In the previous post, I went through the most efficient method I know to find the source of a bug. Here it is, summed up: 0) Don’t start by looking at the code 1) Reproduce the bug 2) Do differential testing __2a) Start with a tiny difference __2b) Continue with larger differences 3) Formulate hypotheses […]
3 Steps to Find the Source of a Bug Quickly
▻https://www.fluentcpp.com/2021/09/22/3-steps-to-find-the-source-of-a-bug-quickly
Do you like doing maintenance as a software activity? Most people don’t. Maintenance is often associated with trudging through lines of code with the debugger in a desperate search for bugs, in software that someone else wrote. All in all, maintenance gets the reputation of being an unrewarding activity, with low intellectual stimulation and not […]
Design Patterns VS Design Principles: Iterator, Mediator and Memento
▻https://www.fluentcpp.com/2021/09/12/design-patterns-vs-design-principles-iterator-mediator-and-memento
In our objective to understand how the GoF design patterns relate to the GRASP design principles, we’re going to analyse 3 more Behavioural patterns today: Iterator, Mediator and Memento. Summary of the previous episodes As a reminder, the GRASP principles are a set of 9 design principles that help take design decisions about where to […]
How to Make Your Classes Compatible with Range for Loop
▻https://www.fluentcpp.com/2021/09/02/how-to-make-your-classes-compatible-with-range-for-loop
Today we have a question from Fluent C++ reader Nithin: Hi Jonathan, Thank you for the very useful Fluent C++ site. I am learning a lot from the site and applying things that I learn from there to write more expressive code. I have several classes in my code base as below. Let’s say I […]
How to Define Comparison Operators by Default in C++
▻https://www.fluentcpp.com/2021/08/23/how-to-define-comparison-operators-by-default-in-c
Implementing comparison operators in C++ is easier said than done. Indeed, for most types, if we could talk to the compiler we would say something like: “to order them, use a lexicographical order on their members”. But when it comes to writing the corresponding code, things get more complicated. However, a classical technique using std::tuple makes […]
How Template Template Parameters Can Simplify Template Classes
▻https://www.fluentcpp.com/2021/08/13/how-template-template-parameters-can-simplify-template-classes
Fluent C++ reader Sam wrote to me asking how to make a template expression simpler. This is an interesting question and I’m grateful to Sam for bringing it up. We’re going to examine this case where template parameters became unwieldy, and see how to simplify them by using template template parameters. The case Let’s have a […]
Don’t Let Legacy Code Make You Suffer. Make It Suffer
▻https://www.fluentcpp.com/2021/08/04/dont-let-legacy-code-make-suffer-make-suffer
Feeling like the codebase you’re working on is poorly designed? Wish you could focus on writing good code, rather than trudging through mud code all day long? Would life be easier if only the legacy codebase had a clearer structure? If you answered Yes to any of those questions, be aware that you’re not alone. […]
Design Patterns VS Design Principles: Chain of responsibility, Command and Interpreter
▻https://www.fluentcpp.com/2021/07/26/design-patterns-vs-design-principles-chain-of-responsibility-command-and-
More than an exact science, designing our code is a craft (there is even a branch of software development that is called software craftsmanship). To guide us through this craft of designing our code we have guidelines that have been accumulated over the ages (or rather, decades) by software developers. 23 of them have been […]
Extended Aggregate Initialisation in C++17
▻https://www.fluentcpp.com/2021/07/17/extended-aggregate-initialisation-in-c17
By upgrading a compiler to C++17, a certain piece of code that looked reasonable stopped compiling. This code doesn’t use any deprecated feature such as std::auto_ptr or std::bind1st that were removed in C++ 17, but it stopped compiling nonetheless. Understanding this compile error will let us better understand a new feature of C++17: extended aggregate initialisation. The […]
How to Return Several Values from a Function in C++
▻https://www.fluentcpp.com/2021/07/09/how-to-return-several-values-from-a-function-in-c
Functions should take their inputs as parameters and produce outputs with their return types. This is the basics of functions interface design. This makes functions easier to understand just by looking at their prototype. It makes functions functional. But C++ only allows to return one value out of a function. What if we’d like to […]
GRASP: 9 Must-Know Design Principles for Code
▻https://www.fluentcpp.com/2021/06/23/grasp-9-must-know-design-principles-for-code
In order to write code that is understandable, maintainable and that stands the test of time, one of the crucial skills that we all need to have is design. What does code design mean? In my definition, doing code design means deciding which class (or more generally which component) is in charge of which responsibility. […]
5 Tips to Find Your Way Around A Legacy Codebase
▻https://www.fluentcpp.com/2021/06/15/5-tips-to-find-your-way-around-legacy-code
Have you ever struggled to understand a codebase that was bigger than you? Most of us go through this experience more or less often in our career, and this is not a simple thing to do. Chances are you’re in this situation right now. During one occurence of the Software Craftsmanship meetup somebody was asking for advice […]
How to Define A Variadic Number of Arguments of the Same Type – Part 5
▻https://www.fluentcpp.com/2021/06/07/how-to-define-a-variadic-number-of-arguments-of-the-same-type-part-5
Defining a variadic pack of arguments of the same type turns out to be a deep topic as this is the fifth post and seventh technique we (I or guest writer Tobias in Part 4) discover on this topic. C++ variadic templates allow to define a parameters pack with any number of parameters of any […]
How to Insert Several Elements in a Vector (With No Memory Errors)
▻https://www.fluentcpp.com/2021/05/30/how-to-insert-several-elements-in-a-vector-with-no-memory-errors
Inserting elements in a vector sounds like the most basic use case we can think of when it comes to using collections in C++. Nevertheless, this is a complex topic in itself, because std::vector offers various ways to insert several elements. Choosing the most appropriate depending on your exact use case allows to write more expressive […]