Styjun

Short answer:

//usr/bin/clang "$0" && exec ./a.out "$@"
int main()
 return 0;

The trick is that your text file must be both valid C/C++ code and shell script. Remember to exit from the shell script before the interpreter reaches the C/C++ code, or invoke exec magic.

Run with chmod +x main.c; ./main.c.

A shebang like #!/usr/bin/tcc -run isn't needed because unix-like systems will already execute the text file within the shell.

(adapted from this comment)

I used it in my C++ script:

//usr/bin/clang++ -O3 -std=c++11 "$0" && ./a.out; exit
#include <iostream>
int main() 
 for (auto i: 1, 2, 3)
 std::cout << i << std::endl;
 return 0;

If your compilation line grows too much you can use the preprocessor (adapted from this answer) as this plain old C code shows:

#if 0
 clang "$0" && ./a.out
 rm -f ./a.out
 exit
#endif
int main() 
 return 0;

Of course you can cache the executable:

#if 0
 EXEC=$0%.*
 test -x "$EXEC" || clang "$0" -o "$EXEC"
 exec "$EXEC"
#endif
int main() 
 return 0;

Now, for the truly eccentric Java developer:

/*/../bin/true
 CLASS_NAME=$(basename "$0%.*")
 CLASS_PATH="$(dirname "$0")"
 javac "$0" && java -cp "$CLASS_PATH" $CLASS_NAME
 rm -f "$CLASS_PATH/$CLASS_NAME.class"
 exit
*/
class Main 
 public static void main(String[] args) 
 return;
 

D programmers simply put a shebang at the beginning of text file without breaking the syntax:

#!/usr/bin/rdmd
void main()

$ cat /usr/local/bin/runc
#!/bin/bash
sed -n '2,$p' "$@" | gcc -o /tmp/a.out -x c++ - && /tmp/a.out
rm -f /tmp/a.out

$ cat main.c
#!/bin/bash /usr/local/bin/runc

#include <stdio.h>

int main() 
 printf("hello world!n");
 return 0;


$ ./main.c
hello world!

The sed command takes the .c file and strips off the hash-bang line. 2,$p means print lines 2 to end of file; "$@" expands to the command-line arguments to the runc script, i.e. "main.c".

sed's output is piped to gcc. Passing - to gcc tells it to read from stdin, and when you do that you also have to specify the source language with -x since it has no file name to guess from.

Since the shebang line will be passed to the compiler, and # indicates a preprocessor directive, it will choke on a #!.

What you can do is embed the makefile in the .c file (as discussed in this xkcd thread)

#if 0
make $@ -f - <<EOF
all: foo
foo.o:
 cc -c -o foo.o -DFOO_C $0
bar.o:
 cc -c -o bar.o -DBAR_C $0
foo: foo.o bar.o
 cc -o foo foo.o bar.o
EOF
exit;
#endif

#ifdef FOO_C

#include <stdlib.h>
extern void bar();
int main(int argc, char* argv[]) 
 bar();
 return EXIT_SUCCESS;


#endif

#ifdef BAR_C
void bar() 
 puts("bar!");

#endif

The #if 0 #endif pair surrounding the makefile ensure the preprocessor ignores that section of text, and the EOF marker marks where the make command should stop parsing input.

CINT:

CINT is an interpreter for C and C++
code. It is useful e.g. for situations
where rapid development is more
important than execution time. Using
an interpreter the compile and link
cycle is dramatically reduced
facilitating rapid development. CINT
makes C/C++ programming enjoyable even
for part-time programmers.

You might want to checkout ryanmjacobs/c which was designed for this in mind. It acts as a wrapper around your favorite compiler.

#!/usr/bin/c
#include <stdio.h>

int main(void) 
 printf("Hello World!n");
 return 0;

The nice thing about using c is that you can choose what compiler you want to use, e.g.

$ export CC=clang
$ export CC=gcc

So you get all of your favorite optimizations too! Beat that tcc -run!

You can also add compiler flags to the shebang, as long as they are terminated with the -- characters:

#!/usr/bin/c -Wall -g -lncurses --
#include <ncurses.h>

int main(void) 
 initscr();
 /* ... */
 return 0;

c also uses $CFLAGS and $CPPFLAGS if they are set as well.

#!/usr/bin/env sh
tail -n +$(( $LINENO + 1 )) "$0" | cc -xc - && ./a.out "$@"; e="$?"; rm ./a.out; exit "$e"; 

#include <stdio.h>

int main(int argc, char const* argv[]) 
 printf("Hello world!n");
 return 0;

This properly forwards the arguments and the exit code too.

Variatn of John Kugelman can be written in this way:

#!/bin/bash
t=`mktemp`
sed '1,/^//code/d' "$0" | g++ -o "$t" -x c++ - && "$t" "$@"
r=$?
rm -f "$t"
exit $r


//code
#include <stdio.h>

int main() 
 printf("Hin");
 return 0;

Quite a short proposal would exploit:

• The current shell script being the default interpreter for unknown types (without a shebang or a recognizable binary header).


• 
  

  The "#" being a comment in shell and "#if 0" disabling code.

  
  
  

  #if 0
  F="$(dirname $0)/.$(basename $0).bin"
  [ ! -f $F -o $F -ot $0 ] && 
  exec "$F" "$@"
  #endif
  
  // Here starts my C++ program :)
  #include <iostream>
  #include <unistd.h>
  
  using namespace std;
  
  int main(int argc, char **argv) 
   if (argv[1])
   clog << "Hello " << argv[1] << endl;
   else
   clog << "hello world" << endl;
  
  

  
  

Then you can chmod +x your .cpp files and then ./run.cpp.

• You could easily give flags for the compiler.


• The binary is cached in the current directory along with the source, and updated when necessary.


• The original arguments are passed to the binary: ./run.cpp Hi
  


• It doesn't reuse the a.out, so that you can have multiple binaries in the same folder.


• Uses whatever c++ compiler you have in your system.


• The binary starts with "." so that it is hidden from the directory listing.

Problems:

• What happens on concurrent executions?

Here's yet another alternative:

#if 0
TMP=$(mktemp -d)
cc -o $TMP/a.out $0 && $TMP/a.out $@:1 ; RV=$?
rm -rf $TMP
exit $RV
#endif

#include <stdio.h>

int main(int argc, char *argv[])

 printf("Hello worldn");
 return 0;