Newsgroup: it.comp.lang.c++
Titolo: Io vs Compilatore, sempre alle solite

Ciao raga, 
spero che sia l'ultima volta di stasera.
La domanda riguarda inline.
Una mia abitudine è di dichiarare ogni funzione membro come inline,
sequendo il consiglio di Paolo Marotta che sul suo tutorial ha scritto che
ogni funzione è inline se definita all'interno della classe stessa. Quindi
credevo che non desse problemi renderlo esplicito ogni volta.
Poco fa ho dovuto implementare una classe con circa 10 funzioni dichiarate
inline; un vero disastro! Compilatore bloccato finché non ho eliminato
qualche inline dalla classe.
Sono problemi di ottimizzazione del compilatore o sono di nuovo io che sto
dando i numeri?
Ciao.
-- 
La classifica dei prodotti MS:
C#, la migliore barzelletta di Bill Gates.
Visual C++, il meno standard dei compilatori C++.
J++, la copiatura più riuscita.
Windows, il più instabile.
Visual Basic, un esempio di prodotto decente della MS - forse l'unico -.
OutlookExpress, scandali su scandali.
La classifica degli "amici" coglioni:
Stefano Zanchi, il miglior lamer del mondo.
 

non sono espertissimo ma forse il compilatore si incazza perchè
qualche metodo è troppo lungo per essere dichiarato inline(in teoria
dovrebbe solo ignorarlo)
spero di non aver detto una banalità e di esserti stato utile
;)


dando i numeri?
Mi viene spontanea un domanda. Che compilatore stai usando?
Non sono un esperto di storia del C++ ma mi risulta che nei
compilatori di tanto tempo fa nelle funzioni inline non fosse ammesso
usare costrutti di controllo che if, while , for, ecc...
Lavinia
WINWORD.EXE - ERRORE DI APPLICAZIONE
l'istruzione a "0x3017ff27"ha fatto riferimento alla
memoria a "0x02a3143c".La memoria non poteva essere 'read'.

 Ciao.
Be considera che non e' oro tutto cio che luccica, non ho mai letto il
tutorial di Marotta ma ho letto quello di Scott Meyers...
L'idea che sta dietro un metodo inline e' quella di sostituire la
chiamata ad un metodo inline con l'equivalente codice e non serve una
laurea per capire che il vantagio ottenuto in termini di prestazioni.
Il rovescio della medaglia e' il seguente:
1) Programmi piu' cicciottelli (problemi con sistemi con poca memoria)
2) Hit rate delle cache piu' basse (alla faccia delle performances)
Se hai un metodo tipo
int getX() { return theX; }
allora ha senso farlo inline, in questo caso e' piu' corto il codice
return theX; che la chiamata al metodo (ricordiamo che in realta' anche
i metodi senza parametri hanno un argomento non mostrato).
In oltre inline come register (cito) e' un consiglio per il compilatore
non un comando, quindi il compilatore puo anche ignorarlo.
Leggi il resto e trema:
Cosa accade se tu dichiari una funzione f inline e il compilatore
decide di ignorare la direttiva? Tu mi dirai che verra' trattata come
non inline il codice generato sara' lo stesso di una funzione 'outline'
e tutto funzionera' normalmente. Questo e quello che accade in teoria,
in pratica:
Le funzioni inline vengono implementate negli headers file (.h) questo
permette di avere in diversi moduli il vantagio di avere la stessa
funzione inline
//example.h
inline void f() { ... }
......
//source1.cpp
#include "example.h"
...    //contiene chiamate ad f
//source2.cpp
#include "example.h"
...    //contiene chiamate ad f
secondo la regola di "outlined inline"  f non viene "inlined"
cosi' quando source1.cpp viene compilato il corrispondente obj file
contiene una funzione chiamata f, lo stesso succede per source2.cpp.
Quando provi a linkare ti aspetti che il linker trovi due volte la
funzione f e ti dia errore. Per ovviare invece alcuni i compilatori
(secondo un vecchio consiglio dallo standard C++) trattano
una un-inlined inlined function come se tu la avessi dichiarata static!
Questo elimina il problema in fase di linking ma (e ti pareva) ad un
costo: ogni obj che include example.h contiene la sua copia statica di
f. Se f definisce in oltre delle variabili statiche ogni copia di f
possiede le proprie copie!!!!! Questo va contro il fatto che credi che
se hai dichiarato delle variabili static questo voglia dire "solo una
copia". Fortunatamente c'e' una nuova regola e i compilatori che la
applicano non incorrono in questi disdicevoli inconvenienti.
Pensa in oltre al seguente caso (AAAAARGGHHHHH)
inline void f() {...}
void (*pf)() = f;
main()
{
 f();
 pf();
.....
}
qui hai f inlined e quale e' l'indirizzo di una funzione inline?????
PAURAAAAA.
Per non parlare dei costruttori che sembrano vuoti ma...
alla prossima.
[1] Scott Meyers Item 33 (Effective C++ second Edition).
Sent via Deja.com
http://www.deja.com/

 dando i numeri?
IMHO è il compilatore che è una ciofeca. Qual è?

dando i numeri?
che compilatore usi?
inoltre ricordati che una funzione inline deve essere DEFINITA (non
dichiarata) in ogni unità di traduzione nella quale è usata. Quindi,
nel caso di funzioni membro, deve essere inclusa la definizione
nell'header della classe. Non è che stai cercando di definire le func
inline in un altro file?
Anto
PS
attento con le inline, usale solo se ti servono veramente (ad esempio
per fare un wrapper senza alcun overhead); se una funzione impiega del
tempo per essere eseguita non conviene dichiararla inline. Inoltre in
compilatore può anche decidere di ingnorare inline e farne una
funzione normale.

 >non credo che P.M. abbia mai consigliato di mettere tutte le funzioni
 >membro inline.
Infatti non l'ho mai detto e neppure consigliato!
D'altronde nei moderni processori un eccesso di inline potrebbe
facilmente portare ad un elevato numero di page fault di cache
con conseguente degrado di prestazioni.
Inline va utilizzata con cura e comunque a meno di non avere una
discreta esperienza, e` bene rimandare certe ottimizzazioni
al momento giusto ed utilizzando gli strumenti del caso.
Paolo
--
Paolo Marotta
Duck Communication Entertainment s.r.l.
Largo Arenula, 11 - Roma
http://www.duckce.com
p.ma...@duckce.com
-- 
Posted from 
HA-server-a.cs.interbusiness.it
 [151.99.250.31] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

inline in un altro file?
Assolutamente no. Il codice era:
class Base {
        private:
                  inline int funzione() {
                           // definizione della stessa
                  }
                 // altre funzioni con inline esplicito
};


 inline in un altro file?
io tempo fa con djgpp ho compilato un file (prova.cpp) dove vengono definite
delle funzioni inline dichiarate in prova.h
ho poi creato un secondo file che includeva prova.h e l'ho compilato con
prova.o
perchè me l'ha permesso?
ciao
Franz

 wrote in message
news:93ipl0$j51$1...@lacerta.tiscalinet.it...

Una "unita` di traduzione" comprende un file-sorgente _e tutti i
file che esso include_ (recorsivamente).  Se l'unita` di traduzione
*USA* una funzione inline, deve anche *DEFINIRLA*.
Nel tuo esempio, il fatto che "il secondo file includeva prova.h"
non ci dice se esso *usasse* funzioni inline che in prova.h sono
dichiarate ma non definite.
Alex -- MVP C++ di Brainbench

 ha scritto nel messaggio
news:93ipl0$j51$1...@lacerta.tiscalinet.it...

Semplicemente perche', non vedendo la definizione delle funzioni inline, le
ha considerate come non inline. In pratica nel tuo caso ti ritrovi con
funzioni inline solo in 'prova.cpp'. Tutte le altre unita' di traduzione che
fanno uso del corrispettivo header vedono tali funzioni come non inline.
Domenico Barra

 fanno uso del corrispettivo header vedono tali funzioni come non inline.
Non e' detto; lo standard permette l'esistenza di piu' definizioni di
una stessa funzione inline con linkage esterno, poiche' ce ne sia al
massimo una per translation unit e siano tutte identiche.
Ciao,
Nicola

 Domenico Barra
ciao
Franz

 Alex -- MVP C++ di Brainbench
ciao
Franz

 massimo una per translation unit e siano tutte identiche.
Già, avevo tralasciato questo caso...
Ciao
Domenico Barra

 >Ma risulta un errore rendere esplicito inline se la definizione della
 >funzione membro è interna alla classe?
Ci sono due possibilita` di per rendere inline una member function:
a)
class A {
   public:
      void f() { /* eventuale codice /* }
};
2) oppure (lo preferisco perche` rende piu` facilmente consultabile
la dichiarazione della classe)
class A {
   public:
       void f();
};
inline void A::f() { /* eventuale codice */ }


 al momento giusto ed utilizzando gli strumenti del caso.
Giustissimo direi. La mia regola è quella di non utilizzare mai inline
se non per funzioni che si limitano esclusivamente a chiamarne altre o
ad effettuare semplici calcoli matematici (somme, moltiplicazioni per
numeri noti a compile-time, etc.). Per curiosità, quali "strumenti del
caso" usi?

Per queste cose essenzialmente si utilizza un profiler....


Ma avevo detto cavolate?? Tutti continuano a chiedere quello a cui avevo
risposto.
