Newsgroup: it.comp.lang.c++
Titolo: overload operatore []

salve,
allora ho una classe che effettua l'overload dell'operatore []
//...dentro la classe ...(classe pippo)
         string& operator[](string namef) const {
               return miometoto(namef);
        }
//questo funziona se lo uso con classi non puntatore così:
pippo a;
a["a"] = "testo dentro a"; //funziona
//se faccio così invece
pippo *a;
a = new pippo();
a["a"] = "testo dentro a"; //non funziona e mi da questo errore :  [C++
Error] E2034 Cannot convert 'char *' to 'int'
//se faccio così compila ma non l'ho provato in esecuzione
perchè ?

 Error] E2034 Cannot convert 'char *' to 'int'
  (*a)["a"]
MM

 ha scritto nel messaggio
news:cp8a71$njc$1...@newsreader.mailgate.org...

sono obligato ? non c'è modo di modificare l'overlod dell'operatore ?


Ma l'errore che prende, 'char *' to 'int, vuol dire che esendo a un
puntatore, a[n] equivarrebbe all'indirizzo di memoria
a+(sizeof(pippo)*n), per intenderci, e quindi cercherebbe di convertire
"a" ad n che e` intero ?
Il che significa che se era operator[](int) invece di string, non
avrebbe avuto l'errore a compilazione ma un "undefined behaviour" ?
Miii ...
Potresti fare a->operator[]("a") ma e` non credo ti piaccia.
Oppure:
	pippo* a_p;
	a_p = new pippo;
	pippo& a = *a_p;
	a["a"] = "testo dentro a";
Saluti
-- 
int

"int i=0 0" <'@.'> ha scritto nel messaggio 
news:1VWtd.33593$C94....@tornado.fastwebnet.it...

Alla seconda ci ho pensato anche
potresti gentilmente rifarmi il ragionamento ? ... non l'ho chiaro...
ma quindi con un puntatore ad una classe non posso utilizzare l'overload di 
un [] in maniera pulita ? per pulita intendo
p["ci"] = "ciao"; ?
mi pare strano ...

 non c'è modo di modificare l'overlod dell'operatore ?
no perche' nel primo caso usi direttamente un oggetto, nel secondo un
puntatore ad un oggetto.


pippo thepippo;
void f(pippo* p, int i)
{
    p[i] = thepippo; // che cosa dovrebbe fare ?
}
int main()
{
    pippo p[10];
    f(  p, 3 );
    pippo P;
    f( &P, 4 );
}
-- 
int

    p[i] = thepippo; // che cosa dovrebbe fare ?
[cut]
in che senso scusa...

 mi pare strano ...
Semplice: definendo "class pippo" tu hai definito un tipo ("pippo" appunto)
e su di esso hai definito un operator[] (che prende come parametro una
stringa). 
Ma il tipo "pippo" ed il tipo "pippo *" non sono per niente la stessa cosa,
sono due cose completamente diverse!!!
Sul tipo "pippo" e' definito un operatore [] ma sul tipo "pippo *" tu non
hai definito alcun operatore e non puoi nemmeno farlo.
Il C++ definisce in modo implicito un operator[] su tutti i dati di tipo
puntatore tale per cui vale la seguente regola (x valore numerico intero): 
p[x]  <=>  *(p + x)
Che e' poi la regola aurea che fa funzionare gli array e che permette di
trattare array e puntatori allo stesso modo... Una delle croci e delle
delizie del C e dei suoi successori...
A proposito... nessuno si e' mai accorto che si puo' scrivere anche qualcosa
di questo tipo:
------------------
int x[] = {1,2,3};
int y = 3[x];
------------------
Infatti: p[x]  <=>  *(p + x)  <=>  *(x + p)  <=> x[p]
:-)
Ciao!
-- 
Qual'e' il colmo per uno studente-lavoratore?
Avere un quadrato che si crede un rettangolo.


Heheh :-)
Grazie di tutto chiarissimo ora :-)

 Azzo questo č una limitazione .. perň..
Ma per favore, dai... se il typing e' una limitazione adesso... ci sono 
sempre le reference quando non vuoi lavorare con puntatori direttamente.
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://mbellett.web.cs.unibo.it/
Jabber: RedGlow  - Linux registered user 299762 @ machine 213003


sono d'accordo però... mha io la vedo cos' :-)
Cmq bella discussione mi è piaciuta... 

 in che senso scusa...
pippo* p dovrebbe capire se vuoi chiamare pippo::operator[](i)
oppure mettere nell'array di pippo puntato da p l'oggetto thepippo.
-- 
int

> qualcosa di questo tipo:
Err... qui mi sono scordato un punto interrogativo alla fine... Non era
un'affermazione, in realta' chedo che se ne fossero gia' accorti in
molti... :-)


 Azzo questo č una limitazione .. perň..
Non vedo limitazioni di sorta. Al limite ci si potrebbe chiedere se avrebbe
avuto senso introdurre una convenzione di questo tipo:
   a->["a"]
(Ma mi pare ci siano buone ragioni per considerarla infelice come
notazione.)
Max

 Infatti: p[x]  <=>  *(p + x)  <=>  *(x + p)  <=> x[p]
Un classico dell'obfuscated C contest :))
Comunque sempre divertente (e passibile di morte se lo si fa su un
codice serio ;) )
-- 
RiK0
Non credo negli schemi non vincenti.

 Un classico dell'obfuscated C contest :))
un classico dell'undefined behaviour, direi...
-- 
"It is better by noble boldness to run the risk of being subject to half 
the evils we anticipate than to remain in cowardly listlessness for fear 
of what might happen."
- Herodotus

 un classico dell'undefined behaviour, direi...
Daccordo sul primo, non tanto sul secondo... 
Dov'e' scritto nello standard? 
Se c'e' me lo sono perso...
...e non ho trovato nessun compilatore che non lo accetta.

 
per accettarlo lo accetta, ma:
------------------
 > int x[] = {1,2,3};
 > int y = 3[x];
 > ------------------
3[x] è come scrivere x[3], giusto?
quindi accedi il 4° elemento di x[], che non esiste perchè x[] è 
composto da tre elementi. Sbaglio qualcosa?


 ha scritto nel messaggio 
news:cpjpha$mr5$1...@localhost.localdomain...

Dove posso leggere lo standard ?
...

 composto da tre elementi. Sbaglio qualcosa?
Ah ah!!! Vabbe' hai ragione... :-)
Da come hai postato pensavo che ti riferissi alla regola generale.


 ...
leggi le faq! :p
-- 
sbi

 un classico dell'undefined behaviour, direi...
Infatti spesso negli Obfuscated Contest specificano per quale
piattaforma e` stato scritto. 


 Ciao!
Saluti,
fabiomdf
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/