Newsgroup: it.comp.lang.c
Titolo: GRAZIE AL NG HO CAPITO CHE

finora ho buttato via un branco di vaini!!
Ho scaricato il DJGPP e, meraviglia delle meraviglie, MI RICOMPILA IL CODICE
SCRITTO PER BORLAND!!
Roba da non credere:  con un paio d'ore e qualche #define ho portato
progetti da 100.000 linee di codice da borland a djgpp, e il tutto
funziona!!!
E a quanto leggo dovrebbe anche essere possibile distribuire
(commercialmente) i programmi realizzati! Il tutto aggratisse!!! E
finalmente senza perdere tempo con overlay, spremitura fino all'ultimo byte,
divisione del progetto in piu' programmi diversi...:)))
So che non ve ne puo' frega' di meno, ma dovevo ringraziare il ng per aver
piu' volte citato il DJGPP: se non era per voi non lo avrei mai provato,
anche perche' pensavo non fosse compatibile con le funzioni non standard
della conio.h del borland... grande cosa!!!
Marco (che finalmente butta via il watcom, ma si tiene il vecchio turboc
perche' e' nostalgico)
PS: approfitto per una domanda tecnica, a qualche buon'anima che mi voglia
rispondere:
nel turboc se dichiaro
int    a[10];
int    b[10];
risulta essere b > a (come puntatori), ossia b viene allocato subito dopo di
a. Sapete se nel djgpp succede la stessa cosa?
Posso contare sempre sul fatto che in
char    s[100]
char    s1[100]
(s1 == (s + 100)) e' vero?
Grazie.

(s1 == (s + 100)) e' vero?
Non credo sia una caratteristica portabile.
Il seguente programma, sulla mia macchina, compilato col djgpp da'
"falso".
#include <stdio.h>
main()
{
    int a[100] ;
    int b[100] ;
    printf ( ( b == a + 100 ) ? "vero" : "falso" ) ;
}

 a. Sapete se nel djgpp succede la stessa cosa?
	Certo, infatti con:
#include <stdio.h>
#define ARRAY_LENGHT 10
int main(){
    int    a[ ARRAY_LENGHT ];
    int    b[ ARRAY_LENGHT ];
    printf("%i  %i", a - b, (int)a - (int)b );
    printf("\n%i  %i", (a - b) / ARRAY_LENGHT, ((int)a - (int)b ) / ( 
ARRAY_LENGHT * sizeof(int)) );
    return 0;
}
si ha il seguente output:
10  40
1  1
	Ciao,
		Giulio

if((tmplevel> 0)&&(tmplevel<10)) strcpy(volst,"BASS #              ");
Essendo la stringa costante di 20 caratteri si andava fuori di uno con volst
nella scrittura, ma non avrebbe dovuto toccare tmplevel se li avesse
allocati consecutivamente.
A meno che djgpp non faccia proprio il bravino e allochi tutto nello stack
(che "gira" al contrario, su macchine PC).
Daro' un okkiata al compilato.
Marco

 Giulio
Ok, ma cosi' vuol dire che ha allocato a a un indirizzo superiore rispetto a
b (a-b > 0), che e' il contrario di quello che mi serve.
Anche se in questo caso a e b vanno nello stack ed e' giusto che sia cosi'.
Spero che per variabili globali le allochi a indirizzi crescenti (ma in
fondo va bene anche cosi': mi basta che siano consecutivi, anche se messi al
contrario..)
Grazie, Marco

int    b[10];
Dimenticavo di dire "fuori dal main".
Cioe'
int    a[10];
int    b[10];
void    main(void)
{
int    c[10];
int    d[10];
    /*    ecc.ecc    */
}
Il turboc c e d se li mette nello stack, dunque vanno "a scendere", mentre a
e b li mette in un segmento dati e li alloca "a salire".
djgpp fa lo stesso?
Ma la cosa importante e': ci si puo' contare sul fatto che SICURAMENTE li
allochi in quel modo?
Marcopp

allocati consecutivamente.
E' vero, che stupido, non avevo considerato che le variabili vengono
allocate nello stack.
In effetti se dichiarate come globali vengono accodate, ma non credo
si possa contare che avvenga sempre cosi'.
C'e' una frase scritta sul K&R che recita "if you don't know *how*
they are done on various machines, that innocence may help to protect
you." ;)

 contrario..)
	Non lo sapevo. Infatti il codice:
#include <stdio.h>
#define ARRAY_LENGHT 10
    int    a[ ARRAY_LENGHT ];
    int    b[ ARRAY_LENGHT ];
int main(){
    int    c[ ARRAY_LENGHT ];
    int    d[ ARRAY_LENGHT ];
    printf("\n%i  %i  %i  %i", b - a, (int)b - (int)a, c - d, (int)c - 
(int)d );
    printf("\n%i  %i  %i  %i", (b - a) / ARRAY_LENGHT, ((int)b - (int)a ) 
/ ( ARRAY_LENGHT * sizeof(int)), (c - d) / ARRAY_LENGHT, ((int)c - (int)d 
) / ( ARRAY_LENGHT * sizeof(int)) );
    return 0;
}
ha questo output con DJGPP:
10  40  10  40
1  1  1  1
e con il Quick C, naturalmente:
10  20  10  20
1  1  1  1
	Ciao,
		Giulio

 wrote in message
7klo8l$j03$1...@nslave1.tin.it...
Snip


 
Io dico: assolutamente no!
Metti ad esempio il caso che il tuo PC non abbia a disposizione, in un
determinato momento 2*10*sizeof(int) bytes tutti di fila??
Vabbe', per degli int forse e' difficile, ma per strutture piu' complesse...
in generale, quindi, io non ci farei affidamento.
bye!
-- 
Emanuele Cesena                 
http://www.penguinpowered.com/~ecesena
ece...@penguinpowered.com
                 Attenti all'antispam NOSPAM
"1. Se hai dubbi, bofonchia
 2. Se hai problemi, delega", leggi di Boren

e non so se fa cosi'...
Secondo me ogni sistema agisce in questo modo, ma purtroppo rimane un
aspetto implementation-dependent, in quanto difficilmente
"standardizzabile".

determinato momento 2*10*sizeof(int) bytes tutti di fila??
Ma io non alloco con malloc, alloco staticamente. Cioe' allo startup del
programma (dove ho tutto lo heap pulito).
Nel turboc per dos addirittura questo spazio viene riservato anche nell'EXE
per cui si carica lo spazio (vuoto!) assieme all'eseguibile :)
Ad esempio watcom (come dgjpp) invece alloca appena il programma parte, ....
ed in effetti .... hai ragione, ho detto una cappellata: non posso essere
sicuro che ci sia spazio libero, a meno che lo startup non richieda al
sistema UN blocco contiguo di memoria per contenere le variabili globali....
e non so se fa cosi'...
Boh!
Marco (?!?)

nessuna parte. Che versione č?
eheheh! Si trova(va) da UN solo rivenditore in Italia a Bologna, che non mi
ricordo nemmeno chi e'.. e che se lo faceva arrivare dal canada, se non
sbaglio.
Marco++

 "standardizzabile".
In piu' io ricordo che l'aritmetica dei puntatori e' garantita solo
all'interno dello stesso vettore o struttura per cui non si puo' fare
affidamento sulla consecutivita' di variabili dichiarate di seguito nel
codice.

codice.
Esatto.
In generale si puo' dire che l'aritmetica su un puntatore e' garantita
solo all'interno dello spazio di memoria allocato per esso.
E' uno dei motivi, citato sulle FAQ, per cui non e' portabile scrivere
:
int array[10] ;
int *p = &array[-1] ;
ed utilizzare p come un puntatore che inizia da 1 anziche' da 0.    

Dov'e' la toppa?? :)
La toppa e' che, innanzitutto, &array[0] non equivale a &array.
In secondo luogo, con p[1] si intende *(p+1), ovvero *(&array[-1]+1),
e NON &array[-1+1] .
In questo caso, si prevede di dover calcolare &array[-1], il che, nel
caso di un particolare tipo di strutturazione della memoria, puo'
anche generare una segnalazione da parte del sistema operativo.
Nel thread abbiamo sottolineato il fatto che l'aritmetica su un
puntatore e' garantita solo all'interno del blocco di memoria allocato
per esso.


non capisco bene questi ultimi 2 punti... voglio dire, non andrebbe bene
definire l'aritmetica del puntatore anche al di fuori dell'area di memoria
in cui questo e' definito??
Finche' mi limito a calcolare un indirizzo di memoria, non do fastidio
a nessuno, e' quando voglio leggerlo e/o scriverlo, che allora il s.o.
dovrebbe verificare se ne ho i diritti...
bye!
-- 
Emanuele Cesena                 
http://www.penguinpowered.com/~ecesena
ece...@penguinpowered.com
                 Attenti all'antispam NOSPAM
"Esistono solo errori", assioma di Robert
"L'errore di un uomo e' la certezza di un altro uomo", corollario di Berman

in cui questo e' definito??
No, non e' previsto.

 
Mmm.. penso di aver capito :-)
bye!
-- 
Emanuele Cesena                 
http://www.penguinpowered.com/~ecesena
ece...@penguinpowered.com
                 Attenti all'antispam NOSPAM
"Per stimare i tempi di un qualsiasi lavoro: prendere il tempo che ci si
dovrebbe mettere, moltiplicare per 2, e cambiare l'unita' di misura con
quella immediatamente superiore. Ad esempio: per un lavoro che dovrebbe
prendere un'ora, si calcolano 2 giorni", formula di Westheimer