Newsgroup: it.comp.lang.c
Titolo: newbie su malloc

io non ho capito (seppur leggendo i var K&R e altri) come faccio a stabilire
quanta
memoria allocare per fare una determinata cosa.
per esempio:
Realizzare un programma che permetta di aggiornare una rubrica telefonica
inserendo
i prefissi telefonici opportuni.
Si dispone di 2 file di ingresso:
· in rubrica.dat è contenuta la rubrica telefonica, avendo su ciascuna riga
le seguenti
informazioni:
<cognome> <nome> <città> <numero di telefono>
· in prefissi.dat sono memorizzati i prefissi telefonici, avendo su ciascuna
riga le seguenti
informazioni:
<città> <prefisso>
Il programma deve scrivere un nuovo file (di nome rubnew.dat) in modo che
per
ogni riga del file rubrica.dat sia aggiornato il numero di telefono,
facendolo
precedere dal prefissotelefonico corrispondente alla città.
Per la soluzione del problema, si tenga in conto che il file rubrica.dat sia
di
dimensione arbitrariamente grande, tale da non poter essere contenuto in
memoria, mentre il file prefissi.dat è di dimensione limitata.
Non voglio il codice di soluzione,vorrei solo capire a che ammontare di
memoria
corrisponde la frase "di dimensione arbitrariamente grande".
Un grazie a tutti da parte di un newbie.

Andrea,

  In realta`, non ci sono grandi considerazioni da fare. In effetti,
puoi pensare il tuo algoritmo che legge una volta il file della rubrica
e, per ogni sua riga, rilegge tutto il file dei prefissi ovvero, se vuoi
ridurre i tempi operativi, leggere tutto il file dei prefissi in
memoria.
  In quest'ultimo caso, un'ottimizzazione rilevante sarebbe quella di
utilizzare per i prefissi una tabella di /hash/, in modo da recuperare
semplicemente il prefisso data la citta`.
  Per quanto riguarda la memoria richiesta, dunque, dipende dal tipo di
implementazione che preferisci.
	Alla prossima,
		Marco

 ha scritto nel messaggio
news:3B2DED4E...@bar.va...


Mi serve un esempio,se no non riusciro mai a capirla sta parte.
Affrontando il problema con il tuo sistema dovresti
typedef struct telefono
{
     char citta[20];
     char pref[5]; /* Credo che il piu' lungo abbia 4 cifre */
} TELEFONO; /* Nome molto di fantasia :-)) */
int foo(tipo... ergomenti)
{
TELEFONO rubrica;
TELEFONO *tel;
...
...
...
...
tel=malloc(sizeof(TELEFONO));
etc..
}
Automaticamente verra' riservata la memoria che ti serve...
Ho fatto centro con l'esempio oppure ho sbagliato argomento?
Igor ROssetti

 ha scritto nel messaggio
news:3b2f3906...@news.libero.it...


Guardate che mi fido,poi all'esame faccio cosi :-)
Uffa mi sono espresso male.
Non intendevo dire se la sintassi e' giusta o meno...
Intendevo: ho capito il tuo problema oppure ho parlato di fiaschi
mentre tu intendevi fischi? :-)
Se poi mi parli d'esame, non so che dirti. Certamente, se dovessi fare
una cosa del genere io, non userei per campi come il cognome variabili
a lunghezza fissa... Immaginati un elenco telefonico che ne so, di
MIlano, se dovesse usare campi di lunghezza pari al cognome piu'
lungo.... 
Igor ROssetti

 ha scritto nel messaggio
news:3b305638...@news.libero.it...


qualsiasi di coppie CITTA'-PREFISSO nella struct?
No. Cioe', non e' detto.
Quello che ho scritto io e' molto approssimativo, purtroppo...
In effetti quando allochi dinamicamente della memoria devi (cioe' puoi
anche fare a meno, ma non te lo consiglio) controllare il valore che
la funzione ti ritorna...
Come mi ha corretto qualche post fa Andrea Laforgia, malloc ha il
seguente prototipo
void *  malloc (size_t size)
cioe' ritorna un puntatore al blocco di memoria riservato.
Questa memoria risiede nell'heap ed e' finita(nel senso che ha un
limite). Se superi la quantita' disponibile, la funzione non riesce ad
allocarne ulteriormente e te lo segnala ritornandoti NULL...
Per quello che io non adotterei un sistema del genere, a meno di
archivi piccoli.
Igor Rossetti

 ha scritto nel messaggio
news:3b3188d0...@news.libero.it...


 qualsiasi di coppie CITTA'-PREFISSO nella struct?
Nella struct c'e` solo una coppia citta`-prefisso.
Il tuo programma dovra` essere strutturato cosi`:
leggi una linea della rubrica;
confronta la citta` con quelle disponibili nel file dei prefissi;
se trovi una corrispondenza {
	modifica il numero di telefono;
	riscrivi la linea sul nuovo file;
}
passa alla riga sucessiva;
Puoi anche cavartela senza malloc, prova ad usare dei buffer statici.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Il coraggio non mi manca.
E` la paura che mi frega...

 ha scritto nel messaggio
news:9gnv73$2dv$1...@dreamland.darkstar.net...


elimino,quando lo imparo?
Possibilmente, mai.
L'uso dei puntatori e' sempre sconsigliabile quando non
necessario.
--
Andrea Laforgia - walkietalkie(at)
libero.it
#exclude <windows.h>

 ha scritto nel messaggio
news:3b30eb3...@news.libero.it...


tel=malloc(sizeof(TELEFONO));
E' giusto, ma quel che voglio dire e' che se non e' strettamente
necessario utilizzare i puntatori, val la pena utilizzare una
struttura dati statica.


 ha scritto nel messaggio
news:3b38efe6...@news.libero.it...


 } TELEFONO;
Scusa ma definendo cosi' la struttura cosa crei in pratica?
Un nuovo tipo di variabile di tipo TELEFONO, giusto? E allora telefono
minuscolo cosa ci sta a fare?
Non avresti dovuto scrivere semplicemente cosi'?
typedef struct
{
      char citta[20];
      char pref[5]; /* Credo che il piu' lungo abbia 4 cifre */
} TELEFONO;
Grazie per il chiarimento
ciao
Christian

Non avresti dovuto scrivere semplicemente cosi'?
"potuto", non "dovuto".


 "potuto", non "dovuto".
giusta precisazione :-)
Ciao
Christian

Non so, mi sembra piu' pulito rispetto a
Non e' piu' pulito, e' illogico.
Quando dichiari *prossimo, Telefono non e' ancora stato
analizzato dal compilatore e il compilatore non sa cosa sia.
