Comments on: Named Arguments in C++

By: Adversus

Adversus — Fri, 14 Dec 2018 19:59:00 +0000

Good read! Note that there are some stray `NamedTypeImpl` that should probably be `NamedType`.

By: Matthew von Arx

Matthew von Arx — Fri, 14 Dec 2018 19:13:00 +0000

In reply to Lesley Lai. I saw Richards talk as well, but I appreciate the different approach shown here. It is more dependent on the core language and the standard library while Richard's was using Boost::Hana to accomplish his hack. I'm not specifically judging which I think is better, just wanted to provide context to your comment on Richard's approach.

By: Alf P. Steinbach

Alf P. Steinbach — Fri, 14 Dec 2018 16:14:00 +0000

Strong coincidence, a few weeks ago I was thinking of writing an article like this for a Norwegian magazine. The same idea of representing arguments via strong typing, from the Boost Parameter library, except that I defined an argument pack type with custom features, instead of relying on `std::tuple`. I think you should at least have mentioned the Boost Parameters library, because even though today it’s unusable C++03 stuff (I think, due to the silly and fragile macro based domain specific language that it defines, it was unusable also in the C++03 days: I never heard of anyone using it), it introduced the main ideas.

I dropped the article after I realized that there was no good way of making the argument types for a function `f` available unqualified in a context where more than one such function could be used.

I toyed with the idea of a macro for invocation, with that macro using a lambda and either `using namespace;` or an ADL argument. But when I tried out I found that it was just too awkward. What’s needed appears to be a language feature opposite of ADL, a Function Dependent Lookup of argument types, FDL.

By: jft

jft — Fri, 14 Dec 2018 14:07:00 +0000

As was pointed out in a comment to this post https://www.fluentcpp.com/2018/11/30/function-parameters-3/
there is already the Boost Parameter Library. See https://www.boost.org/doc/libs/1_68_0/libs/parameter/doc/html/index.html

As I mentioned in that post, IMO to do this ‘properly’ requires compiler support as the ‘named argument’ should be specified separately to the parameter variable. Something like:


void func1(.param1 int a, .param2 int b)
{
   ....
}

func1(.param2 = 3, .param1 = 4);

This type of argument passing has been previously considered and rejected by the c++ standards committee – so I don’t know….

By: Benoît Thouy

Benoît Thouy — Fri, 14 Dec 2018 09:54:00 +0000

Loss of clarity, for sure, the prototype is completely obscure. Plus plenty of static objects through the code.
IMO, named arguments are useful when you need to deal with optional arguments. With mandatory arguments, you must assign a value to each of them, and code hint system helps a lot to see what is the current argument to set. If we take care about logical ordering in prototyping functions, I think named arguments is just sugar.
For optional arguments (with default values), ordered list seems like a pain, enforcing the coder to recall default values and so on. In that case it sounds better to pass default arguments as a single object, in which we could use named arguments to ease construction, enforce default values and so on. Seems to be an application case of this post … ? 🙂

By: Björn Fahller

Björn Fahller — Fri, 14 Dec 2018 09:38:00 +0000

In reply to Björn Fahller.

I partially take that back. You can, and it’s almost reasonable. Sketchy outline here:

https://gcc.godbolt.org/z/jV58Pp

By: Björn Fahller

Björn Fahller — Fri, 14 Dec 2018 08:15:00 +0000

Two (related) drawbacks (apart from the function signature not really saying what it expects.) There’s no reasonable way of ensuring that all necessary parameters are passed, and there’s no reasonable prevention against passing the same parameter several times.

By: Lesley Lai

Lesley Lai — Fri, 14 Dec 2018 04:40:00 +0000

I prefer this one then Richard’s metaprogramming hack he showed in cppcon.

By: pyxis

pyxis — Fri, 14 Dec 2018 03:40:00 +0000

This is just as much of a horrible hack as every other work around for the missing named arguments feature in c++.