Excellent article on thread safety and synchronisation from Herb Sutter.
A race condition occurs when two threads access the same shared variable concurrently, and at least one is a non-const operation (writer). Concurrent const operations are valid, and do not race with each other.
Guideline: A type should only be fully internally synchronized if and only if its purpose is to provide inter-thread communication (e.g., a message queue) or synchronization (e.g., a mutex).
Filed under C++, Programming
This is the best book by Jo Nesbo that I’ve read. It stands out due to the quality of the back story that he tells, set during World War I. It’s also set early in the timeline of the lead character, Harry Hole, and includes how he met Rakel (who features heaviliy in other stories including The Snowman).
Filed under Book Review
I’m using GTest for C++ unit tests and have found a neat way to integrate this into Visual Studio 2010. It’s very low-tech, but works pretty well – see http://stackoverflow.com/questions/6414788/how-can-i-add-a-custom-command-to-visual-studio
That’s it! Now, your command runs inside Visual Studio and writes into the output window. Even better, if there’s a test failure that includes the source location, you can double-click on it to go to that line in the editor.
Filed under C++, Programming
Bruce Dawson posted about class layout incompatibilites in Visual C++ 2013.
Filed under C++, Programming
Bruce Dawson posted about an optimizer weakness in VC++.
Using macros to implement Min and Max has numerous well known pitfalls that can be avoided by using template functions. However the definitions of min and max that are mandated by the C++ standard cause VC++ to generate inefficient code. Until the VC++ compiler fixes this it may be best to use custom Min/Max template functions to avoid this problem.
Filed under C++, Programming
I picked this book in my local book shop, not having read anything by this author before. It took a couple of attempts before I was hooked, but once the main character, Joe Pickett, had travelled to YellowStone Park and begun his investigations, I really enjoyed it. The character breaks the mold for this kind of thriller: he isn’t particularly violent (and admits to being rubbish with a weapon) – that side of things is left to his side-kick, Nate); he doesn’t seem all that sure of himself (unlike Jack Reacher or John Corey). He is determined though and the beautiful setting of the main action made this an enjoyable read.
Filed under Book Review
I’ve watched a few of the Going Native 2013 videos now and, whilst I was impressed by Herb Sutter’s games written in Cinder, I particularly like the slide and gather algorithms demonstrated by Sean Parent in his C++ seasoning presentation:
template<typename Iter>
auto slide(Iter begin, Iter end, Iter target) -> std::pair<Iter,Iter>
{
if (target < begin) return std::make_pair( target, std::rotate(target, begin, end) );
if (end < target) return std::make_pair( std::rotate( begin, end, target ), target );
return std::make_pair( begin, end );
}
template<typename Iter, typename Pred>
auto gather(Iter begin, Iter end, Iter target, Pred predicate) -> std::pair<Iter,Iter>
{
auto start = std::stable_partition( begin, target, std::not1(predicate) );
auto finish = std::stable_partition( target, end, predicate );
return std::make_pair(start, finish);
}
Whilst I haven’t used std::rotate or std::stable_partition, I’m sure to use these two algorithms built on top of them, probably because their behaviour is so much easier to describe.
Filed under C++, C++ Code, Programming, Video
DrDobbs posted another example of why you must have proper test coverage in order to avoid introducing regressions into software releases.
Filed under Programming
Jon Kalb posted an article on flat containers in boost.
Alex Stepanov, the STL’s creator, has been quoted as saying, “Use vectors whenever you can. If you cannot use vectors, redesign your solution so that you can use vectors.”
The Boost Container library has a family of flat_* containers that have associative container interfaces and semantics, but are implemented as sorted vectors
Filed under C++, Programming
Searching for a neat data type that can represent either a double or an error (similar to a boost::optional but where the name suggests the possibility of error and the type could hold an error string. I came across this StackOverflow page with an excellent answer by Jon Skeet:
Decimal numbers can be represented exactly, if you have enough space – just not by floating binary point numbers. If you use a floating decimal point type (e.g. System.Decimal in .NET) then plenty of values which can’t be represented exactly in binary floating point can be exactly represented.
Let’s look at it another way – in base 10 which you’re likely to be comfortable with, you can’t express 1/3 exactly. It’s 0.3333333… (recurring). The reason you can’t represent 0.1 as a binary floating point number is for exactly the same reason. You can represent 3, and 9, and 27 exactly – but not 1/3, 1/9 or 1/27.
The problem is that 3 is a prime number which isn’t a factor of 10. That’s not an issue when you want to multiply a number by 3: you can always multiply by an integer without running into problems. But when you divide by a number which is prime and isn’t a factor of your base, you can run into trouble (and will do so if you try to divide 1 by that number).
Although 0.1 is usually used as the simplest example of an exact decimal number which can’t be represented exactly in binary floating point, arguably 0.2 is a simpler example as it’s 1/5 – and 5 is the prime that causes problems between decimal and binary.
Filed under Programming
musingstudio 