Exécutez la commande C ou C++ en tant que fichier de script

Réponse courte:

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

Le truc, c'est que votre fichier texte doit être à la fois valide code C/C++ et d'un script shell. N'oubliez pas de exit à partir du shell script avant de l'interprète atteint le code C/C++, ou invoquer exec de la magie.

Courir avec chmod +x main.c; ./main.c.

Un beau spectacle comme #!/usr/bin/tcc -run n'est pas nécessaire, parce que les systèmes de type unix déjà exécuter le fichier texte à l'intérieur de la coquille.

(adapté de ce commentaire)

---

Je l'ai utilisé dans mon 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;
}

Si votre ligne de la compilation pousse trop, vous pouvez utiliser le préprocesseur (adapté de cette réponse) comme ce bon vieux C montre le code:

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

Bien sûr, vous pouvez mettre en cache le fichier exécutable:

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

---

Maintenant, pour la vraiment excentrique développeur 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 programmeurs de mettre simplement un beau spectacle au début du fichier texte sans casser la syntaxe:

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

Depuis la ligne shebang seront passés au compilateur, et # indique une directive de préprocesseur, il va s'étouffer sur un #!.

Ce que vous pouvez faire est d'intégrer le makefile dans le .c fichier (tel que discuté dans ce xkcd fil)

#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

La #if 0 #endif paire environnant les makefile assurer le préprocesseur ignore que la section de texte, et le marqueur EOF marque l'endroit où la commande make devrait cesser d'entrée lors de l'analyse.

Vous pourriez voulez extraire ryanmjacobs/c qui a été conçu pour cela à l'esprit. Il agit comme un wrapper autour de votre favori compilateur.

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

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

La bonne chose à propos de l'utilisation de c est que vous pouvez choisir quel compilateur que vous souhaitez utiliser, par exemple,

$ export CC=clang
$ export CC=gcc

De sorte que vous obtenez tous vos favoris optimisations trop! Battre tcc -run!

Vous pouvez également ajouter des drapeaux de compilation pour le shebang, tant qu'ils sont arrêtées avec la -- caractères:

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

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

c utilise également $CFLAGS et $CPPFLAGS si elles sont définies en tant que bien.

Tout à fait une courte proposition serait d'exploiter:

• Le shell en cours de script par défaut interprète pour les types inconnus (sans une arborescence ou un reconnaissable en-tête binaire).

• Le "#" est un commentaire dans la coquille et "#if 0" désactivation du code.

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

Alors vous pouvez chmod +x votre .rpc fichiers puis ./run.cpp.

• Vous pouvez facilement donner des drapeaux pour le compilateur.
• Le binaire est mis en cache dans le répertoire courant le long avec la source, et mis à jour si nécessaire.
• L'original, les arguments sont passés à la binaire: ./run.cpp Hi
• Il n'a pas réutiliser le a.out, de sorte que vous pouvez avoir plusieurs fichiers binaires dans le même dossier.
• Utilise le compilateur c++ que vous avez dans votre système.
• Le binaire commence par "." de sorte qu'il est caché à partir de la liste du répertoire.

Problèmes:

• Ce qui se passe sur les exécutions?

Voici encore une autre 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 world\n");
  return 0;
}