Articles contenant le tag C++
Overflow-safe integer mul&div
Posté par Olivier dans Trucs & Astuces le 22 décembre 2023
When you do a multiply & divide operation, to ensure you don’t loose precision, you would start by the multiplication before the division. But in that case, it could be that the result of the multiplication overflows. The natural solution would go to use an intermediate storage of larger size. This uses concepts (C++20). For […]
Clamping values with style
Posté par Olivier dans Trucs & Astuces le 12 mai 2021
The following question was raised in one of our software devs channel at work: On style and readability and intent : std::min or std::clamp or explicit if/reassign. Option 1: int x = someValue;if (x > max) { x = max;} Option 2: int x = std::min(someValue, max); Option 3: int x = std::clamp(someValue, 0, max); […]
Proper handling of temporary objects
Posté par Olivier dans Trucs & Astuces le 10 mars 2021
Purpose Making a wrapper that keeps reference to some constructor arguments.That’s OK as long as the wrapper lifetime is longer or equal to its construction arguments. If the wrapper is created from temporary objects, it should better be used in the same line _or_ it will make reference to possibly destroyed objects. Example Available on […]
The Hidden Dangers of std::function and lambdas
Posté par Olivier dans Trucs & Astuces le 30 septembre 2019
Once upon a time, there was an active object which had callbacks using std::function.On the same day, a user of this object registered a callback function which, in its core, cancelled the registration. That callback was a lambda that aside of that took some reference in the current context.And guess what happened ? Here is […]
boost goodie to clamp numbers
Posté par Olivier dans Trucs & Astuces le 10 juin 2015
How do you clamp a number in a given range in C++ ? Classical way to do it is: double clamped = std::min(maxValue, std::max(minValue, value)) But why repeat this magic formula when boost has clamp() for you ? From now on, do: #include double clamped = boost::algorithm::clamp(value, minValue, maxValue)
Namespace, template typedef and operator overloads – The Evil trio
Posté par Olivier dans Trucs & Astuces le 10 juin 2015
What an unconfortable situation ? I had the following code which would not compile. // Range.h #include <boost/numeric/interval.hpp> #include <iostream> namespace App { template <typename T> using Range = boost::numeric::interval<T>; template <typename T> std::ostream& operator<<(std::ostream &os, const Range<T> &r) { … } } // namespace App // Filter.cpp #include "Range.h" #include <iostream> namespace App { […]
Moving an object that wraps a vector and an iterator on that vector
Posté par Olivier dans Trucs & Astuces le 27 août 2014
I recently stumbled upon code that looked very suspicious to me. Basically, it was a class which amongst other things held a vector and some iterators from that vector. Something like this: struct Wrapper { typedef std::vector<int> Data; Data data; Data::iterator active; Wrapper() : data(), active(data.end()) { } […]
C++ Thread synchronization pitfall: using a barrier to synchronize a thread start
Posté par Olivier dans Trucs & Astuces le 20 novembre 2013
The context: You want to create a worker thread. Before the main thread goes on, you want to ensure that the worker thread starts. Using a boost::barrier seems like a good idea.
std::unique_ptr, virtual and missing virtual destructor = major pitfall
Posté par Olivier dans Trucs & Astuces le 29 août 2013
In our company, the build infrastructure runs unit tests in a valgrind shell, trying to detect memory leaks at the time the unit tests are executed. And every now and then, although our memory allocations are mostly handled through std::unique_ptr or std::shared_ptr, a leak pops up on the radar. And usually with the most useless […]