Newsgroup: it.comp.lang.c++
Titolo: specificatore <inline>

Non mi č per niente chiaro il funzionamento dello specificatore *inline*.
Allora:
1) se definisco il metodo che vorrei compilato inline nella dichiarazione
della classe, lo specificatore non č obbligatorio, dato che quello di
cercare di rendere inline il metodo stesso č in questo caso il
comportamento di default del compilatore; 
2) ma se la definizione del metodo sta fuori (ad esempio in un file .cpp,
quando la dichiarazione č nel corrispondente header) come faccio? Se provo
a mettere lo specificatore inline prima del prototype nella definizione
(nel .cpp) il linker non trova il metodo inline quando lo si chiama da un
altro punto messo in un altro modulo. A pensarci bene questo č anche un
comportamento lecito da parte del linker... quindi (se penso bene) ne
deduco che non si puň mettere la definizione di un metodo inline fuori
dall'header che dichiara la sua classe. E, se ho ragione, a cosa serve
*inline* dato che in (1) non č obbligatorio?
Oppure penso male? O devo campiare compilatore e linker (ehm... VC++ 5.0) ?
:)
Grazie per la pazienza.
Roberto Cavada

Ciao,
    per definire una funzione membro inline al di fuori dello header della
classe il codice è il seguente (tenendo conto che la classe si chiama
"Pippo" e la funzione si chiama "Esci"):
inline void Pippo::Esci() {
    // codice della funzione
}
per quanto riguarda il fatto che il linker non trova la funzione se chiamata
da un'altro modulo non sei molto chiaro.
Se in un'altro modulo (in cui #includi il file header di Pippo) istanzi un
oggetto di tipo Pippo poi è sufficiente scrivere MyPippo.Esci(); per usare
la funzione inline.
A presto :-)
Marco Abis
http://www.programmazione.it
 Il sito Italiano di riferimento per lo
sviluppatore
ab...@programmazione.it

Oppure penso male? O devo campiare compilatore e linker (ehm... VC++ 5.0) ?
Se non ci sei troppo affezionato, male non farebbe :)
Paolo
-----------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------

 quando la dichiarazione č nel corrispondente header) come faccio? Se provo
La definizione della funzione inline deve essere visibile
al compilatore (altrimenti non riesce a generare il codice),
quindi la definizione deve essere nell'header (o in un altro
file che viene #incluso).
Oltre ai casi 1 e 2 c'e' anche il caso 1 e 1/2: la funzione
e' definita nell'header ma all'esterno della classe:
  // pippo.h
 
  class Pippo {
    ...
    inline void func();
  };
 
  void Pippo::func()
  {
    ...
  }
In questo caso inline e' necessario, non solo per consigliare
l'ottimizzazione (il compilatore ci potrebbe arrivare da solo,
e molti ignorano i consigli su cosa rendere inline).
Il compilatore vede una definizione di Pippo::func() ongi volta
che viene incluso pippo.h, e quindi il linker si troverebbe tante
funzioni Pippo::func(), una per ogni file che usa Pippo, e
salterebbe fuori un errore di funzione duplicata.
La keyword inline dice al compilatore di trattare diversamente
la funzione, e l'errore non si verifica.
	Mauro

]

egcs ci riesce, come fa? Delega il compito di espanderla al linker? 
Sicuro? Mi pare alquanto improbabile...


Sicuro? Mi pare alquanto improbabile...
Certo, le uso. Se nel modulo che definisce le inline non vengono
instanziate da' unresolved external, ma se compili con
-fkeep-inline-functions non c'e' alcun problema. Sono rimasto stupito
pure io, ma funziona...


 pure io, ma funziona...
Probabilmente il programma funziona, pero' le funzioni
inline non sono espanse inline, ma compilate e linkate
come tutte le altre.
	Mauro

come tutte le altre.
E' quello che ho pensato pure io, ma nel manuale non c'e' cenno a
questo, viene solo detto che il codice delle funzioni inline non
referenziate nel modulo in cui sono definite verrebbe eliminato (cosa
ovvia). Cosa avvenga poi dopo non so.
Logicamente mi sembra che non occorra molta intelligenza aggiunta nel
linker per espandere inline il codice delle funzioni; il problema
semmai e' un altro: nella normale espansione inline prima viene fatta
l'espansione e poi le ottimizzazioni (quindi codice chiamante e
chiamato sono ottimizzati globalmente assieme, con notevoli vantaggi);
in questo caso invece non vedo un linker cosi' intelligente da
riottimizzare il codice una volta iserita la funzione inline...


Che io sappia l'espansione inline e` fatta dal compilatore e non
dal linker (che oltretutto non potrebbe fare alcun controllo sui tipi).
Per tale motivo il codice delle funzioni inline non puo` essere messo
in un file .cpp. Inoltre inline e` solo un suggerimento, il compilatore 
non e` obbligato a tale azione (in effetti il mio si rifiuta in presenza
di cicli).


di cicli).
In effetti, da standard, inline *puo'* essere espanso dal compilatore o 
meno. E' una scelta sua. 
Puoi mettere codice inline in .cpp semplicemente specificando, ad esempio:
 
inline
void MyClass::myMethod(void )
lo standard richiede che una funzione sia dichiarata "inline" o nella 
classe o alla definizione.
Non e' detto che il compilatore ne faccia l'espansione pero'. Tipicamente 
compilando con opzioni di debug *non* la fa. 
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun/

Puoi mettere codice inline in .cpp semplicemente specificando, ad esempio:
Ummm..
la compilazione avviene 1 file alla volta, quindi la definizione di una
funzione inline deve apparire nel file .cpp che la usa...
Di conseguenza o la funzione e` nel file in questione, oppure
e` in uno degli header inclusi... non mi pare sia possibile altrimenti
(salvo rinunciare all'espansione inline).


 (salvo rinunciare all'espansione inline).
Si', credo anch'io che nel caso "fuori header" la cosa si limiti in genere
al file stesso - cose tipo funzioni private che si mettono nel .cpp per
nascondere anche fisicamente l'implementazione.