coderbyte is an online coding challenge site (found it just 2 minutes ago).

The first C++ challenge you are greeted with has a C++ skeleton you need to modify:

#include <iostream>
#include <string>
using namespace std;

int FirstFactorial(int num) 

 // code goes here 
 return num; 



int main() 

 // keep this function call here
 cout << FirstFactorial(gets(stdin));
 return 0;

If you are little familiar with C++ the first thing^* that pops in your eyes is:

int FirstFactorial(int num);
cout << FirstFactorial(gets(stdin));

So, ok, the code calls gets which is deprecated since C++11 and removed since C++14 which is bad in itself. But then I realize: gets is of type char*(char*). So it shouldn't accept a FILE* parameter and the result shouldn't be usable in the place of an int parameter, but ... not only it compiles without any warnings or errors but it runs and actually passes the correct input value to FirstFactorial.

Outside of this particular site the code doesn't compile (as expected) so what is going on here?

^{*Actually the the first one is using namespace std but that is irrelevant to my issue here.}

PS we need a makes-no-sense tag (although it would be misused).

I am intrigued. So, time to put the investigation goggles on and since I don't have access to the compiler or compilation flags I need to get inventive. Also because nothing about this code makes sense it's not a bad idea question every assumption.

First let's check the actual type of gets. I have a little trick for that:

template <class> struct Name;

int main() 

 Name<decltype(gets)> n;

 // keep this function call here
 cout << FirstFactorial(gets(stdin));
 return 0;

And that looks ... normal:

/tmp/613814454/Main.cpp:16:19: warning: 'gets' is deprecated [-Wdeprecated-declarations]
 Name<decltype(gets)> n;
 ^
/usr/include/stdio.h:638:37: note: 'gets' has been explicitly marked deprecated here
extern char *gets (char *__s) __wur __attribute_deprecated__;
 ^
/usr/include/x86_64-linux-gnu/sys/cdefs.h:254:51: note: expanded from macro '__attribute_deprecated__'
# define __attribute_deprecated__ __attribute__ ((__deprecated__))
 ^
/tmp/613814454/Main.cpp:16:26: error: implicit instantiation of undefined template 'Name<char *(char *)>'
 Name<decltype(gets)> n;
 ^
/tmp/613814454/Main.cpp:12:25: note: template is declared here
template <class> struct Name;
 ^
1 warning and 1 error generated.

gets is marked as deprecated and has the signature char *(char *). But then how is FirstFactorial(gets(stdin)); compiling?

Let's try something else:

int main() 
 Name<decltype(gets(stdin))> n;

 // keep this function call here
 cout << FirstFactorial(gets(stdin));
 return 0;

 

Which gives us:

/tmp/286775780/Main.cpp:15:21: error: implicit instantiation of undefined template 'Name<int>'
 Name<decltype(8)> n;
 ^

Finally we are getting something: decltype(8). So the entire gets(stdin) was textually replaced with the input (8).

And the things get weirder. The compiler error continues:

/tmp/596773533/Main.cpp:18:26: error: no matching function for call to 'gets'
 cout << FirstFactorial(gets(stdin));
 ^~~~
/usr/include/stdio.h:638:14: note: candidate function not viable: no known conversion from 'struct _IO_FILE *' to 'char *' for 1st argument
extern char *gets (char *__s) __wur __attribute_deprecated__;

So now we get the expected error for cout << FirstFactorial(gets(stdin));

I checked for a macro and since #undef gets seems to do nothing it looks like it isn't a macro.

But

std::integral_constant<int, gets(stdin)> n;

It compiles.

But

std::integral_constant<int, gets(stdin)> n; // OK
std::integral_constant<int, gets(stdin)> n2; // ERROR wtf??

Doesn't with the expected error at the n2 line.

And again, almost any modification to main makes the line cout << FirstFactorial(gets(stdin)); spit out the expected error.

Moreover the stdin actually seems to be empty.

So I can only conclude and speculate they have a little program that parses the source and tries (poorly) to replace gets(stdin) with the test case input value before actually feeding it into the compiler. If anybody has a better theory or actually knows what they are doing please share!

This is obviously a very bad practice. While researching this I found there is at least a question here (example) about this and because people have no idea that there is a site out there who does this their answer is "don't use gets use ... instead" which is indeed a good advice but only confuses the OP more since any attempt at a valid read from stdin will fail on this site.

TLDR

gets(stdin) is invalid C++. It's a gimmick this particular site uses (for what reasons I cannot figure out). If you want to continue to submit on the site (I am neither endorsing it neither not endorsing it) you have to use this construct that otherwise would not make sense, but be aware that it is brittle. Almost any modifications to main will spit out an error. Outside of this site use normal input reading methods.

I tried the following addition to main in the coderbyte editor:

std::cout << "gets(stdin)";

Where the mysterious and enigmatic snippet gets(stdin) appears inside a string literal. This shouldn't possibly be transformed by anything, not even the preprocessor, and any C++ programmer should expect this code to print the exact string gets(stdin) to the standard output. And yet we see the the following output, when compiled and run on coderbyte:

8

Where the value 8 is taken straight from the convenient 'input' field under the editor.

From this, it's clear that this online editor is performing blind find-and-replace operations on the source code, substitution appearances of gets(stdin) with the user's 'input'. I would personally call this an abomination and abuse of the language that's far worse than careless preprocessor macros.

In the context of an online coding challenge website, I would shun this, firstly because it teaches unconventional, non-standard, meaningless, and at least unsafe practices like gets(stdin), and secondly because it teaches that such a construct is basically the hand of god reaching through your source code, defying all syntax and rules.

I'm sure it can't be this hard to just use std::cin and just stream input to a program.