将 C 或 C++ 文件作为脚本运行

Question

所以这可能是一个长镜头，但是有没有办法将 C 或 C++ 文件作为脚本运行？我试过了：

#!/usr/bin/gcc main.c -o main; ./main

int main(){ return 0; }

但它说：

./main.c:1:2: error: invalid preprocessing directive #!

Answer 1

简答：

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

诀窍在于您的文本文件必须是有效的 C/C++ 代码和 shell 脚本。记得在解释器到达 C/C++ 代码之前从 shell 脚本中 exit，或者调用 exec 魔法。

使用chmod +x main.c; ./main.c 运行。

不需要像 #!/usr/bin/tcc -run 这样的 shebang，因为类 unix 系统已经在 shell 中执行文本文件。

（改编自this comment）

---

我在我的 C++ 脚本中使用了它：

//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;
}

如果您的编译行增长过多，您可以使用预处理器（改编自 this answer），正如这段普通的旧 C 代码所示：

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

当然你可以缓存可执行文件：

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

---

现在，对于真正古怪的 Java 开发人员：

/*/../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 程序员只需在文本文件的开头放置一个 shebang，而不会破坏语法：

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

---

见：

• https://unix.stackexchange.com/a/373229/23567
• https://stackoverflow.com/a/12296348/199332

Answer 2

对于 C，您可以查看 tcc，即 Tiny C 编译器。将 C 代码作为脚本运行是其可能的用途之一。

Answer 3

$ 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!

sed 命令获取.c 文件并去除hash-bang 行。 2,$p 表示将第 2 行打印到文件末尾； "$@" 扩展为 runc 脚本的命令行参数，即 "main.c"。

sed 的输出通过管道传送到 gcc。将- 传递给 gcc 告诉它从标准输入读取，当你这样做时，你还必须用-x 指定源语言，因为它没有文件名可供猜测。

Answer 4

由于 shebang 行将被传递给编译器，并且 # 表示预处理器指令，它会在 #! 上阻塞。

您可以做的是将 makefile 嵌入到 .c 文件中（如 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

围绕 makefile 的 #if 0 #endif 对确保预处理器忽略该文本部分，并且 EOF 标记标记 make 命令应该停止解析输入的位置。

Answer 5

CINT:

CINT 是 C 和 C++ 的解释器 代码。它很有用，例如对于情况 哪里更快速发展 比执行时间重要。使用 编译和链接的解释器 周期大大缩短 促进快速发展。 CINT 甚至使 C/C++ 编程变得愉快 适合兼职程序员。

Answer 6

#!/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;
}

这也正确地转发了参数和退出代码。

Answer 7

您可能想查看专为此设计的ryanmjacobs/c。它充当您最喜欢的编译器的包装器。

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

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

使用c 的好处是您可以选择要使用的编译器，例如

$ export CC=clang
$ export CC=gcc

因此，您也可以获得所有您最喜欢的优化！击败tcc -run！

您还可以将编译器标志添加到 shebang，只要它们以 -- 字符终止：

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

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

c 也使用$CFLAGS 和$CPPFLAGS（如果它们也已设置）。

Answer 8

很短的提议会利用：

• 当前的 shell 脚本是未知类型的默认解释器（没有 shebang 或可识别的二进制标头）。

• “#”是 shell 中的注释，“#if 0”是禁用代码。

  #if 0
  F="$(dirname $0)/.$(basename $0).bin"
  [ ! -f $F  -o  $F -ot $0 ] && { c++ "$0" -o "$F" || exit 1 ; }
  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;
  }
  

然后你可以chmod +x你的.cpp文件然后./run.cpp。

• 您可以轻松地为编译器指定标志。
• 二进制文件与源代码一起缓存在当前目录中，并在必要时更新。
• 原始参数被传递给二进制文件：./run.cpp Hi
• 它不重复使用a.out，因此您可以在同一个文件夹中拥有多个二进制文件。
• 使用系统中的任何 c++ 编译器。
• 二进制文件以“.”开头以便它在目录列表中隐藏。

问题：

• 并发执行会发生什么？

Answer 9

John Kugelman 的变体可以这样写：

#!/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("Hi\n");
    return 0;
}

Answer 10

这是另一种选择：

#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 world\n");
  return 0;
}

Answer 11

我知道这个问题不是最近的问题，但我还是决定将我的答案混入其中。 使用 Clang 和 LLVM，无需写出中间文件或调用外部帮助程序/脚本。 (除了clang/clang++/lli)

您可以将 clang/clang++ 的输出通过管道传输到 lli。

#if 0
CXX=clang++
CXXFLAGS="-O2 -Wall -Werror -std=c++17"
CXXARGS="-xc++ -emit-llvm -c -o -"
CXXCMD="$CXX $CXXFLAGS $CXXARGS $0"
LLICMD="lli -force-interpreter -fake-argv0=$0 -"
$CXXCMD | $LLICMD "$@" ; exit $?
#endif

#include <cstdio>

int main (int argc, char **argv) {
  printf ("Hello llvm: %d\n", argc);
  for (auto i = 0; i < argc; i++) {
    printf("%d: %s\n", i, argv[i]);
  }
  return 3==argc;
}

但是，以上内容不允许您在 c/c++ 脚本中使用标准输入。 如果 bash 是您的 shell，那么您可以执行以下操作来使用标准输入：

#if 0
CXX=clang++
CXXFLAGS="-O2 -Wall -Werror -std=c++17"
CXXARGS="-xc++ -emit-llvm -c -o -"
CXXCMD="$CXX $CXXFLAGS $CXXARGS $0"
LLICMD="lli -force-interpreter -fake-argv0=$0"
exec $LLICMD <($CXXCMD) "$@"
#endif

#include <cstdio>

int main (int argc, char **argv) {
  printf ("Hello llvm: %d\n", argc);
  for (auto i = 0; i < argc; i++) {
    printf("%d: %s\n", i, argv[i]);
  }
  for (int c; EOF != (c=getchar()); putchar(c));
  return 3==argc;
}

Answer 12

有几个地方建议 shebang (#!) 应该保留，但它对于 gcc 编译器是非法的。所以有几个解决方案把它删掉了。此外，可以插入预处理器指令，在 c 代码错误的情况下修复编译器消息。

#!/bin/bash
#ifdef 0 
xxx=$(mktemp -d)
awk 'BEGIN 
 { print "#line 2 \"$0\""; first=1; } 
 { if (first) first=0; else print $0 }' $0 |\
g++ -x c++ -o ${xxx} - && ./${xxx} "$@"
rv=$?
\rm ./${xxx}
exit $rv
#endif
#include <iostream>
int main(int argc,char *argv[]) { 
  std::cout<<"Hello world"<<std::endl; 
}

Answer 13

如上一个答案所述，如果您使用 tcc 作为编译器，则可以将 shebang #!/usr/bin/tcc -run 作为源文件的第一行。

但是，有一个小问题：如果你想编译同一个文件，gcc 将抛出一个error: invalid preprocessing directive #!（tcc 将忽略 shebang 并编译得很好）。

如果您仍然需要使用gcc 进行编译，一种解决方法是使用tail 命令从源文件中切断shebang 行，然后再将其通过管道传输到gcc：

tail -n+2 helloworld.c | gcc -xc -

请记住，所有警告和/或错误都会消失一行。

您可以通过创建一个 bash 脚本来自动检查文件是否以 shebang 开头，例如

if [[ $(head -c2 $1) == '#!' ]]
then
  tail -n+2 $1 | gcc -xc -
else
  gcc $1
fi

并使用它来编译您的源代码，而不是直接调用gcc。

Answer 14

只是想分享一下，感谢 Pedro 对使用 #if 0 技巧的解决方案的解释，我已经更新了我在 TCC (Sugar C) 上的 fork，以便最终可以使用 shebang 调用所有示例，在查找源代码时没有错误在 IDE 上。

现在，在 VS Code 中使用 clangd 为项目源代码显示精美的代码。示例第一行如下所示：

#if 0
  /usr/local/bin/sugar `basename $0` $@ && exit;
  // above is a shebang hack, so you can run: ./args.c <arg 1> <arg 2> <arg N>
#endif

这个项目的初衷一直是使用 C，就像使用 TCC 底层的脚本语言一样，但客户端优先考虑 ram 输出而不是文件输出（没有 -run 指令）。

您可以通过以下方式查看该项目：https://github.com/antonioprates/sugar