Newsgroup: it.comp.lang.visual-basic
Titolo: [OT] That's why I love C!

 x^=(y^=(x^=y));
lol :-D
--
Fibia "Sakamoto" FBI

:-)
LOL
Ciao,
Moreno
#sirri#@#morenosoft#.com
(togliete "#" dall'indirizzo)
Moreno Sirri VB Site - 
http://www.msvbsite.net
---------------------------------------------------------------------------
Le risposte alle tue domande le trovi sul Sito Comune di questo NewsGroup:
 
http://www.it-lang-vb.net
---------------------------------------------------------------------------

 --
???????
cosa significa?? che formula č ?
"x elevato a uguale" ??
dai dai dai dai... che cosa č... ??!! ::))))
MarioH

 temporanea.
Accidenti... non l'avevo mai notato!
Ma si può fare anche in VB anche se non altrettanto elegantemente (che però
in quanto a leggibilità...)
    a = a Xor b
    b = b Xor a
    a = a Xor b
Alla fine tutto quello che si risparmia però è la dichiarazione di una
variabile :(
Piuttosto mi lascia perplesso che
    a = a Xor b
    b = b Xor a
non equivale a
    a = b Xor (a Xor b)
Ma devo essere troppo stanco...
Ciao

terza temporanea.
tsk! la stessa formuletta che presentai ad un incredulo professore di 
Programmazione I alla fine di una delle prime lezioni (il genio è 10% 
ispirazione, 10% traspirazione e 80% culo). Solo che il Pascal non ha 
quella brutalità sintattica del C, e si limita ad un più educato:
x:= x xor y;
y:= x xor y;
x:= x xor y;
Il Pascal si rifiuta, inoltre, di fornire un equivalente al C-grugnito 
che segue:
#define swap(x, y) x^=(y^=(x^=y))

 #define swap(x, y) x^=(y^=(x^=y))
Orrore!!!
Ciao.

 ('na scheggia! :-)
Infinitamente piu' elegante, molto piu' semplice da utilizzare,
molto piu' utile e decisamente piu' efficiente:
template<class T> inline void swap(T& x, T& y)
{
     T z(x);
     x = y;
     y = z;
}
Ciao.

 passera' a 
VB.NET
.
Credo che i programmatori VB siano più intelligenti di quanto tu non creda e
credo che sceglieranno il linguaggio che gli garantirà la miglior
produttività e la miglior flessibilità (e sopratutto la migliore possibilità
di rivendersi sul mercato), se questo gli permetterà di non dover buttare al
vento anni di esperienza in VB, tanto meglio.
Se questo sarà VB.Net oppure C# non lo so, ognuno farà la scelta che riterrà
opportuna e senz'altro non sputerà nel piatto in cui mangia (o ha mangiato).
Corrado
PS: Vorrei suggerirti un giochetto per la prossima provocazione:
C ->         i++; (oppure ++i se preferisci)
VB.Net      i+=1
Oppure critica pure la totale mancanza di operatori di bit-shifting.

 wrote in message
news:9mth79$mqm$3...@lacerta.tiscalinet.it...


 wrote in message
news:gdsk7.63624$vC1.8...@news1.tin.it...


 for(;*b++=*a++;);
b = a  '(con b ed a string)
Ciao.

 sull'efficiente.
Lo e'. Il non volere utilizzare una terza variabile d'appoggio e'
decisamente fuori luogo.
Pensaci bene:
x^=(y^=(x^=y));
Il compilatore per fare questo e' costretto a creare 3 temporanei. E
sicuramente tre temporanei costano piu' di una sola variabile.
Ciao.

for(;*b++=*a++;);
ummaronna, e che è 'sto mostro? che fa, copia il buffer a nel buffer b 
finchè non incontra un carattere ascii 0?

op-code ('na scheggia! :-)
oh, beh, Delphi usa le fastcall, se ti tieni sotto i tre parametri hai 
praticamente una inline :) Certo, niente template o macro significa 
doversi scrivere:
procedure swap(var x, y: Ordinal); overload;
(* perchè le runtime di Delphi possono usare gli pseudo-tipi Untyped e 
Ordinal e io no??? il signor Borland mi sentirà... *)
begin
 x:= x xor y;
 y:= x xor y;
 x:= x xor y;
end;
procedure swap(var x, y: Pointer); overload;
 var
  intX: Cardinal absolute x; (* muhahahahahahahaha! *)
  intY: Cardinal absolute y;
begin
 intX:= intX xor intY;
 intY:= intX xor intY;
 intX:= intX xor intY;
end;
procedure swap(var x, y: String); overload;
 var
  z: String;
begin
 z:= x;
 x:= y;
 y:= z;
end;
(* ad nauseam *)

 il signor Borland mi sentirà... *)
Perche' il Pascal (e quindi l'OP), a differenza del C++, pone una
netta barriera fra quello che puo' fare il compilatore e quello che
puo' fare il programmatore.
Ciao.

 incontra un carattere ascii 0?
Si'. Non fa altro che copiare un array di char null terminated (le
stringhe del C) in un altro.
Quello che in VB bisogna fare con b = a ;-)
Ciao.

 denigrare altri linguaggi, et similia.
ROTFL! (per far capire meglio, hai presente il Trio Medusa alla trasmissione
le Iene?)
Ciao
Corrado


Forse perche' manca un assegnamento (che con VB non e' possibile fare) ?


puo' fare il programmatore.
Beh, ma quello che intendo io è che se vuoi essere pignolo puoi esserlo 
in un modo un po' più furbo. Ad esempio, non so se conosci l'Ada... 
l'Ada è uno dei linguaggi più disgustosamente type safe del mondo, *ma* 
ha una libreria apposita (chiamata, toh guarda, Unsafe :), che permette 
cose come array arbitrari, stringhe di lunghezza variabile, typecast e 
così via (e usando unicamente caratteristiche del linguaggio, come il 
tipo speciale "<>"). Ti viene data persino la libertà di posizionare i 
membri di una struct ad offset a tuo piacimento...

     a = a Xor b
Trovo il tutto moolto pericoloso. Provare per credere:
Dim a As Double ' ma anche Variant è uguale
Dim b As Double
a = 9900000000#
b = 10000000000#
a = a Xor b ' Boom!
b = b Xor a ' qui manco ci arriva
a = a Xor b ' e qui nemmeno
Non so come se la cavi il C, ma in VB io eviterei accuratamente di usare
questo codice.
Ciao
*Roby*

     mov eax,[ebp-0x08]
[cut]
Una delle mie (tante) pecche e' la completa ignoranza dell'assembly.
Comunque, orologio alla mano, i fatti mi danno ragione, anche se si
parla di differenze di 400 ms in un ciclo di 100.000.000 iterazioni
(ovvero praticamente inesistenti).
Ciao.

 (ovvero praticamente inesistenti).
E' più lento solo perchè non è parallelizzabile dal processore perchè usa
sempre gli stessi registri, mentre nel caso di un giro di Mov a 3 indirizzi
(ossia con l'uso di una variabile temporanea) questo problema non esiste.
Ciao
*Roby*

 questo problema non esiste.
Qualunque sia il motivo (grazie per la spiegazione), 1-0 per la mia
swap :-P
Ciao.


N.B. parlavo di "eleganza" (concetto profondamente personale) non di
prestazioni


 parallelizzate (al massimo 2 in parallelo, se non ricordo male).
Si, ma con le MOV, due si parallelizzano di sicuro e la terza si potrebbe
parallelizzare con l'istruzione successiva.
MOV ECX,EAX
MOV EBX,EAX ; fin qui si va in parallelo
MOV EAX,ECX ; forse parallelizzo con la successiva
XOR invece agisce sempre sullo stesso registro, quindi nel caso migliore
(dipende dallo spiazzamento fisico del codice) la prima si parallelizza con
l'istruzione precedente, e l'ultima con quella successiva. In ogni caso
resta l'XOR centrale che non è parallelizzabile, e questo sembrerebbe
giustificare lo scarto di qualche manciata di millisecondi nel timing fatto
da H.P.L.
XOR EAX,,EBX ; forse parallelizzo con la precedente
XOR EBX,,EAX
XOR EAX,,EBX ; forse parallelizzo con la successiva
Ciao
*Roby*
P.S.
Comunque come dicevi anche tu, si parlava di eleganza e non di velocità.
Però io al primo sguardo di quella funzione non avevo capito nulla, e questo
è molto poco elegante. ;-)

 writes:
RP> Non so come se la cavi il C, ma in VB io eviterei accuratamente di usare
RP> questo codice.
Direi che  non ha alcun problema  se dispone di un  tipo intero nativo
lungo a sufficenza -per cui usi un cast, dato che ^ non č definito sui
tipi floating point-, altrimenti (almeno il gcc fa cosě) si arrabbia a
compile time.
Direi che nel caso di VB non č la tecnica ad essere pericolosa...
--
Gian Uberto| main(){printf(&unix["\021%six\012\0"],(unix)["have"]+"fun"-0x60);}
Lauri      |                        David Korn, 1987 ioccc best one liner 
(aka saint)|-------------------------------------------------------------------
em@ail: 
sa...@eng.it
 ( vedere X-nospam nello header - see X-nospam in header )

 writes:
RP> XOR invece agisce sempre sullo stesso registro,
Ahem,  il   P.Pro  aveva  l'algoritmo  di  Tomasullo   (Tomasulo  ?  -
a.k.a. rinominazione dei registri) e quindi la frase non è così vera.
Se la cosa è stata portata anche nelle CPU successive...
