Newsgroup: it.comp.programmare.win32
Titolo: Una curiosita sulle STL

Mi chiedo come siano implementate le STL ,visto che il compilatore genera
codice solo quando trova una istanza della classe . Ad esempio quando io
dichiaro vector<MioTipo> nel sorgente del mio prg il compilatore istanzia la
classe vector con il tipo richiesto. OK ma dove si trova il codice della
classe che viene istanziata visto che non puo essere precompilato prima per
il tipo da me richiesto ?

 ha scritto nel messaggio
news:4BiSa.188946$lK4.5...@twister1.libero.it...

nei file di include vctor, string, ecc ... sono scritti come template quindi
finche non li richiami non viene generato codice per loro, infatti STL e'
Standard Template Library.
quindi se hai gcc ti so indicare i file precisi ... se usi altri compilatori
prova a cercare vector. senza nulla .h o altro e vedi se trovi le classi
template scritte.
ciao
ps: il vector lo stack la list li puoi usare benissimo senza dichiarare il
tipo (almeno mi pare di aver visto esercizi cosi) perche' dovrebbero solo
salvare il tuo puntatore castato in void, ed e' anche per quello che non
puoi deallocare un vector finche non rimuovi tutti gli oggetti da esso,
cioe' se fai un vector di dati base si potrebbe pure deallocarlo senza prob
... si puo' fare ???

... si puo' fare ???
e come li dichiari?
std::vector<> IlMioVettore;
???
-- 
]\/[ad]\/[age (
www.mindreamz.net
)
"Un Maestro insegue semplicemente la sua visione di Eccellenza in
qualunque cosa sta facendo e lascia agli altri decidere se sta 
lavorando o giocando. A lui sembra sempre di fare entrambe." - Anonimo



e perché "non può"? certo che può, perché durante la compilazione il
compilatore SA BENE quali sono le classi da te richieste!!
essendo le STL delle standard TEMPLATE library, sono costituite di
template... i template sono delle funzioni/classi che fungono da
modelli per creare tutte le funzioni/classi che servono al tuo
programma
mi spiego: prendi ad esempio la funzione template
template <class T>
T somma(T Valore1, T Valore2)
{
	return Valore1 + Valore2;
}
questo codice, di per sé, non viene compilato, vengono invece
compilati tutti le versioni in cui "T" è un tipo richiesto da una
qualunque chiamata del tuo programma...
se ad esempio nel programma scrivi
int a, b;
int c = somma(a, b);
viene compilata la funzione
int somma(int Valore1, int Valore2)
ecc.
(cioè la funzione template in cui "T" è sostituito da "int")
se invece è
int a, b, c = somma(a, b);
long x, y, z = somma(x, y);
il compilatore compilerà sia una funzione con gli int che una con i
long
lo stesso discorso si può estendere anche alle classi, considerando
che esista un operatore+ per operandi di classe MiaClasse, puoi
scrivere
MiaClasse q, w, t = somma(q, w);


 ???
non lo so ... alla stl ci devo ancora arrivare :-p mi pareva di aver visto e
letto che si possono usare anche generiche ... tanto non salvano il
puntatore all'area e non l'oggetto di perse' ???
cioe' semmai un vector<void> o se proprio non si puo' cosi' si forza un
vector<void*> in cui salvi dentro i puntatori a tuoi oggetti castando il
loro puntatore a void e ricastandolo alla classe giusta all'uscita ???
magari serve avendo molte classi derivate da una classe base che ne
identifica il tipo ... in cui tu al prelevamento del puntatore lo casti alla
classe base rilevi il tipo lo casti alla classe derivata giusta e usi
l'oggetto ??? o sto solo sognando ???
magari visto che mangio molto bene il basso livello asm mi trasformo
mentalmente cosa fanno queste cose e magari travio una certa trasformazione
non comprendendo bene quello che fa'.
per me se ho una classe base:
byte : x
e da essa derivo altre classi che nel costruttore infilano il loro size in
byte io poi posso gestirmele come voglio ... no ? forse sarebbe meglio non
farsi sti giri strani in un programma ma non e' una possibilita' cmq data
dal linguaggio ??? anche se sto con te' che potresti dirmi che cosi' un
programma diventa illeggibile e completamente non mantenibile da persone
diverse dal programmatore originale.
ciao

 puntatore all'area e non l'oggetto di perse' ???
Dipende da come lo dichiari, puntatore o no.
myClass
  {
  ..
  };
vector<myClass> v1;
vector<myClass*> v2;
v1 contienene 'oggetti' mentre v2 puntatori. Mi sembra abbastanza semplice.
Io di solito ho visto usare e uso la forma 1, con la quale peraltro quando
distruggi il vettore rimuovi automaticamente gli oggetti. Prova a guardare
il file header vector e tutto sarà piú chiaro.
Ciao

 il file header vector e tutto sarà piú chiaro.
si ok ma cosi' facendo ti levi la possibilita' di immagazzinamento misto ...
o forse se diachiare vector con la classe base puoi poi memorizzare anche
classi derivate senza problema ??? tanto anche nel 1 caso non dovrebbe
memorizzarsi solo il puntatore ?
cioe' se io voglio farmi uno stack non ci posso pushare quello che voglio
... ma solo tutta roba dello stesso tipo ... mi pare una limitazione
eccessiva soprattutto per una struttura come uno stack (parlo cosi' per
averlo usato in assembly come volevo io)
ciao

averlo usato in assembly come volevo io)
dubito fortemente di questo, anche se non ne sono certo... istruzioni
del std::vector come push_back COPIANO l'argomento dentro al vector,
non ne prendono solo il riferimento o il puntatore
non è una limitazione eccessiva, basta usare i puntatori (in questo
caso viene COPIATO il puntatore e non l'oggetto puntato)... del resto
con uno stack in assembly (o come ti pare), cosa immagazzini
effettivamente nella pila? i puntatori, no? oppure ci metti oggetti di
dimensione variabile? in tal caso si avrebbe un aumento inutile di
complessità


 complessità
bhe in assembly lo stack lo usavi nelle procedure per salvare lo stato
macchina ... e ci pushavi dentro un po' di tutto, sempre e solo registri in
quel caso ... ma non erano solo indirizzi ...
poi vabbe lo si usa anche come passaggio di dati per la procedura ... cioe'
io metto i miei dati nello stack e poi chiamo la procedura che si
riprendera' i dati e li usera' per il suo lavoro ed e' l'unico modo per
essere rientranti anche in assembly ...

 programma
Quindi la STL non e' una libreria compilata ma e' formata solo da codice
sorgente ?

 sorgente ?
diciamo di si ... e' formata solo da codice c/c++ scritto come template
quindi non sono definite le variabili e quindi ci puoi mettere qualsiasi
cosa dentro, dai dati bultin ai tuoi oggetti o alle tue strutture.
ciao

essere rientranti anche in assembly ...
rientranti?


sorgente ?
sì... infatti viene compilata insieme al tuo progetto e vengono
(teoricamente, se il compilatore e il linker sono bravi) compilate
solo le funzioni e le classi che ti servono, col tipo che viene
richiesto... cioè se tu nel tuo progetto hai bisogno di un
std::vector<int> e di un std::vector<PincoPallino> vengono compilate
le due classi, una per il vettore di interi e una per il vettore di
pincopallino


 averlo usato in assembly come volevo io)
Dipende sempre da quello che devi fare. Nella mia esperienza ho quasi sempre
usato i vettori con oggetti di un solo tipo.
Esiste ancha una classe any_array in boost ma non l'ho mai usata e non so
dirti se è efficiente o no.
Ciao

 rientranti?
si ... e' l'unico modo via stack di fare procedure rientranti che possono
essere usate anche in multitasking concorrente senza creare errori di dati
incongruenti ...
cioe' se tu leggi i dati sempre dal solito indirizzo nel ds e a meta' della
procedura viene richiamata ancora la stessa procedura andra' a cambiare dati
cosi' da rendere la prima chiamata incongruente con i dati che gli si erano
passati ...
ecco perche' si usa lo stack spiazzato ... almeno usi sempre le versioni dei
dati che ti vengono passati per quella procedura senza violare altri dati
non tuoi ...
ciao

 ciao
Saluti.

 ha scritto
nel messaggio news:76fe4175.03073...@posting.google.com...
riccardo lo so ... la STL non la ho ancora letta tutta ... la stavo usando
senza sapere bene tutto ... ora anche alle vostre risposte ho fugato i primi
dubbi che appena finisco di leggere il libro delle STL potro avere le idee
chiare del tutto
ciao