Newsgroup: it.comp.lang.c++
Titolo: Operator OverLoad

Dear Friends !
Can any one help me with the following Exercise  ?
I need to write a program that Over Loading the Following Operators :
--,++, -, +, 
++ - Prefix & Suffix 
==,!=, ||
you should OverLoad in the way that you can to do the following
operations:
int+ob, ob+int when ob-name of the object.
thank you very much
==================================================
class three_d{
	int x,y,z;
public:
    three_d(int i, int j, int k);
    three_d();
    int get(int &i, int &j, int &k)
    {i=x, j=y;k=z;}
};
Thank You Very Much
Best Regards To All
==================
E-mail : 
a...@speedy.co.il
==================
Adi

Can any one help me with the following Exercise  ?
...
Here we go...
#include <stdio.h>
int main(){for(int
i=0;putchar(i++[""
"J(wf!cffo!tp!mbn"
"f!up!btl!uif!tpm"
"vujpo!up!nz!ipnf"
"xpsl!po!VTFOFU"]-
1)!='T';);}///////
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

1)!='T';);}///////
Che cosa ???? Che significa (niente, ovviamente)?
Domenico Barra

 ha scritto nel messaggio
news:kmZD5.15135$N93.5...@news.infostrada.it...

...eppure compila.
Non so perché, ma compila.
Non so come, ma funziona.
...prende per il culo la vittima in maniera pesante ;-)
Massimo


Forse meglio precisare anche:
#include <stdio.h>
int main(){for(int
i=0;putchar(i++[""
"J(n!po!uif!xspoh"
"!ofxthspvq/!"""""
"J(wf!cffo!tp!mbn"
"f!up!btl!uif!tpm"
"vujpo!up!nz!ipnf"
"xpsl!po!VTFOFU"]-
1)!='T';);}///////
P.S.
Non sapevo si potesse fare, ad esempio, 1["hello"] al posto
di "hello"[1].
Come mai è ammesso?
Manlio Perillo

 Come mai č ammesso?
Credo perchč:
 a[x]     equivale a 
 *(a+x)  che equivale a 
 *(x+a)  che equivale a 
 x[a];

Come mai è ammesso?
Urgh ! e' una delle cose ultrafamose del C ;)
a[b] = *(a+b) = *(b+a) = b[a]
--
Andrea Laforgia (ICQ 87230455)
------------------------------ 
#exclude <windows.h>

 a[b] = *(a+b) = *(b+a) = b[a]
Sbaglio o con un vettore di qualcosa di piů complicato dei byte (char) non
dovrebbe funzionare in quanto l'offset indicato dall'indice non č uguale al
numero di byte di cui spostarsi in memoria ?
Massimo

numero di byte di cui spostarsi in memoria ?
Funziona comunque ed e' la base dell'aritmetica dei puntatori C/C++:
se p e' un puntatore ad un "qualcosa" allora p+1 punta al "qualcosa"
successivo in memoria.
L'uso dell'aritmetica dei puntatori e' pero' garantito solamente
all'interno di un array di elementi (e' anche ammesso avere un
puntatore che punti "dopo l'ultimo elemento", ma non e' ammesso
dereferenziare questo puntatore).


 successivo in memoria.
Esatto, ma non dimenticare che a[b] significa *(a + b), ma "a" è un
indirizzo di memoria assoluto (quello della variabile a), ed è espresso
nella word della macchina (un byte in questo caso), mentre b è un numero di
elementi che possono essere anche più grandi di un byte. L'espressione
inversa "b + a" è quindi equivalente ad "a + b" solo se entrambi sono
espressi nella stessa unità di misura, e quindi solo se si tratta di un
vettore di char (byte)... o sbaglio ?
Se a è un vettore di char e l'indirizzo base è ad esempio 0x42424242, se b
vale 0x4 l'indirizzo dell'elemento sarà a + 4*sizeof(char), quindi
0x42424246, in quanto sizeof(char) vale 1. L'espressione inversa *(b + a) si
riferirà all'elemento numero a di un vettore che inizia all'indirizzo b, in
questo caso 4, e si raggiunge con uno spostamento di 0x42424242 byte, e
quindi i due indirizzi coincidono.
Ma se prendiamo ad esempio un array di long, abbiamo che sizeof(long) = 4,
quindi l'indirizzo dell'elemento d di un vettore c di long che inizi allo
stesso elemento di a sarà c + d*sizeof(long), quindi, prendendo sempre il
quarto elemento, varrà 0x42424242 + 0x4*0x4 = 0x42424242 + 0x10 =
0x42424252.
L'espressione inversa però in questo caso varrà *(d + c), quindi 0x4 +
0x42424242, e quindi verrà prelevato il valore all'indirizzo 0x42424246,
invalidando così la formula nel caso di un vettore di elementi diversi da
char.
Sbaglio qualcosa ?
Massimo

Sbaglio qualcosa ?
Si', sbagli nel non considerare il tipo del puntatore.
0x42424242 e' il valore di un puntatore di tipo "pointer to long",
quindi sommare 0x4 a questo valore significa, comunque, farlo avanzare
di 0x4 * sizeof( long ).
;)


 di 0x4 * sizeof( long ).
Mmmm... rimango dubbioso e attendo delucidazioni da qualche esperto :-)
Massimo

...

Andrea ha ragione: puoi assegnare (anche se non è consigliabile) un valore
assoluto ad un puntatore, ma qualsiasi numero tu vada ad addizionare o a
sottrarre al puntatore, sarà sempre (in termini di memoria)   n *
sizeof(type)
quindi, se ho un puntatore 'int *ptr' valido,
scrivere 'ptr+=4' equivale (sempre in termini di memoria) a scrivere
'ptr+=4*sizeof(int)'
Ciao
Domenico Barra

Mmmm... rimango dubbioso e attendo delucidazioni da qualche esperto :-)
Guarda che questo e' uno dei principi cardine dell'aritmetica dei
puntatori in C, ancor prima del C++.
E' bene assicurarsi di aver compreso bene questi argomenti prima di
approfondirne altri piu' complessi. 


 Non so come, ma funziona.
Niente di piu', niente di meno che :
#include <stdio.h>
const char *s = 
"I've been so lame to ask the solution to my homework on USENET"
int main()
{
    for ( int i = 0 ; s[i] ; i++ )
        putchar( s[i] ) ;
}
;)


;)
Già, l'avevo capito, ma quello che non avevo capito era il senso del
messaggio ;-)
Ciao
Domenico Barra