Newsgroup: it.comp.lang.c++
Titolo: [1/2 OT] Cosa succede durante la creazione dell'exe?

Salve a tutti.
Potreste aiutarmi a soddisfare una curiosita'?
Cosa succede durante a creazione dell'exe (intendo come quando premo
Ctrl+F10 con DevC++ e compaiono le scritte "Compiling" e "Linking")?
Grazie.

In poche parole:
il "Compiling" traduce il linguaggio sorgente in linguaggio "macchina"
il "Linking" mette insieme quello che hai compilato con le librerie
esterne.
Bye
Al



Che vengono lanciati rispettivamente gcc e poi ld :) :)
Scherzi a  parte penso che  in un qualsiasi libro  di programmazione
(non per forza di C) è  descritto cosa si intende per compilazione e
per link, ti rimando ad una esauriente lettura.
-- 
Vanni Brutto
| email 
za...@nofesso.libero.it
      |
| irc nick VanniB   |   ICQ 18526701 |
--- rimuovi nofesso per rispondere ---
---PC powered by Linux kernel 2.4.14vb
Il parente più  simpatico è quello che
è  solito mandare  una cartolina  ogni
tanto da un paese lontanissimo. 

 per link, ti rimando ad una esauriente lettura.
In Herbert Schildt - C++ La Guida Completa - McGrawHill Non sono
riuscito a trovare niente devo aver guardato male forse. =(
Perfavore, potresti speigarmi cosa avviene durante queste fasi o
consigliarmi un sito dove poter andare a guardare?
Grazie.
Ciao.

consigliarmi un sito dove poter andare a guardare?
La compilazione e' la trasformazione del codice sorgente in
codice oggetto.  Il codice oggetto e' codice macchina in cui
sono presenti dei riferimenti ad oggetti esterni (vedi le
funzioni di libreria).  Il "linking" e', invece, la
generazione del codice macchina eseguibile dal codice
oggetto, in cui, cioe', i riferimenti esterni vengono
risolti.  Per farti un esempio, quando compili un programma
che fa uso di una funzione di libreria, il compilatore
traduce tutto il codice che puo' tradurre, ma non ha subito
sotto mano il codice della funzione di libreria, per cui
rimanda il suo collegamento col codice macchina ad un altro
modulo, che e' il linker (con un'informazione del tipo "in
questo punto va chiamata la funzione X").  Il linker, da
parte sua, scorre il codice oggetto, quando trova il
riferimento a X, scorre le librerie alla ricerca di X, la
trova e inserisce il codice della funzione nel codice
oggetto, creando il programma nella sua forma completa ed
eseguibile.
-- 
Andrea Laforgia
#exclude <windows.h>

 eseguibile.
Grazie mille!
La tua spiegazione e' stata molto chiara ed interessante.
Scusa se approfitto ma avrei ancora una domanda riguardo
la fase di compilazione...
Quand'e' che il compilatore controlla la coerenza tra il
prototipo, il corpo delle funzioni e le chiamate all'interno
del codice, e quando controlla se il riferimento all'oggetto
esterno e' presente o meno?
Grazie ancora.
Ciao.

Ps
Scusate il pessimo quoting del messaggio precedente. ^^;;

esterno e' presente o meno?
Non e' lui a farlo.  Come gia' detto, la risoluzione dei
riferimenti e' a carico del linker.  Quando il compilatore
trova l'invocazione a una funzione, si accerta per prima
cosa se la funzione e' presente all'interno del codice che
sta compilando, se non lo e', assume che sia una funziona
esterna e compila il codice, quindi, lasciando insoluto
questo riferimento.  Quando il linker trova il riferimento,
cerca di risolverlo e se non riesce a farlo genera un errore
fatale del tipo "unresolved external reference" o qualcosa
del genere.


 questo riferimento.
Non mi e' chiara una cosa.
Se il compilatore, non trovando la funzione all'interno del
codice, assume che sia una funzione esterna e compila il codice
come fa a verificare che ci sia compatibilita tra i tipi usati
per i parametri e il prototipo della funzione?
Grazie.
Ciao.

 wrote in message
news:H9sT7.13438$o9.5...@news1.tin.it...

Secondo te perchè prima di chiamare una funzione devi sempre
dichiararla?
In altre parole: a che servono gli header?
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

per i parametri e il prototipo della funzione?
Non puo'.
E' per questo che si e' resa obbligatoria la dichiarazione
delle funzioni, prima del loro uso, proprio per poter
verificare che il programmatore chiami la funzione passando
i parametri in numero e tipo corretti.  Quando in un
programma C includi "stdio.h", ad esempio, non fai altro che
porre in testa al tuo file sorgente tutte le dichiarazioni
(leggi "prototipi") delle funzioni dell'I/O standard che
andrai a chiamare.  Le funzioni, in realta', risiedono nella
libreria standard, esterna al tuo sorgente, ma al
compilatore, per i controlli sulla correttezza semantica
delle chiamate, basta dare un'occhiata ai prototipi.


 per i parametri e il prototipo della funzione?
// File a.cpp
int funz(int x, const char* y) {
	return x+(*y);
}
// File b.cpp
#include <iostream>
int funz(int, const int*); // <-- e' diversa da quella nel file a.cpp
int main() {
	int i = 7, j = 9;
	int k = funz(i,&j);
	std::cout << k << std::endl;
}
Prova a compilarli e non dovrebbero dare problemi... questo perche' il 
compilatore compila una "translation unit" (in questo caso un file) 
alla volta, e all'interno di b.cpp la chiamata a funz( ) rispetta la 
"promessa" fatta nella dichiarazione
Ma in fase di linking i nodi vengono al pettine ;)
-- 
Danilo Piazzalunga
Linux Registered User #245762 at 
http://counter.li.org
mailto:
leo-...@ibero.it