Re: "A diagram of C23 basic types"

On 04/04/2025 16:14, bart wrote:

On 04/04/2025 14:38, David Brown wrote:

On 04/04/2025 04:50, Janis Papanagnou wrote:

 

Really, that recent!? - I was positive that I used it long before 2017
during the days when I did quite regularly C++ programming. - Could it
be that some GNU compiler (C++ or "C") supported that before it became
C++ standard?
>
Janis
>

>
To be clear, we are talking about :
>
     if (int x = get_next_value(); x > 10) {
         // We got a big value!
     }
>
It was added in C++17.  <https://en.cppreference.com/w/cpp/language/if>
>
gcc did not have it as an extension, but they might have had it in the pre-standardised support for C++17 (before C++17 was published, gcc had "-std=c++1z" to get as many proposed C++17 features as possible before they were standardised.  gcc has similar "pre-standard" support for all C and C++ versions).

 So, this is a proposal still for C, as it doesn't work for any current version of C (I should have read the above more carefully first!).

Yes, that is correct.  The feature has made it into the public drafts for the post-C23 version of C standards, but I have no idea when that will be complete.

 There are appear to be two new features:
 * Allowing a declaration where a conditional expresson normally goes

Yes.

 * Having several things there separated with ";" (yes, here ";" is a separator, not a terminator).

Two things, rather than several.
Thus:
if (int x = get_next_value()) {
...
}
is equivalent to :
if (int x = get_next_value(); x) {
...
}
and
{
int x = get_next_value();
if (x) {
...
}
}
<https://open-std.org/JTC1/SC22/WG14/www/docs/n3467.pdf>
Page 163 (labelled page numbers) or page 179 (of the pdf).

 Someone said they weren't excited by my proposal of being able to leave out '#include <stdio.>'. Well I'm not that excited by this.

OK.  I would not expect you to be - you prefer your variables to be declared at the head of functions rather than at minimal scope.  For other C programmers, this is similar to "for (int i = 0; i < 10; i++)" and will likely be quite popular once C23 support gets established.

 In fact I would actively avoid such a feature, as it adds clutter to code. It might look at first as though it saves you having to add a separate declaration, until you're writing the pattern for the fourth time in your function and realised you now have 4 declarations for 'x'!
 And also the type of 'x' is hardcoded in four places instead of one (so if 'get_next_value' changes its return type, you now have more maintenance and a real risk of missing out one).
 

I think your counting is off.
if (int x = get_next_value()) { ... }
is /one/ use of "x".
A C90 style of :
int x;
...
x = get_next_value();
if (x) { ... }
is /three/ uses of "x".
Different arrangements and conditionals will have different counts, of course.
But a major point of having small scopes is that the length and description power of an identifier should be roughly proportional to its scope.  A variable that exists throughout a sizeable function needs a longer and more descriptive name than a short-lived variable in a small scope, whose purpose is immediately obvious from a few lines of code.

(If you say that those 4 instances could call different functions so each 'x' is a different type, then it would be a different kind of anti-pattern.)
 Currently it would need this (it is assumed that 'x' is needed in the body):
      int x;
      if ((x = getnextvalue()) > 10) {
           // We got a big value!
     }
 It's a little cleaner. (Getting rid of those outer parameter parentheses would be far more useful IMO.)
 (My language can already do this stuff:
      if int x := get_next_value(); x > 10 then
         println "big"
     fi
 But it is uncommon, and it would be over-cluttery even here. However I don't have the local scope of 'x' that presumably is the big deal in the C++ feature.)

Yes, small scope is the point.  Small scopes are better than big scopes (within reason).