Risposte:
Se si tratta di un semplice programma a sorgente singolo:
make foo
dove il file sorgente è foo.c o foo.cpp, ecc.
Non hai nemmeno bisogno di un makefile. Make ha abbastanza regole integrate per creare il tuo file sorgente in un eseguibile con lo stesso nome, meno l'estensione.
L'esecuzione dell'eseguibile appena creato equivale all'esecuzione di qualsiasi programma, ma molto spesso sarà necessario specificare il percorso dell'eseguibile poiché la shell cercherà solo cosa c'è dentro $PATH
per trovare gli eseguibili, e molto spesso questo non include la directory corrente ( .
).
Quindi, per eseguire l'eseguibile incorporato foo
:
./foo
make main.cpp
, ma make main
.
gcc main.cpp -o main.out
./main.out
Undefined symbols for architecture x86_64
problema, modifico il comando come segue:, gcc -lstdc++ main.cpp -o main.out
e funziona sul mio Mac. tramite collegamento: stackoverflow.com/questions/11852568/...
Questo è il comando che funziona su tutte le macchine Unix ... Lo uso su Linux / Ubuntu, ma funziona anche su OS X. Digita il seguente comando in Terminal.app .
$ g++ -o lab21 iterative.cpp
-o
la lettera O non è zero
lab21
sarà il tuo file eseguibile
iterative.cpp
è il tuo file c ++
Dopo aver eseguito quel comando digitare quanto segue nel terminale per eseguire il programma:
$ ./lab21
Due passaggi per me:
primo:
make foo
poi:
./foo
./foo
non so come la risposta accettata non abbia questo importante comando
Tutta l'esecuzione dell'applicazione in un ambiente Unix (Linux, Mac OS X, AIX, ecc.) Dipende dal percorso di ricerca eseguibile.
È possibile visualizzare questo percorso nel terminale con questo comando:
echo $ PATH
Su Mac OS X (per impostazione predefinita) verrà visualizzato il seguente percorso di ricerca separato da due punti:
/ Usr / bin: / bin: / usr / sbin: / sbin: / usr / local / bin: / usr / X11 / bin
Quindi qualsiasi eseguibile nelle directory elencate può essere eseguito semplicemente digitando il loro nome. Per esempio:
cat mytextfile.txt
Questo viene eseguito /bin/cat
e visualizza mytextfile.txt al terminale.
Per eseguire qualsiasi altro comando che non si trova nel percorso di ricerca dell'eseguibile, è necessario qualificare il percorso dell'eseguibile. Quindi dire che avevo un eseguibile chiamato MyProgram nella mia directory home su Mac OS XI posso qualificarlo completamente in questo modo:
/ Users / oliver / MyProgram
Se ti trovi in una posizione vicina al programma che desideri eseguire, puoi qualificare il nome con un percorso parziale. Ad esempio, se MyProgram
ero nella directory /Users/oliver/MyProject
I ed io ero nella mia home directory, posso qualificare il nome dell'eseguibile in questo modo e farlo eseguire:
MyProject / MyProgram
O dire che ero nella directory /Users/oliver/MyProject2
e che volevo eseguire, /Users/oliver/MyProject/MyProgram
posso usare un percorso relativo come questo, per eseguirlo:
../MyProject/MyProgram
Allo stesso modo se mi trovo nella stessa directory in cui MyProgram
ho bisogno di utilizzare un percorso relativo "directory corrente". La directory corrente in cui ci si trova è il carattere punto seguito da una barra. Per esempio:
./MyProgram
Per determinare quale directory si è attualmente in uso utilizzare il pwd
comando.
Se di solito metti i programmi in un posto sul tuo disco rigido che desideri eseguire senza dover qualificare i loro nomi. Ad esempio, se nella directory home è presente una directory "bin" per gli script di shell utilizzati regolarmente di altri programmi, potrebbe essere saggio modificare il percorso di ricerca eseguibile.
Questo può essere fatto facilmente creando o modificando il .bash_profile
file esistente nella tua home directory e aggiungendo le righe:
#!/bin/sh
export PATH=$PATH:~/bin
Qui il carattere tilde (~) viene utilizzato come scorciatoia per / Users / oliver. Si noti inoltre che la riga hash bang (#!) Deve essere la prima riga del file (se non esiste già). Nota anche che questa tecnica richiede che la shell di accesso sia bash (impostazione predefinita su Mac OS X e la maggior parte delle distribuzioni Linux). Si noti inoltre che se si desidera che i programmi installati ~/bin
vengano utilizzati preferibilmente agli eseguibili di sistema, è necessario riordinare la dichiarazione di esportazione come segue:
export PATH=~/bin:$PATH
Ryan, sto cambiando questo per essere una risposta anziché un commento, dal momento che sembra che sia stato troppo breve. Fai tutto questo in "Terminale".
Per utilizzare il compilatore G ++, è necessario:
Passare alla directory in cui è stato memorizzato il file * .cpp.
cd ~/programs/myprograms/
(la ~ è una scorciatoia per la tua casa, cioè / Users / Ryan / programmi / myprograms /, sostituisci con la posizione che hai effettivamente utilizzato.)
Compilalo
g++ input.cpp -o output.bin
(output.bin può essere qualsiasi cosa con qualsiasi estensione, davvero. bin è comune su unix.)
Non ci dovrebbe essere NULLA restituito se ha avuto successo, e va bene . Generalmente si ottengono ritorni sugli errori.
Tuttavia, se si digita ls
, verrà visualizzato l'elenco dei file nella stessa directory. Ad esempio, vedresti le altre cartelle, input.cpp e output.bin
Dall'interno della directory, ora eseguilo con ./outbut.bin
Un modo compatto per farlo potrebbe essere:
make foo && ./$_
Bello avere un one-liner in modo da poter rieseguire facilmente il tuo eseguibile di nuovo.
Supponendo che la directory corrente non sia nel percorso, la sintassi lo è ./[name of the program]
.
Per esempio ./a.out
Aggiungi seguito per ottenere i migliori avvisi, non te ne pentirai. Se possibile, compilare WISE (l'avviso è un errore)
- Wall -pedantic -Weffc++ -Werror
Per compilare programmi C o C ++, esiste un comando comune:
make filename
./filename
make costruirà il tuo file sorgente in un file eseguibile con lo stesso nome. Ma se vuoi usare il modo standard, potresti usare il compilatore gcc per creare programmi C e g ++ per c ++
Per C:
gcc filename.c
./a.out
Per C ++:
g++ filename.cpp
./a.out
Usa a makefile
. Anche per progetti molto piccoli (= un file), probabilmente ne vale la pena perché è possibile avere diversi set di impostazioni del compilatore per testare le cose. Il debug e la distribuzione funzionano in questo modo molto più facilmente.
Leggi il make
manuale , a prima vista sembra piuttosto lungo, ma la maggior parte delle sezioni si può semplicemente sfogliare. Tutto sommato mi ci sono volute alcune ore e mi ha reso molto più produttivo.
Ho trovato questo link con le indicazioni:
http://www.wesg.ca/2007/11/how-to-write-and-compile-c-programs-on-mac-os-x/
Fondamentalmente fai:
gcc hello.c
./a.out (or with the output file of the first command)
gcc hello.c -o a.out
? Che fa lo stesso di gcc hello.c
.
basta inserire nella directory in cui si trova il tuo file c / cpp.
per compilare ed eseguire codice c.
$gcc filename.c
$./a.out filename.c
per compilare ed eseguire codice c ++.
$g++ filename.cpp
$./a.out filename.cpp
"$" è il simbolo del terminale mac predefinito
Per compilare ed eseguire un codice sorgente cpp dal terminale Mac è necessario:
L'esecuzione di un file .C utilizzando il terminale è un processo in due passaggi. Il primo passo è digitare gcc nel terminale e rilasciare il file .C sul terminale, quindi premere Enter:
username$ gcc /Desktop/test.c
Nel secondo passaggio, eseguire il comando seguente:
username$ ~/a.out
Per l'esecuzione di file c ++ eseguiti sotto il comando, Supponendo che il nome del file sia "main.cpp"
1.Compilare per creare il file oggetto dal file c ++.
g++ -c main.cpp -o main.o
2.Poiché #include <conio.h>
non supporta MacOS, quindi dovremmo usare la sua alternativa che supporta Mac che è #include <curses.h>
. Ora il file oggetto deve essere convertito in file eseguibile. Per usare curses.h
dobbiamo usare la libreria -lcurses
.
g++ -o main main.o -lcurses
3.Ora esegui l'eseguibile.
./main