Re: C23 auto x C++ auto.

On 26/05/2024 18:38, Thiago Adams wrote:

Em 5/26/2024 1:10 PM, David Brown escreveu:

On 26/05/2024 16:22, Bonita Montero wrote:

Am 26.05.2024 um 15:49 schrieb Thiago Adams:

I think most people is not aware of this:
>
 From 3096 C23 draft
>
"
6.7.9 Type inference
...
  2 For such a declaration that is the definition of an object the init-    declarator shall have the form
>
    direct-declarator = assignment-expression
"
>
Basically "direct-declarator" differs from "declarator" because it does not contains pointer.
>
Then the type inference using auto and pointer is something undefined in C23.
>
struct node{
     struct node * next;
>
};
int main(){
    struct node node = {};
    auto * p = node.next;
}
>
<source>:7:4: error: 'auto' requires a plain identifier, possibly with attributes, as declarator
     7 |    auto * p = node.next;
       |    ^~~~
>
This differs from C++.
>
>

>
I don't know what type inference in C is good for since the type names
in C are usually short. If I have short typenames in C++ I don't use
type inference. Type-inference makes sense to make such things shorter
     typename map<string, string>::const_iterator it = map.cbegin();
This doesn't happen in C.
>

>
"typeof" and "auto" have been available forever as gcc extensions (where "auto" was spelt "__auto_type", since of course "auto" had another meaning in C until C23).  One use-case for C is in macros that handle multiple types, but I expect people have done other things with them too.
>
It would have been nice to see statement expressions included in C23, as they have been in gcc for ages:
>
#define max(a,b) \
   ({ __auto_type _a = (a); \
       __auto_type _b = (b); \
     _a > _b ? _a : _b; })
>
>
In general, it's just another tool that could be useful in writing code that's a bit more flexible.
>

 I am trying to remember the situation where typeof cannot be used, justifying the existence of auto other than "easy to read".

"Easy to read" is a pretty good justification for a feature, IMHO.
The gcc documentation at <https://gcc.gnu.org/onlinedocs/gcc/Typeof.html> lists two more advantages of "__auto_type" over "typeof" (in situations where either could be used) :
"""
* Each argument to the macro appears only once in the expansion of the macro. This prevents the size of the macro expansion growing exponentially when calls to such macros are nested inside arguments of such macros.
* If the argument to the macro has variably modified type, it is evaluated only once when using __auto_type, but twice if typeof is used.
"""
(This last one is only likely to be an issue if you are trying hard to make your code painful to test the corner-cases of VLAs.)

    #define max(a,b) \
     ({ typeof(a) _a = (a); \
         typeof(a) _b = (b); \
       _a > _b ? _a : _b; })
 I think for function calls typeof can be a little confusing because the arguments.
 typeof(f(arg1, arg2)) r = f(arg1, arg2);
auto r = f(arg1, arg2);
 

That looks like another good case.  The results (the type of r) will be the same, and "f" will only be evaluated once, but it certainly doesn't look nice.  And it gets messy if there are macros involved.