Re: Block Comments Or Rest-Of-Line Comments?

On 21/03/2024 22:16, Lawrence D'Oliveiro wrote:

On Thu, 21 Mar 2024 13:37:57 +0200, Mikko wrote:
 

On 2024-03-21 06:19:13 +0000, Lawrence D'Oliveiro said:
>

     gdImageCopyResampled
       (
         /*dst =*/ ResizedFrame,
         /*src =*/ Context.StillFrame, /*dstX =*/ 0,
         /*dstY =*/ 0,
         /*srcX =*/ 0,
         /*srcY =*/ 0,
         /*dstW =*/ ResizedFrame->sx, /*dstH =*/ ResizedFrame->sy,
         /*srcW =*/ Context.StillFrame->sx,
         /*srcH =*/ Context.StillFrame->sy
       );

>
I prefer to put the argument names at the end of the line.

 But putting them in front of the values looks more like the syntax in
languages (like Ada and Python) that do allow specification of argument
keywords.
 

Why would you want your C code to look like Python?  That's as silly as wanting your Python code to look like C code.  The languages are significantly different - each with their strengths and weaknesses, and each suitable for quite different kinds of programming tasks.
I can appreciate wanting to document what the parameters are in a function that takes far too many parameters.  I don't see any benefit in doing so in a way that looks vaguely like an entirely different programming language.
gdImageCopyResampled
(
ResizedFrame, // destination frame
Context.StillFrame, // source frame
0, 0, // destination x, y
0, 0, // source x, y
ResizedFrame->sx, // frame sizes
ResizedFrame->sy,
Context.StillFrame->sx,
Context.StillFrame->sy
);
That is simpler and more informative than your style (IMHO of course).

And maybe, in future, if it becomes valid in C (or some successor), then
updating the code should be as simple as removing the comment symbols.

I am a fan of being able to name parameters in languages that allow it. I am quite confident that this will never come to C.  It /might/ make it into C++, but as people have been writing proposals to do so for 20 years at least, I am not holding my breath.
In the meantime, you can use structs with parameters and use designated initialisers and compound literals to get a similar effect but with a heavier and less flexible syntax.  Or you can use specific types for each parameter, along with macros (or constructors in C++), to ensure that you can't get the parameters mixed up.  Again, it's more boiler plate and a heavier syntax than named parameters would be.