Newsgroup: it.comp.programmare.win32
Titolo: Linguaggi 0-based e 1-based

Salve,
tempo fa postai una domanda in merito, per sapere quale dei 2 modi di
considerare gli indici è migliore. Mi fu dato un'indirizzo con un
documento da consultare:
http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF
Siccome non ho molta dimestichezza con l'inglese qualcuno che conosce
questo argomento potrebbe riassumermi il vantaggio di usare il sistema
0-based? A me sembra di aver capito che il vantaaggio sia quello di aver
la lunghezza dell'intervallo facendo la differenza tra l'indicie
superiore e quello inferiore. Ma a dire la verità secondo me il
vantaggio di poter sapere che l'n-esimo carattere è quello di indice n è
anche meglio.
Grazie
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 anche meglio.
in C il vantaggio di poter sommare ad un puntatore un offset e di
trattarlo con la notazione degli array e' ben piu' grande
-- 
artemis.alpeia
http://spazioinwind.libero.it/artemis

 trattarlo con la notazione degli array e' ben piu' grande
Puoi scrivere un piccolo codice d'esempio?
Se C fosse 1-based quello che dici tu sarebbe meno intuitivo? Cioč si
dovrebbe considerare l'indice del puntatore - 1?
Ciao


 dovrebbe considerare l'indice del puntatore - 1?
esatto
-- 
artemis.alpeia
http://spazioinwind.libero.it/artemis

 esatto
A dire il vero era puntatore + 1 :)
Infatti
*p = 'c';
*(p + 2) = 'd';
per accedere a 'd' si deve fare p[3] visto che si parte già da 1 :D 
Cmq, secondo te che vantaggi ha un linguaggio 0-based come Java o Python
in cui non esistono puntatori?
Credo siano 0-based solo perchè sono scritti in C/C++.



Per molta gente e' piu "naturale" contare da 1 e lo zero li spiazza
un pochino, ecc. ecc.
Invece dal punto di vista della conversione da linguaggio ad alto
livello a codice macchina il sistema basato su zero e' piu semplice
e/o efficiente.
Es: [in pseudo-assembly]
     se devi fare un check di validita dell' indicizzazione m[k]
     con notazione 1-based devi eseguire:
     ; check indicizzazione che preserva la variabile indice
     cmp k,1
     jl  errore_di_indicizzazione  ; errore se k<1
     cmp k,max_indice_array_m
     jg  errore_di_indicizzazione ; errore se k >  max_indice_array_m
     oppure:
     ; check indicizzazione che modifica la variabile indice
     ; (bisogna usare un altro registro e/o poi ripristinare
     ;  il valore iniziale della variabile indice con una inc )
     dec k
     cmp k,lunghezza_array_m
     jnb errore_di_indicizzazione ; errore se k >= lunghezza_array_m
                                  ; (considerandoli valori unsigned)
     con notazione 0-based invece basta:
     cmp k,lunghezza_array_m
     jnb errore_di_indicizzazione ; errore se k >= lunghezza_array_m
                                  ; (considerandoli valori unsigned)
Almeno a "basso livello" la notazione 0-based e' la scelta migliore
(codice leggermente piu compatto, ecc. ecc.).
Semmai ci sarebbe da discutere se permettere oppure no a piu alto
livello il sistema n-based (il "costo" di 1-based
e' praticamente uguale a quello di n-based, tanto vale quindi
implementare la forma piu versatile).
L. Micheletto

Credo siano 0-based solo perchč sono scritti in C/C++.
No, i *linguaggi* non sono "scritti in C/C++".  I linguaggi sono
linguaggi.  Se, invece, ti riferisci agli interpreti/compilatori, la
questione 0/1-based č una scelta implementativa che prescinde dal
linguaggio in cui il traduttore č scritto.
-- 
Andrea Laforgia
Open Delphi Manual
http://groups.yahoo.com/group/delphi_open_manual/

 
http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF
Son stato io! :)
Il documento e` stato scritto niente popodimeno che da E.W.Dijkstra, uno dei
piu` grandi scienziati informatici. La disputa 0-based/1-based era una delle
sue tante fissazioni, tutti i geni sono un po' maniaci. :)
Anche se considero un blasfemo infedele chiunque usi notazioni o linguaggi
1-based (perche`? Perche` si`), non ritengo che ci siano delle ragioni
veramente importanti per preferire una forma all'altra; quello di Dijkstra
e` soprattutto un esercizio di stile, un sofismo.
Cio` che e` davvero pernicioso sono quelle situazioni in cui due o piu`
programmatori non si mettono d'accordo su queste convenzioni, cosi` uno
parla del "primo elemento" riferendosi all'elemento 0 mentre un altro si
riferisce all'elemento 1. Ti assicuro che questa non e` affatto una
questione di poco conto, mi capita quasi giornalmente di avere problemi
perche` i programmatori a piu` alto livello, essendo dei mangiatori di
quiche (cfr. altro mio messaggio), si esprimono con i numeri ordinali. :)
-- 
Lorenzo

Ma n-based sarebbe ad es 4-based anche?
Quindi ai caratteri della stringa "ciao" si accede con s[4], s[5], s[6],
s[7]?
ciao 


 s[7]?
Per n-based intendo che l'indice inferiore di un array non e' fissato
a priori.
Come avviene ad esempio con Pascal, Ada o il VB6.
L. Micheletto

 Come avviene ad esempio con Pascal, Ada o il VB6.
tali linguaggi fanno la sotrazione automatica a tempo di compilazione o come
si comportano con tali array ???
ciao

 si comportano con tali array ???
Sě, fanno la sottrazione automatica.

Goul_duKat wrote:

Dipende tutto dal processore per cui si genera il codice e dalla
sofisticazione del backend.
Per esempio, se hai un array a di elementi di tipo T definibile
in una specie di "C esteso" come:
T a[-128 to 128];
a) L' assegnazione "in C esteso" a[k] = v;
    puoi codificarla in "C semplificato" come:
       tmp=k+128; /* k - (-128) */
       *(a + tmp) = v;
b) Oppure a partire dalla definizione in "C esteso" generi una "alias"
    ad un ipotetico elemento di indice 0 [non importa che 0 faccia
    parte degli indici possibili, lo usiamo come riferimento].
    T a[-128 to 127];
    /* il compilatore "C esteso" definisce internamente
       un puntatore all'elemento a[0], descrivibile come:
       T *a0_alias = &(a[-128]) + 128;
       N.B. a0_alias e' semplicemente uno valore derivato
            dall'indirizzo base, se l'array e' allocato staticamente
            a0_alias non occupa spazio in memoria nel codice compilato
            perche "esiste" solo in fase di compilazione.
    */
    E cosi quando devi accedere codificare a[k] =v;
    Puoi codificarlo in "C semplificato" come:
		*(a0_alias + k) = v;
Ho usato il "C semplificato" per rendere la cosa comprensibile
anche a chi ha poca dimestichezza con l'assembly, ma
la forma b) e' molto piu semplice e compatta di a)
ad esempio in linguaggio assembly x86 l'equivalente a b) e'
semplicemente un indirizzamento indicizzato con offset
dove l'offset e' indirizzo_base_di(a) + sizeof(T)*128
(l'indirizzo fittizio di a[0] in "C esteso") invece
di indirizzo_base_di(a) come avviene con l'indirizzamento
0-based.
Questo significa anche che su un architettura che supporta
l'indirizzamento registro+offset con offset sufficientemente
grande da rappresentare un indirizzo di memoria qualsiasi
la differenza tra 0-based ed n-based e' relativamente ridotta
(la maggior "pesantezza" dell' n-based e' limitata
  al check degli indici a runtime).
L. Micheletto