web-dev-qa-db-fra.com

Détermination du nom de l'exécutable C

Lorsque nous compilons un programme C, la sortie est stockée dans a.out. Comment pouvons-nous rediriger la sortie compilée vers un autre fichier?

cgcccompilationexecutablelinkage
27
arun

La plupart des compilateurs C fournissent l'option -o pour cela, telle que:

gcc -o gentext gentext.c
cc  -o mainprog -Llib -lmymath firstbit.c secondbit.o
xlc -o coredump coredump.c
29
paxdiablo

-ofilename fera filename au lieu de a.out.

19
Daniel A. White

Selon le manuel:

-o <file>  Place the output into <file>
8
Arkaitz Jimenez

Sous Unix, d'où provient C, les programmes C sont généralement compilés module par module, puis les modules compilés sont liés à un exécutable. Pour un projet composé des modules foo.c et bar.c, les commandes ressembleraient à ceci:

cc -c foo.c
cc -c bar.c
cc -o myprog foo.o bar.o

(Avec -c, le nom du fichier de sortie devient le fichier source avec le suffixe remplacé par .o.)

Cela vous permet également de ne recompiler que les modules qui ont été modifiés, ce qui peut vous faire gagner beaucoup de temps pour les gros programmes, mais peut aussi devenir assez compliqué. (Cette partie est généralement automatisée à l'aide de make.)

Pour un programme à module unique, il n'est pas vraiment utile de compiler d'abord dans un fichier .o, puis de faire un lien, de sorte qu'une seule commande suffit:

cc -o foo foo.c

Pour les programmes à module unique, il est habituel d'appeler le programme exécutable résultant de la même manière que le fichier source C sans le suffixe .c. Pour les programmes multi-modules, il n’est pas difficile de spécifier si la sortie porte le nom du fichier avec la fonction principale ou non. Vous êtes donc libre d’inventer ce qui vous convient le mieux.

3
user25148

Compiler en utilisant:

cc -o <opfilename> <filename.c>

Exécuter en utilisant:

./<opfilename>
1
KJ Sudarshan

Avec l'option -o.

gcc main.c -o myCoolExecutable.o

Cela ne pose pas de problème si votre programme est constitué d’un seul fichier. Si vous avez plus de fichiers, je suggère d'utiliser make: créez une Makefile puis exécutez la commande make.

Une Makefile est un fichier contenant certaines règles de compilation . Un exemple peut être le suivant (# signifie que la ligne est un commentaire):

CXX = gcc

#CXXFLAGS = -std=c++11
#INC_PATH = ...
#LIBS = ...

SOURCEDIR := yourSourceFolder
SOURCES := $(wildcard $(SOURCEDIR)/*.c)
OBJDIR=$(SOURCEDIR)/obj

OBJECTS := $(patsubst $(SOURCEDIR)/%.c,$(OBJDIR)/%.o, $(SOURCES))
DEPENDS := $(patsubst $(SOURCEDIR)/%.c,$(OBJDIR)/%.d, $(SOURCES))

# ADD MORE WARNINGS!
WARNING := -Wall -Wextra

# .PHONY means these rules get executed even if
# files of those names exist.
.PHONY: all clean

# The first rule is the default, ie. "make",
# "make all" and "make parking" mean the same
all: yourExecutableName

clean:
    $(RM) $(OBJECTS) $(DEPENDS) yourExecutableName

# Linking the executable from the object files
# $^   # "src.c src.h" (all prerequisites)
yourExecutableName: $(OBJECTS)
    $(CXX) $(WARNING) $^ -o $@
    #$(CXX) $(WARNING) $(CXXFLAGS) $(INC_PATH) $^ -o $@ $(LIBS)

-include $(DEPENDS)

$(OBJDIR):
    mkdir -p $(OBJDIR)

$(OBJDIR)/%.o: $(SOURCEDIR)/%.c Makefile | $(OBJDIR)
    $(CXX) $(WARNING) -MMD -MP -c $< -o $@

En bref, la variable CXX définit votre compilateur (gcc, g ++), with CXXFLAGS, vous pouvez définir des indicateurs pour votre compilation (c'est-à-dire -std=c++11). Vous pouvez ensuite inclure et définir une personnalisation (INC_PATH et LIBS: non définis dans l'exemple). Avec SOURCEDIR, vous pouvez spécifier votre répertoire de code source (où se trouvent les fichiers *.c). Ensuite, SOURCES indique en gros que les fichiers source pour la compilation sont tous les fichiers ayant l'extension *.c.

La Makefile contient un ensemble de règles dont la structure est la suivante:

output: inputs
    commandToExecute

La règle pour générer votre fichier exécutable est 

yourExecutableName: $(OBJECTS)
    $(CXX) $(WARNING) $^ -o $@

ce qui équivaut à gcc -Wall -Wextra $(OBJECTS) -o yourExecutableName.

$(OBJECTS) sont le fichier objet résultant de la compilation. Lorsque la règle ci-dessus est exécutée, si elles ne sont pas trouvées, make continuera à analyser le fichier afin de trouver une règle pour les générer. Dans ce cas, la règle pour générer ces fichiers est la suivante:

$(OBJDIR)/%.o: $(SOURCEDIR)/%.c Makefile | $(OBJDIR)
    $(CXX) $(WARNING) -MMD -MP -c $< -o $@

Si des informations supplémentaires sont nécessaires, faites-le moi savoir.

0
Francesco Boi

Si foo sera votre exécutable et bar.c votre fichier source, la commande est la suivante:

gcc -o foo bar.c
0
Albert Davies