Home » Blog » Categories » Articles & Books

Articles & Books

Which One Is Better: Map of Vectors, or Multimap?--Jonathan Boccara

By Adrien Hamelin | Apr 12, 2018 10:24 AM | Tags: intermediate

Depends!

Which One Is Better: Map of Vectors, or Multimap?

by Jonathan Boccara

From the article:

While advising on how to make code more expressive on the SFME project, I came across an interesting case of choosing the right data structure, which I’ll share with you with the permission of the authors of the projects.

We had to associate a key with several values, and perform various operations. Should we use a map of vectors, or is a multimap more appropriate? Let’s see the case in more details, and compare the two solutions...

Overload 144 is now available

By Adrien Hamelin | Apr 12, 2018 10:10 AM | Tags: community

ACCU’s Overload journal of April 2018 is out. It contains the following C++ related articles.

Overload 144 is now available

From the journal:

Deeds not words
Women’s suffrage used the motto “Deeds not Words". Frances Buontempo applies this to programming. by Frances Buontempo

No News is Good News
Using ‘new’ without care can be slow. Paul Floyd uses Godbolt’s compiler explorer to see what happens when you do. by Paul Floyd

Monitoring: Turning Noise into Signal
Creating useful logging is a constant challenge. Chris Oldwood shows us how structured logging helps. by Chris Oldwood

The Interface to Component Pattern and DynaMix
Dynamic Polymorphism is hard in C++. Borislav Stanimirov demonstrates how the DynaMix library helps. by Borislav Stanimirov

5 Reasons NOT to Use std::ostream for Human-Readable Output
C++’s ostream can be hard to use. Sergey Ignatchenko suggests we use the {fmt} library instead. by Sergey Ignatchenko

Practical Cryptographical Theory for Programmers
Cryptography is a daunting subject. Deák Ferenc helps you get started. by Deák Ferenc

Ex Hackina
Machine Learning and AI are popular at the moment. Teedy Deigh takes the Turing test. by Teedy Deigh

Quick Q: Does access control matter for deleted constructors?

By Adrien Hamelin | Apr 9, 2018 02:58 PM | Tags: c++11 advanced

Quick A: No

Recently on SO:

Does access control matter for deleted constructors?

Since it's overload resolution that makes the program ill-formed in this case, and not access specifiers (which are checked later), there is no difference in outcome. The compiler will always complain that a deleted function was picked.

But since the idiom before C++11 was "declare but not define a private copy c'tor to disable copying", I would consider it going along with the same idiom, and therefore favorable. You are using the "old slang" with some new language to describe the same thing, except better.

East End Functions--Phil Nash

By Adrien Hamelin | Apr 9, 2018 02:54 PM | Tags: community c++11

What's your opinion?

East End Functions

by Phil Nash

From the article:

There has been a recent stirring of attention, in the C++ community, for the practice of always placing the const modifier to the right of the thing it modifies. The practice has even been gifted a catchy name: East Const (which, I think, is what has stirred up the interest)...

Getting the Benefits of Strong Typing in C++ at a Fraction of the Cost--Vincent Zalzal

By Adrien Hamelin | Apr 6, 2018 01:56 PM | Tags: intermediate

Very interesting!

Getting the Benefits of Strong Typing in C++ at a Fraction of the Cost

by Vincent Zalzal

From the article:

Strong types promote safer and more expressive code. I won’t repeat what Jonathan has presented already in his series on strong types.

I suspect some people may find that the NamedType class template has a nice interface but is using a somewhat heavy machinery to achieve the modest goal of strong typing. For those people, I have good news: you can achieve many of the functionalities of NamedType, with a very simple tool. That tool is the humble struct...

Parallel Coding: From 90x Performance Loss To 2x Improvement--"No Bugs" Hare

By Adrien Hamelin | Apr 5, 2018 02:20 PM | Tags: performance

Part 2!

Parallel Coding: From 90x Performance Loss To 2x Improvement

by "No Bugs" Hare

From the article:

In my previous post, we have observed pretty bad results for calculations as we tried to use mutexes and even atomics to do things parallel. OTOH, it was promised to show how parallel <algorithm> CAN be used both correctly and efficiently (that is, IF you need it, which is a separate question); this is what we’ll start discussing within this post...

Quick Q: Why does unary operator & not require a complete type?

By Adrien Hamelin | Apr 5, 2018 02:05 PM | Tags: intermediate

Quick A: It only need to take the address.

Recently on SO:

Why does unary operator & not require a complete type?

What if stru has overloaded operator&()?

Then it is unspecified whether the overload will be called (See Oliv's comment for standard quote).

How could unary operator & does not require a complete type?

That's how the standard has defined the language. The built-in address-of operator doesn't need to know the definition of the type, since that has no effect on where to get the address of the object.

One consideration for why it is a good thing: Compatibility with C.

Quick Q: Why does shared_ptr needs to hold reference counting for weak_ptr?

By Adrien Hamelin | Apr 4, 2018 03:19 PM | Tags: intermediate c++11

Quick A: To know when to deallocate the control block.

Recently on SO:

Why does shared_ptr needs to hold reference counting for weak_ptr?

The reference count controls the lifetime of the pointed-to-object. The weak count does not, but does control (or participate in control of) the lifetime of the control block.

If the reference count goes to 0, the object is destroyed, but not necessarily deallocated. When the weak count goes to 0 (or when the reference count goes to 0, if there are no weak_ptrs when that happens), the control block is destroyed and deallocated, and the storage for the object is deallocated if it wasn't already.

The separation between destroying and deallocating the pointed-to-object is an implementation detail you don't need to care about, but it is caused by using make_shared.

If you do

shared_ptr<int> myPtr(new int{10});

you allocate the storage for the int, then pass that into the shared_ptr constructor, which allocates storage for the control block separately. In this case, the storage for the int can be deallocated as early as possible: as soon as the reference count hits 0, even if there is still a weak count.

If you do

auto myPtr = make_shared<int>(10);

then make_shared might perform an optimisation where it allocates the storage for the int and the control block in one go. This means that the storage for the int can't be deallocated until the storage for the control block can also be deallocated. The lifetime of the int ends when the reference count hits 0, but the storage for it is not deallocated until the weak count hits 0.

Is that clear now?