Newsgroup: it.comp.lang.c
Titolo: chiarimento su malloc()

Ciao a tutti,
sarò breve: ho capito cosa fa la funzione malloc(), ma in pratica a cosa
serve?
Potreste farmi qualche esempio?
Vi ringrazio anticipatamente
Ciao

 Potreste farmi qualche esempio?
Serve per  allocare dinamicamente la memoria  ;) In pratica ti  serve in
tutti quei casi  (ma non solo in  quelli) in cui non  puoi determinare a
priori la grandezza o il numero di dati da memorizzare.
Pensa di dover leggere N interi  dall'utente e memorizzarli in un array.
Utilizzando un array statico dovresti porre dei limiti al numero massimo
di elementi,  e, nel caso  venissero letti pochi  elementi, sprecheresti
memoria. Con  malloc ti  crei un  array  della dimensione  che vuoi  (ed
eventualmente lo ridimensioni con  realloc). Oppure pensa agli alberi ed
alle liste:  sono strutture dati dinamiche  per eccellenza. Come faresti
ad attaccare un nuovo nodo senza malloc?
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
ATTENZIONE: il mio indirizzo email e` cambiato, quello vecchio verra` 
disabilitato a breve.
Un apostolo vedendo Gesu` camminare sulle acque:
- Cazzo se e` buono 'sto fumo!!!

 ha scritto nel messaggio
news:VRz28.15982$ly.5...@twister1.libero.it...

Es.
main()
{
     int *p;                                   //puntatore p(intero)
     p=(int*)malloc(4*sizeof(int)); //Alloca la dimensione del punatore a 4
(da p[0] a [p3])
     p[0]=1;
}

>     p=(int*)malloc(4*sizeof(int));
Togli il cast, non serve ed e' dannoso.
Mox

     p=(int*)malloc(4*sizeof(int)); //Alloca la dimensione del punatore a 4
Non ci vuole il cast:
p = malloc(4 * sizeof(int));
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
ATTENZIONE: il mio indirizzo email e` cambiato, quello vecchio verra` 
disabilitato a breve.
This message will self distruct in 5 seconds.

      p=(int*)malloc(4*sizeof(int)); //Alloca la dimensione del punatore a
4
Neanch'io ho capito bene l'argomento.
A che serve il primo int?


 p = malloc(4 * sizeof(int));
Ops, la mia vecchia abitudine a usare in C++....
Cmq il mio compilatore mi da: warning: assignment makes pointer from integer
without a cast
Bho
Ciao
--
Timothy Redaelli

 A che serve il primo int?
In che senso???
Definisci il punatore *p come intero....
Ciao
--
Timothy Redaelli

without a cast
Ecco perche' il cast non va' messo
provato a mettere
#include <stdlib.h> ?
Ecco perche' dico di non mettere sto cast?
Mox

 without a cast
Questo veniva mascherato dal cast. Includi la stdlib.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
ATTENZIONE: il mio indirizzo email e` cambiato, quello vecchio verra` 
disabilitato a breve.
Il dottore mi ha detto di smettere di fare cene intime per quattro.
A meno che non ci siamo altre tre persone.

Mox
Shinji-kun

 Io non ho capito perche` dici di non mettere il cast :(
Premessa: un  compilatore conforme allo  standard C89, quando  trova una
chiamata  ad  una funzione  non  dichiarata,  deve assumere  che  quella
funzione  accetti esattamente  quel tipo  e quel  numero di  parametri e
ritorni un int.
Ora, il seguente codice e` corretto e non presenta alcun problema:
#include <stdlib.h>
int main () {
	int *p;
	p = (int*) malloc(10 * sizeof(int));
	free(p);
	return 0;
}
E` possibile  solo rilevare  un cast in  eccesso. Lo standard,  fino dal
C89[1] (paragrafo  6.5.16.1), impone che  conversioni da un  puntatore a
void  verso un  puntatore  qualificato e  viceversa  siano implicite  ed
automatiche. Lo spezzone di codice puo` essere quindi riscritto come:
#include <stdlib.h>
int main () {
	int *p;
	p = malloc(10 * sizeof(int));
	free(p);
	return 0;
}
Questo pezzo di codice, all'apparenza corretto, nasconde un errore molto
subdolo:
int main () {
	int *p;
	p = (int*) malloc(10 * sizeof(int));
	free(p);
	return 0;
}
Non essendo stata inclusa la  stdlib, il compilatore non ha disposizione
il prototipo di  malloc. Assumera` quindi che il tipo di  ritorno sia un
intero. Il problema si presenta  quando sizeof(int) != sizeof(void*). In
questo caso l'indirizzo  restituito da malloc viene  troncato per essere
infilato  in  un  int  e  quindi riconvertito  a  puntatore  per  essere
assegnato a p. Risultato: undefined behaviour.
Questo spezzone, simile al precedente permette di rilevare l'errore:
int main () {
	int *p;
	p = malloc(10 * sizeof(int));
	free(p);
	return 0;
}
Qui  infatti il  compilatore si  lamentera` del  fatto che  stai facendo
un'assegnamento  tra  tipi di  dati  incompatibili:  stai assegnando  un
intero ad un puntatore.
Per finire, questo (sbagliatissimo) programmino:
int main () {
	int *p;
	p = (int*) malloc("pippo", "pluto", 666);
	free(p);
	return 0;
}
Il compilatore non si lamentera` di nulla, visto che non ha disposizione
il prototipo di malloc. Con il  cast esplicito abbiamo soppresso l'unico
avvertimento che poteva darci.
Se  non  sbaglio questi  discorsi  non  sono  validi  per il  C99,  dove
non  esiste  piu` la  dichiarazione  implicita  di una  funzione. Se  il
compilatore non trova la dichiarazione si arrabbia e basta.
Concludendo  aggiungerei che  il  cast e`  un'operazione rischiosa,  che
potenzialmente  viola la  tipizzazione  e le  regole  di promozione  del
linguaggio, e, IMHO, va utilizzato solo in casi straordinari.
[1]  Sul K&R  seconda  edizione, essendo  stato  pubblicato prima  della
stesura definitiva  dello standard, vengono ancora  riportati i cast. In
rete si possono trovare le correzioni.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
ATTENZIONE: il mio indirizzo email e` cambiato, quello vecchio verra` 
disabilitato a breve.
"Su cio` di cui non si puo` parlare e` bene tacere".
 Ludwig Wittgenstein

A che serve il primo int?
E' un cast:
poichè malloc ritorna un puntatore a void (vedi stdlib.h) bisogna
convertirlo in puntatore a int o a char.
In effetti questa conversione è obbligatoria solo col c++, mentre il visual
c++ della microsoft la richiede sia con file c++ che c,
quando lo standard ansi c specifica che la conversione da void * è
automatica