Newsgroup: it.comp.lang.c
Titolo: Quasi un giochino ... (per imparare qualcosa)

Chi di voi sa dire cosa stampa questo programma e perché?
Naturalmento il gioco consiste nel rispondere guardando solo il testo,
senza usare un compilatore per vedere cosa fa :o)
<Inizio codice>
#include <stdio.h>
int main()
{
    int i = 0 ;
    int num[10];
    for (i = 0; i < 10; i++)
        i[num] = i;  /* Attenzione a questa istruzione */
    for (i = 0; i < 10; i++)
        printf("%d\n", num[i]) ;
    return 0;
}
<Fine codice>
-- 
- Che cosa vuol dire "addomesticare"?
- E' una cosa da molto dimenticata. Vuol dire "creare dei legami"
		Antoine de Saint-Exupéry - Il piccolo principe

 wrote in message 381AF9...@tin.it...


        i[num] = i;  /* Attenzione a questa istruzione */
ciao

         i[num] = i;  /* Attenzione a questa istruzione */
Ho capito il tranello: in C i[num] e num[i] significano la stessa cosa.
Giusto?
EMG

    for (i = 0; i < 10; i++)


 wrote:
M>Chi di voi sa dire cosa stampa questo programma e perché?
[root@fokhouse /root]# grep -A 10 '^6\.11' /usr/doc/FAQ/txt/C.FAQ
6.11:   I came across some "joke" code containing the "expression"
        5["abcdef"] .  How can this be legal C?
A:      Yes, Virginia, array subscripting is commutative in C.  This
        curious fact follows from the pointer definition of array
        subscripting, namely that a[e] is identical to *((a)+(e)), for
        *any* two expressions a and e, as long as one of them is a
        pointer expression and one is integral.  This unsuspected
        commutativity is often mentioned in C texts as if it were
        something to be proud of, but it finds no useful application
        outside of the Obfuscated C Contest (see question 20.36).
[root@fokhouse /root]#
Ciao ciao,
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)


Se non ricordo male i compilatori valutano l'espressione v[i]  ==> *(v+i).
Da un "punto di vista notazionale" il nome di un array equivale ad un
puntatore al suo primo elemento (sento già i sensi di colpa).
v[i]   e   i[v]    sono lo stesso elemento perchè banalmente   *(v+i) ==
*(i+v).
Sono stato bravo?
Quindi il programma sopra dovrebbe stampare...............  ;-)))
Preso dall'euforia voglio proporre anche questo:
<Inizio codice>
#include <stdio.h>
int main()
{
    int i = 5 ;
    char a[]= "0123456789";
        printf("%c %c %c %c\n", 5[a], a[5], i[a], a[i]) ;
    return 0;
}
___________________________
Togliete NOSPAM per rispondermi
bye Brain


Questa è la risposta più esauriente... Fra l'altro puntualizza anche che
non è un buono stile di programmazione; rimane solo un giochino per
disorientare i più distratti ma niente di più.
Quindi nessuno si senta autorizzato ad usare *schifezze* di questo tipo.
La cosa che si impara, semmai, è quella di fissare in mente che quando
ci sono coinvolti degli array il compilatore del C traduce sempre
l'accesso indicizzato "num[i]" con un'espressione del tipo *(num+i)
facendo comunque "decadere" num ad un puntatore al primo elemento :o)
Ciao


 bye Brain
Risposta esatta!
Naturalmente il tuo problema non è altro che una riformulazione del mio,
e quindi la risposta è "5 5 5 5"


 
Sì, hai indovinato, ma avresti dovuto dire anche il perché (vedi
commutativitè dell'addizione).
Comunque per una risposta esauriente guarda l'estratto della FAQ
contenuto nella risposta di Andrea Foco.
Visto che stai studiando programmazione, colgo l'occasione per ribadirti
che quello mostrato nel "giochino" è un cattivo stile di programmazione
e quindi assolutamente da evitare :o)
Ciao e in bocca al lupo per gli esami
Marcello


 *(i+v).
Ma se v ha indirizzo 1234 e i= 1 diventa: *(1234+ 1)= 1; poi : *(1234+2)=2?
ma ciò non equivale a *(1234 + int)=1.
Dove sto sbagliando?
--
Marco @Madarco
mad...@hotmail.com
 &&§$$§&
&|@  @|#&
 '[   /  , ]## <- Io
  | °---> |#&
  \_, _/&&'

 ma ciò non equivale a *(1234 + int)=1.
Suppongo che per usare l'aritmetica dei puntatori, almeno uno dei termini
deve essere un puntatore, non credi?
Comunque magari funziona, non saprei
--
Alessandro Monti

 Dove sto sbagliando?
Francamente non ho capito qual è il tuo dubbio :o)
perché dici che, sotto le ipotesi da te enunciate, *(1234+ 1)= 1? e poi
*(1234+2)=2?
Se dato un puntatore a char (un char*) esso contiene il valore 1234, questo
vuol dire che alla locazione di  memoria all'indirizzo 1234 si accede
tramite il puntatore. Cosa la locazione contiene non lo sappiamo (o per lo
meno tu non lo dici).
l'espressione *(p+1) indica il valore della seconda locazione di memoria,
quella contenuta all'indirizzo 1235 (conterrà '1', 'a', '#', ... chi può
dirlo dato che non lo inizializzi prima?)
Se ho risposto alla tua domanda bene:o) se no riformulala più chiaramente
Ciao
