Wiki Ubuntu-it

Indice
Partecipa
FAQ
Wiki Blog
------------------
Ubuntu-it.org
Forum
Chiedi
Chat
Cerca
Planet
  • Pagina non alterabile
  • Informazioni
  • Allegati
  • Differenze per "LucaGambardella/Prove1"
Differenze tra le versioni 43 e 54 (in 11 versioni)
⇤ ← Versione 43 del 21/06/2012 15.44.07 →
Dimensione: 5307
Autore: LucaGambardella
Commento:
← Versione 54 del 18/07/2012 08.07.53 → ⇥
Dimensione: 5822
Autore: LucaGambardella
Commento:
Le cancellazioni sono segnalate in questo modo. Le aggiunte sono segnalate in questo modo.
Linea 5: Linea 5:
<<Informazioni( forum="http://forum.ubuntu-it.org/index.php"; rilasci="12.04 11.10 11.04 10.10 10.04")>> <<Informazioni( forum="http://forum.ubuntu-it.org/viewtopic.php?f=46&t=529998"; rilasci="12.04 11.10 11.04 10.10 10.04")>>
Linea 11: Linea 11:
Il significato originario di '''GCC''' era GNU C, ma da allora poiché sono stati aggiunti altri linguaggi e il suo significato è stato cambiato in Gnu Compiler Collection. Il significato originario di '''GCC''' era GNU C Compiler, ma da allora poiché sono stati aggiunti altri linguaggi e il suo significato è stato cambiato in Gnu Compiler Collection.
Linea 17: Linea 17:
Installare il pacchetto [[apt://build-essetial | build-essetial]]. Questo fornirà i compilatori per il linguaggio C e C++ e molti strumenti utili che gli gli sviluppatori utilizzano frequentemente. [[InstallareProgrammi | Installare]] il pacchetto [[apt://build-essential | build-essential]]. Questo fornirà i compilatori per il linguaggio C e C++ e molti strumenti utili che gli gli sviluppatori utilizzano frequentemente.
Linea 29: Linea 29:
 * [[apt://gccgo | gccgo]] (Go)
Linea 32: Linea 34:
gcc [parametri] nome_file_sorgente.estensione -o nome _file_output }}} gcc [parametri] nome_file_sorgente.estensione -o nome_file_output }}}
Linea 36: Linea 38:
il file sorgente `foo.c` sarà compilato e si otterrà l'eseguibile `foo`. il file sorgente `foo.c` sarà compilato e si otterrà il file di output `foo`.

Una volta generato il file binario sarà possibile avviarlo da un terminale con il comando:{{{
./nome_file_output }}}
sostituendo nome_file_output con il nome del file eseguibile che si desidera avviare.
Linea 42: Linea 48:
||<tablestyle="width:100%" : 25% style="background-color:#FB8B00;">'''C++ (main.cc)''' ||<style="background-color:#FB8B00;": 25% >'''C (main.c)''' ||<style="background-color:#FB8B00;": 25% >'''Assembler (main.S)''' ||<style="background-color:#FB8B00;": 25% >'''Ada (main.adb)'''||
|| {{{#!cplusplus
#include <iostream>
int main()
{
std::cout << "Hello World\n";
}
Linea 50: Linea 49:
}}} || {{{#!c
#include <stdio.h>
  
int main ()
{
printf ("Hello World\n");
}
}}} || {{{
{{{
.section .data
hello: .ascii "Hello World!\n"
.section .text
.globl _start
_start:
    mov $4, %eax
    mov $1, %ebx
    mov $hello, %ecx
    mov $13, %edx
    int $0x80
    mov $1, %eax
    mov $0, %ebx
    int $0x80
~}}}
}}} || {{{
{{{
with Ada.Text_IO;
use Ada.Text_IO;		 ||<tablestyle="width:100%" : 20% style="background-color:#FB8B00;">'''C++ (main.cc)'''||<style="background-color:#FB8B00;":>'''C (main.c)'''||<style="background-color:#FB8B00;":>'''Assembler (main.S)'''||<style="background-color:#FB8B00;":>'''Ada (main.adb)'''||
||#include <iostream> <<BR>> int main() <<BR>> { <<BR>> std::cout << "Hello World\n"; <<BR>> } ||#include <stdio.h> <<BR>> int main () <<BR>> { <<BR>> printf ("Hello World\n"); <<BR>> } ||.section .data <<BR>> hello: .ascii "Hello World!\n" <<BR>> .section .text <<BR>> .globl _start <<BR>> _start: <<BR>> mov $4, %eax <<BR>> mov $1, %ebx <<BR>> mov $hello, %ecx <<BR>> mov $13, %edx <<BR>> int $0x80 <<BR>> mov $1, %eax <<BR>> mov $0, %ebx <<BR>> int $0x80 ||with Ada.Text_IO; <<BR>> use Ada.Text_IO; <<BR>> <<BR>> procedure main is <<BR>> begin <<BR>> Put_Line("Hello World!"); <<BR>> end main; ||
||<tablestyle="width:100%" : 20% style="background-color:;"> '''g++ main.cc'''||<:> '''gcc main.c''' ||<:> '''gcc main.S''' ||<:> '''gcc -c main.adb''' ||
Linea 78: Linea 53:
procedure main is
begin
 Put_Line("Hello World!");
end main;
~}}}
}}}
||g++ main.cc ||gcc main.c ||gcc main.S ||gcc -c main.adb ||		 L'ultima riga della tabella mostra il comando per mandare in compilazione il sorgente.
Linea 86: Linea 55:
Se nula è stato specificato il compilatore andrà a creare un binario eseguibile chiamato di default `a.out`. E' da notare che il programma scritto in C++ è compilato dal comando g++. Il comando gcc riconosce il linguaggio di input in base all'estensione del file del sorgente (`.cpp`, `.cc` e `.cxx` sono tutte corrette) ma decide di non linkare la libreria standard del C++ (libstdc++). Il comando g++ fa questo in automatico e si risparmiano un sacco di sforzi.
Linea 88: Linea 57:
E' da notare che il programma scritto in C++ è compilato dal comando g++. Il comando gcc riconosce il linguaggio di input in base all'estensione del file del sorgente (`.cpp`, `.cc` e `.cxx` sono tutte corrette) ma dedide di non linkare la libreria standard del C++. Il comando g++ farà questo in automatico e si risparmieranno un sacco di sforzi. Se nulla è stato specificato il compilatore andrà a creare un binario eseguibile chiamato di default `a.out`.


Questa guida è stata verificata solo con versioni obsolete di Ubuntu, potrebbe non essere più valida. Vuoi contribuire ad aggiornarla? Clicca qui!

Problemi in questa pagina? Segnalali in questa discussione

Introduzione

Gnu Compiler Collection (GCC) è una collezione di compilatori e fornisce un'interfaccia uniforme per scrivere programmi in C, C + +, Java, Objective-C, Fortran, Ada, Assembler e Go (a partire da Ubuntu 11.10).

Il significato originario di GCC era GNU C Compiler, ma da allora poiché sono stati aggiunti altri linguaggi e il suo significato è stato cambiato in Gnu Compiler Collection.

Questa guida si prefigge di aiutare nella programmazione in Ubuntu usando GCC per compilare. Non ha il fine di introdurre ai linguaggi di programmazione o di dar supporto ad essi. Per questo occorre leggere molte pagine web, guide in linea o dei buoni libri di testo.

Installazione

Installare il pacchetto build-essential. Questo fornirà i compilatori per il linguaggio C e C++ e molti strumenti utili che gli gli sviluppatori utilizzano frequentemente.

Per gli altri linguaggi è richiesta l'installazione dei seguenti pacchetti:

Utilizzo

La sintassi base di utilizzo è la seguente: 

gcc [parametri] nome_file_sorgente.estensione -o nome_file_output

ad esempio se si dà il comando: 

gcc -g -Wall -Wextra -pedantic-errors foo.c -o foo

il file sorgente foo.c sarà compilato e si otterrà il file di output foo.

Una volta generato il file binario sarà possibile avviarlo da un terminale con il comando:

./nome_file_output

sostituendo nome_file_output con il nome del file eseguibile che si desidera avviare.

Esempio di programma

I seguenti file, dopo essere stati compilati, mostrano sul terminale Hello World.

C++ (main.cc)

C (main.c)

Assembler (main.S)

Ada (main.adb)

#include <iostream>
int main()
{
std::cout << "Hello World\n";
}

#include <stdio.h>
int main ()
{
printf ("Hello World\n");
}

.section .data
hello: .ascii "Hello World!\n"
.section .text
.globl _start
_start:
mov $4, %eax
mov $1, %ebx
mov $hello, %ecx
mov $13, %edx
int $0x80
mov $1, %eax
mov $0, %ebx
int $0x80

with Ada.Text_IO;
use Ada.Text_IO;

procedure main is
begin
Put_Line("Hello World!");
end main;

g++ main.cc

gcc main.c

gcc main.S

gcc -c main.adb

L'ultima riga della tabella mostra il comando per mandare in compilazione il sorgente.

E' da notare che il programma scritto in C++ è compilato dal comando g++. Il comando gcc riconosce il linguaggio di input in base all'estensione del file del sorgente (.cpp, .cc e .cxx sono tutte corrette) ma decide di non linkare la libreria standard del C++ (libstdc++). Il comando g++ fa questo in automatico e si risparmiano un sacco di sforzi.

Se nulla è stato specificato il compilatore andrà a creare un binario eseguibile chiamato di default a.out.

Parametri

Ci sono molti parametri utili, i più importanti sono riportati nella seguente tabella.

Parametro

Spiegazione

-o

Specifica il nome del file di output (a.out è quello predefinito).

-c

Il file sorgente è solo compilato ma non non avviene in linking (terminerà con l'estensione .o).

-OX

Ottimizza il codice sorgente, il grado di ottimizzazione (indicato da X) può essere 0 (nessuno), 1 (dimensioni e velocità), 2 (velocità), 3 (velocità, aggressività o dimensioni).

-march=nativ

Ottimizzato specialmente per il processore esistente, non si avvierà su altre architetture. Non adatto per distcc.

-lXXX

Collega altre librerie (ad esempio -lncurses per libncurses)

-std=XXX

Imposta il linguaggio di programmazione predefinito (ad esempio XXX può essere c99, c1x, gnu++98, c++98 c++0x)

-ansi

Consente solo costrutti conformi ad ANSI C

-Wall

Abilita avvisi utili che sono supportati dal compilatore gcc.

-Wextra

Abilita ancora più avvisi che sono supportati dal compilatore gcc.

-pedantic

Dà tutti gli avvisi richiesti dal rigoroso ISO C e ISO C + +. -pedantic-errors è simile a -pedantic, solo che sono prodotti errori anziché avvisi.

-v

Stampa i comandi e passi che il compilatore esegue esattamente (preprocessore, compilatore, assemblatore, linker...)

-g

Produce informazioni di debug nel formato nativo del sistema operativo (stabs, COFF, XCOFF, o DWARF 2). GDB può lavorare con queste informazioni di debug.

-ggdb

Produce espressioni di debug per usarle da GDB. questo significa usare il più espressivo formato disponibile (DWARF 2, stabs, o il formato nativo se nessuno di questi sono supportati), comprese le estensioni GDB, se possibile.

Ulteriori risorse

CategoryHomepage

Confermare l'impiego di cookie da parte dei portali di Ubuntu-it per fornirti una migliore esperienza d'uso nei servizi offerti.
Maggiori informazioni Accetto