Structured Bindings

Structured bindings tend to be dismissed in many discussions online as very minimal improvements to C++. There isn't very much you can do with them that's not on the package, so to speak: returning multiple values, iterating easily over maps, and initializing more than one variable in an if or switch scope.

The point, however, is not what they allow you to do: everything you can do with them you can do without them. The point is how it is done.

If we compare:

auto [var, flag] = func();

with, say

auto val = func();
auto var = val.first;
auto flag = val.second;

it's not just that we take one line instead of three to get the same result, it's that the latter code has to pay more attention to how rather than what. It draws attention to the fact that was was returned was a pair.

There are at least three other possible mechanisms behind that first line.

auto val = func();
auto var = val[0];
auto flag = val[1];

(an array)

auto val = func();
auto var = get<0>(val);
auto flag = get<1>(val);

(a tuple, or a class implementing a tuple-like interface)

auto val = func();
auto var = val.var;
auto flag = val.flag;

(a struct)

Even with the use of auto, in all these cases one has one's attention drawn to the mechanics of how the data is structured.

This point gets a little lost when random names are used, as above, to expose mechanisms in a comparison. Programming for clarity would lead to something far more like

auto [customerID, isCurrent] = retrieveCustomerInfo();

In the structured binding version almost everything is about the meaning expressed in the variables, whereas

auto customerInfo = retrieveCustomerInfo();
auto customerID = customerInfo.first;
auto isCurrent = customerInfo.second;

is less clear because it is cluttered.

(Without auto - another big help to clarity - this is worse still. The pair version is

std::pair<std::string,, bool> customerInfo = retrieveCustomerInfo();
std::string customerID = customerInfo.first;
bool isCurrent = customerInfo.second;

and the best clarity probably comes from using a specially-defined class or struct, at the cost of slightly greater wordiness, if there's an overall case for having such a class defined with a broader use:

CustomerInfo customerInfo = retrieveCustomerInfo();
std::string customerID = customerInfo.ID;
bool isCurrent = customerInfo.currentFlag;

Of course, in that case might just make sense to pass around the CustomerInfo struct instead of extracting the values at the call site.)

Comments

Post a Comment

Popular posts from this blog

Boundaries

Imagine that you have a well-designed application, possibly using dependency injection. It will almost always have a very thin layer visible in main() - capturing command-line parameters and environment variables, mainly[1], and then a call to an Application class which manages the rest of the initial logic - setting up resources such as logging, doing substantive validation of parameters, and creating and running the objects on the next level down which actually carry out the work of the application. This is simply following the SRP at a high level.
Read more

Overview

The description below applied when it was first written, and has covered a couple of months of posts.  It is no longer entirely inapplicable, but both projects have now been covered, for points if interest, pretty well up from low-level components up to the calling of main(). I am continuing to add posts, but with more general application, and many will not be restricted to spin-offs of the two original projects, nor even necessarily to C++.
Read more

Considerations on an Optimization

An application – actually, successive pair of applications – is meant to process (in the end) about three hundred or so entries to convert a simple markup into complex LaTeX markup. It also enhances the data with information drawn from a flat-file text database (i.e. literally a set of .txt files in a single directory). This application was originally written in rust, which is not my favourite language, but one worth exercising to a degree. The rust application covered a limited subdomain, and generally avoided unsafe rust code, although in some cases it had to use cell mechanisms which converted compile-time to runtime safety. The initial iteration had the text database as one large file, with some logic allowing for extended seeking through chapters. It soon became apparent, after extending my dataset to about twenty or so items, that this was going to result in an unacceptable runtime — it was taking longer to process than the later TeX processing took, and although in theory this w...
Read more