I like that too, but the problem is that C doesn't keep its end of the deal. No hand holding, but make what you are doing transparent. It used to be the case back in the 80s, but not anymore. Not with our optimizing compilers and oodles of UB and spec subtleties and implicit actions.

It's still valid C source code? Is the #! sequence valid C?

Compiler errors won’t cause as many funny consequences with

  gcc "$0" -o "$@".out && exec ./"$@".out || exit $?   # I'd use ${0%.c} not $@

Love this trick too, but the difference, as far as I understand, is that it only works with a Bourne(-compatible) shell, whereas shebangs or binfmt_misc also work with exec().

You can also #embed the compiler binary, and execve it to much the same effect as binfmtc. I explored that trick for an IOCC entry that was never submitted because it ended up far too readable.

Oh this is neat. Took me a bit.

The shell treats the first line as a comment. It executes the second line, which eventually exec's the binary so the rest of the file do not matter to the shell.

And the compiler treats the first line as a preprocessor directive, so it ignores the second line.

I initially misread/mistook the first line for a shebang.

The use of $@ doesn't look right to me.

In the trivial case exposed here where there are no additional arguments to pass to the .c program, the shell executes

  gcc "print.c" -o .out && exec ./.out

and it works "by chance".

In a more complex scenario where print.c expects some parameters, it won't work. For example,

  ./print.c a b c

will result in the shell trying to invoke

  gcc "print.c" -o "a" "b" "c".out && exec ./"a" "b" "c".out

which makes no sense.

Are you sure you didn't intend $0 instead of $@ ?

Is there a way to do this and have the shell remove the temporary file after exec?

   #if 0
   cc -static -pipe -xc "$0"||exit 100
   exec ./a.out
   #endif
   int puts(const char *);
   int unlink(const char *);
   int main(int argc,char *argv[]){ 
   puts("it works"); 
   unlink(argv[0]);
   return 0; 
   }

Or even

    /*bin/true ; exec tcc -run "$0" "$@" # */

I'd have expected this to need a hashbang (#!/bin/sh) at the beginning. Why doesn't it?

This is a neat hack, but the whole file is not a valid C program.

  #!/bin/sh
  c_file=${0%.sh}.c
  x_file=${0%.sh}.bin

  # If cached executable file is missing, or out of date w.r.t.
  # the source file, compile it:

  if [ "$c_file" -nt "$x_file" ]; then
    cc $CFLAGS "$c_file" -o "$x_file"
  fi

  # Run cached executable file
  $x_file