Hacker News Reader

Comment by dgrunwald | Hacker News Reader

What's being removed in C23 is the ancient K&R syntax for function definitions:

    int max(a, b)
    int a, b;
    {
        return a>b?a:b;
    }

My understanding is that C23 does not change the meaning of function declarations. So "void foo();" remains a declaration of a function accepting an unknown number of parameters.

View on HN

According to the OP tweet though, `foo()` is now a function that takes no arguments.

Wouldn't int foo(void) be a function that takes no arguments and int foo() a function that takes an unknown number of arguments?

Yes, that's the problem.

That's a different thing. That's implied `foo(void)`.

It WAS a different thing. That's changing in C23.

Agree the tweet makes it seem the behavior is changing.

Edit: parent is correct it IS changing

> We could make this change because foo() decls and definitions had been deprecated since C89/99, longer than I've been alive.

> Implementations will likely warn on foo() decls for a while, and error if someone calls it with foo(too, many, args);.

https://mobile.twitter.com/__phantomderp/status/149481259506...

Here's the document for that change: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2841.htm

> In this proposal, a function declarator without a parameter list declares a prototype for a function that takes no parameters (like it does in C++).

And it seems like gcc implements this under -std=c2x now:

    zx2c4@thinkpad /tmp $ cat a.c
    int blah()
    {
            return 7;
    }
    
    int main(int argc, char *argv[])
    {
            return blah(argc);
    }
    zx2c4@thinkpad /tmp $ gcc -std=c17 a.c
    zx2c4@thinkpad /tmp $ gcc -std=c2x a.c
    a.c: In function ‘main’:
    a.c:8:16: error: too many arguments to function ‘blah’
        8 |         return blah(argc);
          |                ^~~~
    a.c:1:5: note: declared here
        1 | int blah()
          |     ^~~~

Which is much more consistent, IMO.

int foo(int, int) is a function taking two arguments. int foo(int) is a function taking one argument. int foo() ought to mean a function taking no arguments, not a function with an unspecified number of arguments!

I'm particularly unhappy that K&R declarations are going away without https://www9.open-std.org/JTC1/SC22/WG14/www/docs/n2780.pdf being added to replace them. Now there's some functions that you can't write anymore.

Wow, that's annoying. There's a bunch of old code we have that'll need updating (written that way to keep the line lengths down).

...can't you just configure your build system to compile those modules with pre-c23 standard?

Of course. But one of the great things about C is that as a rule nothing breaks with compiler changes (as long as appropriate care has been taken) which this appears to violate.

Maybe the compiler will add a extension flag? I mean the K&R declarations still need to be supported in the compiler for earlier standards.

All the compilers I use have a default C version, and an optional flag to control which version to use. It's a non-issue.

Reply on news.ycombinator.com