Newsgroup: it.comp.lang.c
Titolo: Decadenza di un array

  se l'indirizzo "numericamente" e' lo stesso).
Non capisco, quali sarebbero queste varianti?
Ho effettuato qualche test senza trovare differenze nei tipi, ma forse
non sapevo esattamente dove cercarle.
Ho svolto qualche prova, ottenendo risultati coerenti, senza
eccezioni. Ho provato usando i soliti Bc++3.1 e DevC++4.01
Premetto che per 'equivalente' intendo l'accezione matematica del
termine, che è più generale (e meno forte) di quella di uguaglianza.
La loro classe di equivalenza sarebbe l'insieme dei puntatori che
rispettano l'algebra dei puntatori per il tipo di dato dichiarato e,
passati come argomento ad una funzione, oppure assegnate ad un
puntatore variabile, generano sempre la stessa risposta.
In buona sostanza a tutti gli usi pratici che mi vengono in mente
potrebbero essere usate indifferentemente.
Questa precisazione non vuole essere pedante o didattica, vuole
evitare problemi causati dall'uso di differenti accezioni del termine.
Se in programmazione avesse un altro significato, correggetemi.
Detto questo, non solo tutti i puntatori citati nel quoting risultano
equivalenti, ma inoltre ho dimenticato per errore gli operatori &, e
la loro assenza non ha cambiato nulla, tranne ovviamente nel caso
della specificazione di tutti gli indici, nel qual caso non si tratta
più di un puntatore ma di un valore.
Risultano perciò equivalenti anche i seguenti
array[i]
array[i][j]
array[i][j][k]
... fino al penultimo indice specificato
A ben pensarci mi sembra logico, visto che ciascuno di essi identifica
un differente vettore.
Ho scritto un semplice programma per stampare una matrice di stringhe
(o array tridimensionale di char, o array di matrici di char... come
meglio credete), e indifferentemente dall'uso della forma matriciale,
o della forma algebrica (intendo la forma (mat i * N * M + j * M + k)
), per tutti i puntatori omologhi, i risultati sono stati sempre gli
stessi (le stringhe stampate sono state sempre le stesse).
Secondo la relazione di equivalenza definita sopra, tutti questi
puntatori sembrano perciò equivalenti.
Dunque... ammettendo che i puntatori non siano equivalenti, dove
sarebbe la differenza?
C'è qualche controesempio che possa chiarirmelo?
-- 
Cordiali saluti
  Artemio

... fino al penultimo indice specificato
Sorry... non intendevo *tutti* equivalenti tra loro, ma
array[i]
&array[i][0]
&array[i][0][0]
...
e cosě via per analogia. :-)
Scusate l'imprecisione.
-- 
Cordiali saluti
  Artemio

potrebbero essere usate indifferentemente.
Peccato che non sia cosi'.
#include <stdio.h>
int main()
{
    char array[5][5];
    printf("%d\n", sizeof array);
    printf("%d\n", sizeof &array[0]);
    printf("%d\n", sizeof &array[0][0]);
    return 0;
}
-- 
Andrea Laforgia (
walkie...@libero.it
)
"Usenet is a strange place" [Dennis Ritchie]

&array[0] e' un pointer-to-pointer-to-array[N]-T.
Ah, la distrazione: array decade, ovviamente, nel puntatore
al suo primo elemento ed e', quindi, un 
T (*)[N]
quindi un pointer-to-array[N]-T
-- 


C'è qualche controesempio che possa chiarirmelo?
Spero di essere stato chiaro. Io non ho capito che prova
hai fatto tu ... potresti mostrare il codice ?
HTH
Andrea

*(2+"ciao")
Tutto giusto, solo una piccola precisazione: 
Anche in questo caso il literal string e' un array e decade
nel puntatore al primo elemento.


e' errato.
Credo di esserci... Ora proverň a giocarci un poco...
Niente equivalenza dunque, a meno di non ridefinire la relazione, il
che diventerebbe troppo antiintuitivo.
-- 
Cordiali saluti
  Artemio

 che diventerebbe troppo antiintuitivo.
Quale relazione ?
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Quale relazione ?
Di equivalenza, quella definita precedentemente.
Ho inteso che *volendo* ci si potrebbe arrabattare per trovarne una
che renda equivalenti quei puntatori... ma sarebbe un pň come cercare
di dimostrare che la terra č il centro immoto dell'universo, e che
tutto le gira intorno... un casino inutile, come intuě Copernico
qualche tempo fa...
In generale una relazione č una legge che lega tra loro gli elementi
di un insieme, o anche di insiemi differenti.
Fra le possibili relazioni, le piů note (e intuitive) sono le
relazioni d'ordine e le relazioni di equivalenza.
Una relazione d'ordine per esempio č la maggiorazione o la
minorazione.
Immagino che le tue conoscenze matematiche superino le mie, quindi non
vado molto oltre, salvo precisare (a beneficio di chi non lo sapesse)
che la relazione di equivalenza non č solamente l'uguaglianza, ma
molto di piů. L'uguaglianza ne č un caso molto particolare.
L'equivalenza raccoglie gli elementi di un insieme in classi di
equivalenza, vale a dire in insiemi i cui elementi sono equivalenti
rispetto alla relazione definita precedentemente.
Per esempio dall'insieme delle auto posso stabilire una relazione
d'equivalenza dicendo che tutte le auto con lo stesso tipo di
alimentazione sono equivalenti (benzina, diesel, gas). Avrň quindi la
classe di tutte le auto diesel etc...
Infatti anche nel parlato, quando si parla di equivalenza solitamente
si definisce l'ambito entro il quale vale l'equivalenza.
'Ai fini della sopravvivenza immediata (definisce implicitamente la
classe di equivalenza) tutti i cibi sono equivalenti'.
La classe di equivalenza qui č l'insieme delle sostanza commestibili.
Su questo si basava la mia affermazione, meglio precisarlo.
-- 
Cordiali saluti
  Artemio

 Su questo si basava la mia affermazione, meglio precisarlo.
Come detto sopra:
Due puntatori a due tipi diversi NON appartengono alla stessa
classe di equivalenza.


classe di equivalenza.
Nell'ambito del C naturalmente: non stavo cercando di negarlo.
Nel caso in questione mi avete dimostrato che non è affatto vero.
La matematica apre maggiori possibilità, ma questo non c'entra molto
con la programmazione.
-- 
Cordiali saluti
  Artemio

Nell'ambito del C naturalmente: non stavo cercando di negarlo.
it.comp.lang.c


puntatori non equivalenti che forse facciamo prima.
Due puntatori con tipi diversi (come si sono rivelati quelli da te
evidenziati) oppure tue puntatori dello stesso tipo, ma ad indirizzi
diversi.
Non voglio approfondire troppo il discorso sulle relazioni binarie tra
gli elementi degli insiemi, perché siamo già troppo OT, temo.
-- 
Cordiali saluti
  Artemio

 gli elementi degli insiemi, perché siamo già troppo OT, temo.
Ecco, bravo, non approfondire.


   char m[20][20]; /* solo una scrittura */
Ti riferisci alle istruzioni eseguite dal processore?
-- 
Cordiali saluti
  Artemio

funzionava tutto.
*Ovviamente*.
Perche' non fai vedere da che cosa hai capito che i
puntatori che hai usato fossero equivalenti ?  Dacci una
prova di questa evidente equivalenza.  A me sembra che, come
al solito, tu citi degli esperimenti che nessuno ha mai
visto e che poi si rivelano fondati su errori grossolani.
Mostra il codice che hai usato e che illustra come questa
evidenza tra puntatori sia cosi' lampante.


>>>non sapevo esattamente dove cercarle.
Punto la tua attenzione su 'forse non sapevo esattamente dove
cercarle'.
Se ti sembra che invece io abbia affermato d'aver scritto un codice
perfetto e onnivalente, dimmelo e mostrami dove.
Il mio sorgente non è errato in assoluto, anzi mi pare formalmente
corretto.
Il problema è che non effettua la verifica necessaria al nostro caso,
perché quando l'ho scritto difettavo di alcune informazioni.
Ho provato da solo prima di chiedere nel NG, ma non avevo ancora
inquadrato correttamente il problema, quindi ho guardato nella
direzione errata.
Ora dispongo di qualche indizio in più.
Ti sembra tanto strano?
BTW nel mio messaggio c'erano anche un paio di domande che non ritengo
banali.
Perché fissarti su un'affermazione del tutto secondaria?
-- 
Cordiali saluti
  Artemio

 porta aperta.
I miei brevi e superflui messaggi sono serviti per farti
capire che quanto stavi dicendo era sbagliato.  
La porta era chiusa, te lo assicuro.
 
Tu, per quanto mi riguarda, puoi fare tutti gli esperimenti
che vuoi, pero' te lo ripeto ancora una volta, prima di 
rispondere a qualcuno che chiede chiarimenti, pensa 1000
e piu' volte a cio' che stai scrivendo, perche' sino ad ora 
hai soltanto tirato fuori idiozie derivate dai tuoi strampalati
esperimenti.


Ti riferisci alle istruzioni eseguite dal processore?
Mi riferisco alle operazioni logiche che l'esecuzione
di uno statement di tipo m[i][j]=0 comporta.
Andrea

esperimenti.
Veramente mi pare di avere *chiesto* un'informazione.
-- 
Cordiali saluti
  Artemio

Veramente mi pare di avere *chiesto* un'informazione.
Derivata da un consiglio sbagliato, confronta il thread
"Dubbio!!!", autore Kikko, 10/03/2002.


"Dubbio!!!", autore Kikko, 10/03/2002.
E chi se ne frega dell'origine, qui non era pertinente, è un altro
thread.
Riprendimi *quando* sbaglio, e non in un altro thread *scollegato*
dall'altro, quando l'altro discorso era ormai *chiuso*. Potevi
benissimo riprendermi in quella sede.
E' irrazionale lasciar correre quando commetto un errore, per poi
attaccarmi quando mi comporto ***correttamente***.
Mettiamo che tuo figlio rompa un mobile giocando a palla in soggiorno.
Secondo questo tuo modo di agire, ignorerai la cosa sul momento.
Successivamente tuo figlio andrà a giocare in cortile, poiché
dall'errore ha imparato a non giocare a pallone in casa.
A questo punto ovviamente gli piazzerai un bel calcio nel culo, perché
questo comportamento corretto deriva da un errore precedente.
Ma per piacere...
E non venirmi a raccontare che non mi stai attaccando: queste palle
raccontatele da solo, se subito dopo condisci il messaggio di senso di
nausea, repulsione nei miei confronti ed altre considerazioni
personali completamente OT, oltre che molto offensive.
Risparmiaci queste idiozie e parleremo di C, senza vaneggiare d'altro.
Ignorami se non riesci proprio a tollerarmi, ma evita di insultarmi, è
meglio per entrambi e per il NG.
Quando ho scritto il primo msg del thread pensavo di essere in
killfile e mi ha stupito leggere la tua risposta. Se vuoi saperla
tutta, mi ha fatto anche piacere, visto che credevo che non avremmo
più comunicato.
Ho cercato di risponderti sforzandomi di dimenticare il tono degli
scambi precedenti, cercando comunicare con te senza pregiudizi.
Cerca di fare altrettanto ed andremo d'accordo, altrimenti mettimi nel
fottuto killfile, e facciamola finita una volta per tutte.
-- 
Cordiali saluti
  Artemio

>esperimenti.
Me l'hai detto, contento?
In futuro però vedi di riprendermi *QUANDO SBAGLIO* e non *QUANDO MI
COMPORTO CORRETTAMENTE*.
-- 
Cordiali saluti
  Artemio

vale 8 e non 1.
Ho provato
#include <stdio.h>
int main(void)
{
  char matrice[8][8];
  printf("%d", sizeof *(matrice + 3 * 8 + 7));
}
Il risultato è proprio quello da te previsto.
Senti, tagliamo la testa al toro. :-)
Credo di essermi fatto una discreta idea grazie al tuo aiuto, ma
vorrei approfondire.
Puoi indicarmi qualche buona lettura?
Ovviamente se possibile qualche cosa di gratuito online. :-)
Il K&R non ne parla molto.
-- 
Cordiali saluti
  Artemio

 wrote:
Sorry.
Sono uscite due diverse risposte allo stesso post.
La seconda è quella scritta di getto, mentre la prima è quella
riassunta, la sola che avrebbe dovuto partire.
Mi è scappato un click in Forté Agent mentre spegnevo per andare a
dormire.
-- 
Cordiali saluti
  Artemio

Il K&R non ne parla molto.
Purtroppo non saprei cosa consigliarti. In realta' il K&R
dice quanto basta (nel senso che le cose fondamentali sono
dette... al resto si puo' arrivare con il ragionamento).
Io ho letto solo il K&R (una vecchia edizione relativa
al C pre-ANSI) e tutto il resto l'ho appreso per strada
quindi non so cosa consigliarti... le FAQ di comp.lang.c
sono comunque un punto di partenza riguardo agli errori
comuni su dichiarazioni complesse, NULL, 0, pointer e array.
Recentemente ho anche scaricato un documento sullo standard
C98 ma i documenti/draft di standard non vanno secondo me
bene se si hanno le idee confuse sui fondamentali... possono
servire solo a cercare dove e come spaccare un capello in 4.
Purtroppo i testi nel nostro campo costano abbastanza...
e in giro c'e' un sacco di spazzatura (testi che semplicemente
non dicono nulla di interessante e non ovvio o addirittura
testi che contengono cretinate sulle questioni delicate).
Io ad esempio sul C++ mi sono documentato comprando e
leggendo libri (non credo che con qualcosa complesso come
il C++ un approccio disorganico e puramente sperimentale
possa essere per nulla sufficiente) e la cosa mi e'
effettivamente costata non poco :/ ... 
Andrea

testi che contengono cretinate sulle questioni delicate).
Lo so (sigh...) ieri ho lasciato un obolo di oltre 100 euro per
comprare alcuni libri universitari. Già che c'ero però ho comprato
anche lo Stroustrup.
La penso come te circa la necessità di un apprendimento organico, e
preferisco imparare il C++ correttamente fin da subito. In parallelo
approfondirò gli aspetti oscuri del C, ma credo che si possano fare
entrambe le cose senza collisioni, no?
-- 
Cordiali saluti
  Artemio

Scusa se rompo ancora.
Volevo chiederti se da questo semplice esempio ti pare che io stia
iniziando a capire, o se mi trovi ancora molto fuori strada.
Funziona, ma non vorrei aver trascurato qualcosa.
#include <stdio.h>
int main(void)
{
  char matrice[8][8];
  char (*p1)[8][8], (*p2)[8][8];
  p1 = &matrice;
  printf("Data una matrice 8x8\n");
  printf("char matrice[8][8]\n\n");
  printf("*matrice %p,\t*matrice + 1 %p,\tdistanza %d\n", *matrice,
*matrice + 1, (char)(*matrice + 1) - (char)(*matrice));
  /* decade al primo char */
  printf("matrice  %p,\tmatrice + 1  %p,\tdistanza %d\n", matrice,
matrice + 1, (char)(matrice + 1) - (char)(matrice));
  /* decade alla prima riga */
  printf("&matrice %p,\t&matrice + 1 %p,\tdistanza %d\n", &matrice,
&matrice + 1, (char)(&matrice + 1) - (char)(&matrice));
  /* non decade affatto */
}
Output sul mio schermo
Data una matrice 8x8
char matrice[8][8]
*matrice FFB4,  *matrice + 1 FFB5,      distanza 1
matrice  FFB4,  matrice + 1  FFBC,      distanza 8
&matrice FFB4,  &matrice + 1 FFF4,      distanza 64
Per usare 'matrice' come puntatore ad una matrice (scusa la sfortunata
omonimia), devo usare l'operatore &, altrimenti decade alla sua prima
riga?
Se uso 'matrice' per l'algebra dei puntatori si comporta come un array
monodimensionale.
-- 
Cordiali saluti
  Artemio

 COMPORTO CORRETTAMENTE*.
Io ti riprendo quanto e quando mi pare e piace, nel tuo caso 
non e' difficile, visto che alterni 1 stronzata ogni 2.
Hai gia' promesso in un messaggio che ti saresti rimesso
a studiare.  Te lo chiediamo tutti in ginocchio: FALLO !.
Ora ti lascio perdere sul serio...


 è pre ansi, anche se riporta a caratteri cubitali 'ANSI' in copertina.
No, non e' la stessa.  
La II edizione del testo e' differente dalla prima.
La seconda edizione NON E' pre-ANSI.
Con pre-ANSI si intende antecedente al primo standard del linguaggio,
ratificato dal comitato ANSI/ISO del 1989.  Anche se il testo e'
stato pubblicato qualche istante prima che lo standard venisse
ufficialmente ratificato, tutto quanto e' contenuto nel testo e'
adeguato a quello standard.


adeguato a quello standard.
Mi sembra naturale fidarmi delle parole degli stessi autori del libro.
Se poi non esistono discostamenti dallo standard, tanto meglio.
-- 
Cordiali saluti
  Artemio

Ora ti lascio perdere sul serio...
Sarebbe anche ora, se sai solo renderti insopportabile.
-- 
Cordiali saluti
  Artemio

 Minime non vuol dire nulle.
Minime vuol dire "tutto".
Non e' cio' che si intende per linguaggio "PRE-ANSI", 
informati.  
Il linguaggio pre-ANSI e' quello che precede il primo
standard del linguaggio e che e' esposto nel K&R I
versione.


 approfondito sui puntatori.
"livore grottesco" ? ROTFL... ma fammi il piacere, imbecille.


"livore grottesco" ? ROTFL... ma fammi il piacere, imbecille.
PLONK
-- 
Cordiali saluti
  Artemio