Newsgroup: it.comp.lang.c++
Titolo: Fatto strano, spiegatemi per favore

Salve,
come mai questo sorgente compila e si esegue senza errori??
#include <iostream>
#include <map>
#include <string>
map <string, pair<int, int> > PG;
map <string, pair<int, string> > LC;
int main() {
    pair <int, int> zero;
    zero.first = 1;
    zero.second = 2;
    PG.insert(map <string, pair<int, int> >::value_type ("ciao", zero));
    LC["ciao"].first++;
    std::cout << LC["ciao"].first << std::endl;
    return 0;
}
Io l'inserimento l'ho fatto nella mappa PG, come e' che anche con LC riesco
a estrarla? O_O
In pratica inserisco un valore in una mappa e lo estraggo da un'altra!
Per caso con l'istruzione LC["ciao"].first ho aggiunto un'elemento alla
mappa LC?
Se per creare un nuovo elemento basta semplicemente usarlo a che serve il
metodo insert allora?
Grazie

 metodo insert allora?
Guardati la documentazione. Non sono proprio la stessa cosa.
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

 Guardati la documentazione. Non sono proprio la stessa cosa.
Purtroppo attualmente non ho la possibilita di guardarla pero' ho notato che
se non inserisco prima l'elemento con insert e' come se perdessi il valore
associato a tale chiave. Puoi chiarirmi meglio questo aspetto? La differenza
e' sostanzialmente questa?
Grazie

Anzi ho provato il seguente codice e in effetti il valore lo mantiene
infatti:
#include <iostream>
#include <map>
#include <string>
map <string, pair<int, int> > M;
int main() {
    M["ciao"].first = 10;
    M["ciao"].first++;
    std::cout << M["ciao"].first << std::endl; // Stampa 11
    return 0;
}
A questo punto non vedo quale sia la differenza :(
Forsa essa esiste solo a livello di implementazione (quindi ce ne una piu'
veloce forse o che usa meno memoria?)
Grazie

 e' sostanzialmente questa?
No! Se modifico l'esempio precedente nel seguente modo non cambia nulla:
#include <iostream>
#include <map>
#include <string>
typedef std::map < std::string, int > TSubMap;
typedef std::map < std::string, TSubMap > TMap;
int main()
{
    TSubMap MySubMap;
    MySubMap[ "SubKey" ] = 10;
    TMap MyMap;
    MyMap.insert( TMap::value_type( "MainKey", MySubMap ) );
    std::cout << MyMap[ "MainKey" ][ "SubKey" ] << '\n';
    return 0;


 A questo punto non vedo quale sia la differenza :(
Ripeto: guardati la documentazione riguardo il metodo
std::map::insert(). Ci sono tre overloading con vari parametri e valori
di ritorno differenti.


 Come fai a sviluppare senza documentazione?
Mi arrangio in vari modi (tempo fa non sapevo dell'esistenza del metodo
replace per le stringhe e me lo sono scritto io :P) ma stavolta sto
aspettando il libro di Stroustrup che dovrebbe arrivare. Ho cercato info sul
Thinking in C++ ma sara' perche' l'inglese non lo conosco bene, ma non ho
trovato info in merito.

 di ritorno differenti.
Ok ora do un'occhiata alla libreria direttamente.
Grazie

 trovato info in merito.
Molto male... quasi tutto si trova in inglese... (pensa che io quando non
ho la documentazione finisce che RTFS...)
-- 
[ RiK0                                ]
[ non credo negli schemi non vincenti ]
[ two is an odd prime number          ]

 trovato info in merito.
Molto male... quasi tutto si trova in inglese... (pensa che io quando non
ho la documentazione finisce che RTFS... e pure quello e` in inglese.. )
