Htydjtk

I am a big fan of CodeSignal, but I found a strange piece of C++ grammar (the first line):

string r, longestDigitsPrefix(string s)

{

   for(auto const c : s)

   {

      if(isdigit(c))

        r += c;

      else

        break;

   }

   return r;

}

Is defining string r, in the function declaration valid in modern C++?

The above code compiles and passes all tests in the CodeSignal console, but it produced a compiler error when I tried to compile locally (--std=c++14).

If this is valid grammar in modern C++ and which standard revision does it comply with?

Yeah, C++ grammar is weird. Basically, when it comes to declarations (and only declarations), we have this thing where:

T D1, D2, ... ,Dn;

means ([dcl.dcl]/3):

T D1;

T D2;

...

T Dn;

This will be familiar in the normal cases:

int a, b; // declares two ints

And probably in the cases you've been told to worry about:

int* a, b, *c; // a and c are pointers to int, b is just an int

But declarators can introduce other things too:

int *a, b[10], (*c)[10], d(int);

Here a is a pointer to int, b is an array of 10 ints, c is a pointer to an array of 10 ints, and d is a function taking an int returning an int.

However, this only applies to declarations. So this:

string r, longestDigitsPrefix(string s);

is a valid C++ declaration that declares r to be a string and longestDigitsPrefix to be a function taking a string and returning a string.

But this:

string r, longestDigitsPrefix(string s) { return s; }

is invalid C++. Function definitions have their own grammar and cannot appear as part of the init-declarator-list.

The definition of that function is also bad, since it's using a global variable to keep track of state. So even if it were valid, longestDigitsPrefix("12c") would return "12" the first time but "1212" the second time...

By reading the ISO C++14 draft N4140 Annex A [gram], I'm pretty sure it's incorrect since I cant find a way to deduce the grammar from a translation unit from

translation-unit -> declaration-seq -> declaration -> block-declaration | function-definition | linkage-specification | ...

function-definition: attribute-specifier-seqopt decl-specifier-seqopt
declarator virt-specifier-seqopt function-body

declarator: ptr-declarator noptr-declarator parameters-and-qualifiers
trailing-return-type

But your line is more the comma operator but its grammar is:

expression:
assignment-expression | expression , assignment-expression

assignment-expression: conditional-expression | logical-or-expression |
assignment-operator | initializer-clause | throw-expression

And there is no way from assignment-expression to function-definition

Update:
Thanks to Barry, another way to try to buttom-up parse your text is by rather try to get from a init-declarator-list (which you can get from block-declaration) to a function-definition:

init-declarator-list: init-declarator | init-declarator-list ,
init-declarator

init-declarator: declarator initializeropt

And

declarator: ptr-declarator noptr-declarator parameters-and-qualifiers
trailing-return-type

Would allow you a function declaration but not definition. So this odd code would be legal:

#include <string>

using std::string;



string r, longestDigitsPrefix(string s);



string longestDigitsPrefix(string s) {

    for(auto const c : s)

    {

        if(isdigit(c))

            r += c;

        else

            break;

    }

    return r;

}



int main(int argc, char *argv) {

    longestDigitsPrefix("foo");



    return 0;

}

However I could be wrong, since I'm not used to use the formal grammar of C++, which is normal since it's grammar is very complex, and has some non trivial behaviour.

To my knowledge, this is not a valid function declaration.

The prefix in functions can be used only as a way to define what type is the function's "returning" variable, not the variable itself.

You can however declare a variable outside your function (thus making it global) and modify it inside the function, as you may have probably attempted, but then you need to pass said variable as a reference in your function's arguments. You would also need to set your function as void, since it is not going to return the variable, but just modify it

Example

std::string foo = "Hello";



void foo_func(std::string &string)

{ //do something with the string

}



//call the function and modify the global "foo" string

foo_func(foo);

Why wouldn't it be possible? After all, it's just two declarations with strings, and they can be grouped. There are examples like this in the cppreference page for declarations; they just lack function bodies.

My g++ (GCC) 8.2.1 allows this within a class. This will compile without warning (-Wall) and return 42.

struct Weird {

    int r, getR() {return r;};

};



int main() {

    Weird w={42};

    return w.getR();

}