Newsgroup: it.comp.lang.c++
Titolo: ma l'indirizzo nullo???

Salve ragazzi,
il punto è il seguente:
NULL o 0 per un puntatore che non punta a niente?
molti di risponderanno che uno vale l'altro ma a me purtroppo entrambi non
portano a nulla!!!! :-(((
mi spiego meglio
ho un ciclo che dovrebbe terminare quando trova un puntatore (di una lista
fatta tramite puntatori) che non punta a nulla.
ho provato sia con puntatore==NULL sia con puntatore==0 ma niente, il ciclo
non termina.
credo che mi manchi qualche passaggio cruciale sul discorso puntatori. Come
indicare una variabile puntatore a tutti gli effetti *vuota*?
grazie
ivan

 non termina.
Prova a postare il pezzo di codice rilevante (la struttura dati, il codice
in cui inserisci ed il codice dove il ciclo non termina).
Tommy

 portano a nulla!!!! :-(((
A questo punto, ho paura che il tuo puntatore di controllo di fine ciclo non
sia mai NULL.
Vediamo il codice.
Maurus

 fatta tramite puntatori) che non punta a nulla.
Immagino qualcosa del genere:
struct mylista
{
   int info;
   struct mylista *next;
};
Devi provvedere esplicitamente a porre il campo next pari a NULL quando ad
esempio generi una lista dotata di un solo elemento:
struct mylista *cella, *ptr;
cella = (struct mylista *) malloc(sizeof(struct mylista));
if (cella != NULL)
{
  cella->info = 5;
  cella->next = NULL;
}
ptr = cella;
while (ptr != NULL)
{
  printf("INFO: %i\n", ptr->info);
  ptr = cella->next;
}
free(cella);

 indicare una variabile puntatore a tutti gli effetti *vuota*?
int * p = 0;
Ciao,
Nicola

 int * p = 0;
[FLAME ON]
int* p = NULL;
[FLAME OFF]
;)
-- 
Luc.

 ha scritto nel messaggio
news:MPG.18ac486ac...@tornado.fastwebnet.it...
| Nicola Musatti ha scritto...
|
| > int * p = 0;
|
| [FLAME ON]
|
| int* p = NULL;
|
| [FLAME OFF]
|
|
perchè una soluzione del genre susciterebbe un flame?
sono curioso! :-))
ivan

perchè una soluzione del genre susciterebbe un flame?
Purtroppo c'è qualche imbecillotto che ama ribadire che l'uso di NULL
è migliore di 0, senza _alcun_ motivo valido.  NULL e 0, come ribadito
da Nicola (di cui ti raccomando di seguire i consigli) sono
esattamente la stessa cosa.  
-- 
Andrea Laforgia
#exclude <windows.h>

 sono curioso! :-))
Perche' c'e' chi crede che usare NULL sia come portare con se una bandiera
che dice "sono un principiante in C++".
A mio avviso non si puo' giudicare un programmatore dall'uso di NULL
piuttosto che 0. Ammesso che NULL sia questa gran schifezza in C++ (cosa che
non trovo vera) mi sembra che questa cosa da sola non sia abbastanza per
dare giudizi sulle capacita' di altre persone.
Ad ogni modo di questo si e' ampiamente parlato, e si e' scatenato un FLAME.
In pratica e' inutile andare avanti con questo argomento, se sei interessato
rileggiti i vecchi messaggi a riguardo. Li trovi su google.
Tommy

 esattamente la stessa cosa.
E' vergognoso come tu riesca sempre ad essere offensivo! (anche se questa
volta hai terminato in "otto").
Non riesci a comportarti da persona civile e smettere di dare giudizi
gratuiti sugli altri?
Poi io non "amo ribadire" nulla. Ho detto, ed una volta sola:
"Di solito invece di 0 si usa NULL (che vale 0). NULL e' piu chiaro, pensala
in questo modo: testa->next non punta a nulla (NULL)."
Questo e' il mio parere, se e' sbagliato amen, ma NON ho mai detto che NULL
sia migliore, ho detto che secondo me e' piu' leggibile, e poi il motivo
valido (contestabile, questo si) lo ho dato:
"NULL e' piu chiaro"
Questo e' quello che penso io. Se a voi e' piu chiaro 0 usatelo pure! Io non
do dell'imbecille a voi.... voi non datelo a me!
Il mondo e' bello perche' e' vario, ognuno ha le sue opinioni. Ma sono
opinioni, come fate a smentirmi?!? Non ci siete riusciti, siete solo
diventati offensivi. (come io non posso smentire voi, sono solo opinioni).
Il flame non e' nato poi per questa affermazione, ma per la risposta a
questo messaggio data da Sbirish:
"Non mi azzarderei a sostenere con tanta leggerezza che NULL vale 0 ( nè che
sia piu' chiaro :)"
La seconda parte, quella tra parentesi e' una opinione personale, ok, la
prima pero'.....
Io poi ho scritto:
"NULL e' standard, la sua implementazione non e' definita. Ogni compilatore
puo' dare la sua. Che sia 0, (void*)0, 0L,  o altro, ma non avra' mai valore
diverso da 0 (il
tipo puo' cambiare invece)."
Di solito e' 0L in C++.
E questa mia risposta a scatenato una valanga di commenti (a mio avviso)
senza senso.....
Ok, ho avuto persone che hanno detto :
"Adoperarlo è come portare una bandiera che dice "sono principiante in C++""
Gente che ha detto che NULL non era standard.
Gente che mi ha corretto dicendo che non faceva parte di cstdio ma solo di
cstddef, mentre fa parte di entrambi e di altri ancora.
etc.....
Il flame insomma e' nato per motivi ancora a me ignoti e non mi interessa
nemmeno scoprirli. Quello che so e' che non ci sono state argomentazioni
valide.
Mi interessa invece che gente come Andrea Laforgia smetta di dare commenti
sugli altri.
Tommy

 esattamente la stessa cosa.
E' vergognoso come tu riesca sempre ad essere offensivo! (anche se questa


[SNIPPED]
... ragazzi.. calma..
si discute per migliorare no?
un atteggiamento non rilassato non sempre porta a buoni rilsultati..
.. Tommy continui a postare doppio te.. sicuro sia un problema della tua
rete e non che stai usando un
Outlook non patchato?
Sbirish

 [FLAME OFF]
C-ista. E ho detto tutto.
Ciao,
Nicola

 Outlook non patchato?
Credevo di no, ma a questo punto controllo.... Pensa, ne ho postate due
copie a quanto pare ma io non ne vedo nemmeno una!
Credevo di aver patchato tutto, ora guardo se c'e' qualche nuova patch!
Grazie,
Tommy

si discute per migliorare no?
Infatti, è per questo che non leggo il Tommy a cui ti riferisci.
Per il resto, io sono rilassatissimo ;-)


 esattamente la stessa cosa.
Vi raccomando di leggere i viaggi di Gulliver...
Un popolo che faceva la guerra contro un altro per decidere se le uova si
rompono da sopra o da sotto...

 Nicola
ciao
    sbirish

 Tommy
sbirish

rompono da sopra o da sotto...
Personalmente, la mia scelta l'ho fatta (e uso, per la cronaca,
felicemente 0 al posto di NULL), io non faccio la guerra a nessuno.
Non val la pena combattere contro gli idioti, si fanno gią del male da
soli.


 esattamente la stessa cosa.
Io credo che NULL sia meglio di 0 solo per estetica, perchè così capisco che
è un puntatore (lo uso solo per i puntatori) mentre 0 mi potrebbe creare
confusione in quanto mi potrebbe far pensare di stare a maneggiare un
intero, anche se, a dire la verità, mi è capitato di usare entrambi
indistintamente anche nello stesso codice.
È vero anche che usare NULL fa occupare più spazio al file *.cpp perchè sono
4 caratteri anzichè 1 quindi occupa 3 byte in più per ogni occorrenza (vabbè
era una considerazione inutile).
Ciao

COBOL
Uuuh... un brivido mi percorre i denti...
"The use of COBOL cripples the mind; its teaching should, therefore,
be regarded as a criminal offence." (Edsger Dijkstra)


Č vero anche che usare NULL fa occupare piů spazio al file *.cpp
Questo č un buon motivo per non usarlo ;-))


 soli.
Andrea ora sei gia' passato ad: "idioti". Ti prego di moderare i termini.
Ti ripeto: "io non offendo te e tu non offendi me".
Discutiamo e basta, ... da persone civili!
Tommy

 be regarded as a criminal offence." (Edsger Dijkstra)
COBOL is for morons
- Dijkstra
muahahah
ho un amico che lavora in...
*cough*
stavo per dirlo..
in banca!
Sbirish

 C-ista. E ho detto tutto.
Allora siamo in molti, e parlo di gente veramente brava (ovviamente anche 
più di me)... Mi dispiace, ma il codice è più leggibile.
-- 
Luc.

 Io credo che NULL sia meglio di 0 solo per estetica
Non sei solo, ragazzo! ;-)))
-- 
Luc.

 in banca!
Sara' perche' ho quasi 40 anni e ho una visione molto
utilitaristica dei linguaggi di programmazione
(cioe' li vedo come strumenti piu' o meno adatti a raggiungere uno
scopo, non come una religione da difendere), ma non trovo
nulla di vergognoso nel programmare in COBOL
(anche se non ho mai dovuto farlo, a suo tempo
lessi un manuale del linguaggio, che nel frattempo
credo si sia parecchio arricchito).
Il COBOL e' nato con uno scopo ben preciso e
(sentendo persone che l'hanno dovuto usare professionalmente)
nel suo ambito era un linguaggio perfettamente
funzionale. Naturalmente nessuna persona sana
di mente pretende di scrivere un sistema operativo in COBOL.
(o in FORTRAN, che pure e' un linguaggio
  rispettabilissimo!)
Ciao,
g.

non trovo nulla di vergognoso nel programmare in COBOL
Vade retro, Satana !


 Discutiamo e basta, ... da persone civili!
Con lui la resistenza č inutile. Ignoralo che sparisce.
-- 
Luc.

 più di me)... Mi dispiace, ma il codice è più leggibile.
Tuo parere, che sia per o contro il NULL, non resta che tuo parere. Non lo puoi affermare come
fatto.
Claudio Puviani

 cstddef, mentre fa parte di entrambi e di altri ancora.
Secondo lo standard, NULL deve esistere, sia direttamente o indirettamente, in:
- cstddef (18.1/2)
- cstring (20.4.6/5)
- ctime (20.5/1)
- cwchar (21.4)
- clocale (22.3/1)
- cstdio (27.8.2/1)
- cstdlib (C.2.2.3)
È permesso definirlo altrove, ma non sarebbe portatile. Dovrebbe essere evidente da questa lista che
la ragione per l'esistenza di NULL è per supportare il porto di programmi C. Il fatto che non si
trovi negli "header" della libreria C++ è un'altra indicazione che NULL non è inteso per uso
generale in C++.
Oltre a questo, il NULL ne fai ciò che vuoi, ma aspettati di essere contraddetto spesso. :-)
Claudio Puviani

 Oltre a questo, il NULL ne fai ciò che vuoi, ma aspettati di essere
contraddetto spesso. :-)
Esatto! E visto che ognuno ha opinioni diverse, essere contraddetto e'
normale!
Ti ricordo tuttavia che mi hai dato del principiante perche' ho utilizzato
NULL invece di 0, mi e' sembrato (e mi sembra tuttora) eccessivo ;-)
In sostanza mi aspetto di essere contraddetto in modo civile, e ancora di
piu' mi aspetto di NON essere insultato (cosa che  Laforgia fa troppo
spesso).
Tommy

forse mr. shift voleva dire altro con i viaggi di gulliver
"Swift", non Shift.



Io lo uso invece per comodità e anche perchè il fatto che sia l'unica parola
in MAIUSCOLO risalta agli occhi e trovo subito ciò che mi interessa, tipo
segnalibro, anche perchè preferisco scrivere tutti i nomi di variabili in
minuscolo perchè il MAIUSCOLO da quando frequento i newsgroup e le chat mi
da un pò agli occhi.
Ciao

come dichiarazione e inizializzazione in un colpo solo, etc).
E` esattamente per questo che esiste l'International Obfuscated C Code
Context (qui, comunque, si parla di C++, non di C).


 Faccio finta di non aver letto...
 virtual void myfunct() = NULL;
ghghghgh!
è il futuro!! :P
Sbirish

 NULL invece di 0, mi e' sembrato (e mi sembra tuttora) eccessivo ;-)
Avevo detto: adoperarlo [NULL] č come portare una bandiera che dice "sono principiante in C++".
Anche se hai molta esperienza, č nonostante quello il messaggio che manda, a ragione o a torto. Uno
che č bravo, se la cava, ma se consigli a un principiante di adoperarlo, quel povero ne sara
sicuramente punito e non sapra difendersi. Era quello che spiegavo.
Claudio Puviani

 Context (qui, comunque, si parla di C++, non di C).
Che comunque sia e' un tantino diverso.....
Ne riporto uno breve e meno graficamente affascinante degli altri.
Guarda e dimmi se e' piu' sintetico... a me sembra SOLO piu' difficile da
leggere.
Ecco perche' dico che e' un tantino diverso da come dici tu:
<CODE>
#include <stdio.h>
#define A(a) G a();
#define B(a) G (*a)();
#define C(a,b) G a() { printf(b); return X; }
typedef struct F
G;A(a)A(b)A(c)A(d)A(e)A(f)A(g)A(h)A(i)A(j)A(k)A(l)A(m)A(n)A(
o)A(p)A(q)A(r)A(s)A(t)A(u)A(v)A(w)A(x)A(y)A(z)A(S)A(N)void Q();struct
F{B(a)B
(b)B(c)B(d)B(e)B(f)B(g)B(h)B(i)B(j)B(k)B(l)B(m)B(n)B(o)B(p)B(q)B(r)B(s)B(t)B
(
u)B(v)B(w)B(x)B(y)B(z)B(S)B(N)void(*Q)();}X={a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p
,
q,r,s,t,u,v,w,x,y,z,S,N,Q};C(a,"z")C(b,"y")C(c,"x")C(d,"w")C(e,"v")C(f,"u")C
(
g,"t")C(h,"s")C(i,"r")C(j,"q")C(k,"p")C(l,"o")C(m,"n")C(n,"m")C(o,"l")C(p,"k
"
)C(q,"j")C(r,"i")C(s,"h")C(t,"g")C(u,"f")C(v,"e")C(w,"d")C(x,"c")C(y,"b")C(z
,
"a")C(S," ")C(N,"\n") void
Q(){}main(){X=g().s().v().S().j().f().r().x().p().
S().y().i().l().d().m().S().u().l().c().S().q().f().n().k().v().w().S().l().
e
().v().i().S().g().s().v().S().o().z().a().b().S().w().l().t().N();}
</CODE>
<OUTPUT>
the quick brown fox jumped over the lazy dog
</OUTPUT>
Tommy

 credo si sia parecchio arricchito).
credo che nel frattempo sia morto, invece

 esattamente la stessa cosa.
certo che sei non poco maleducato e oltretutto stai dicendo una stupidata.
NULL è definito apposta per i puntatori ...
aggiornati e non solo sul C++ ma anche sulla netiquette

 fatto.
scusami ma a ceh serve questo tuo messaggio ??
NULL è definito apposta per i puntatori e non vedo il motivo di usare 0 che
potrebbe non essere adeguato in alcuni compilatori per svariati motivi.

 che potrebbe non essere adeguato in alcuni compilatori per svariati motivi.
Impossibile. Il linguaggio definisce il valore 0 come essendo il valore di un puntatore che non
punta verso niente. Qualsiasi compilatore che non supporti il 0 č difettoso. Infatti, lo standard
esige che NULL sia definito come 0 (o 0L) e non come (void*)0. Vale la pena leggere sia lo standard
che il libro di Stroustrup.
Claudio Puviani

>>fatto"
??
pero' e' davvero triste sta polemica per il "NULL" :)))
ciao

 pero' e' davvero triste sta polemica per il "NULL" :)))
Se non fosse polemica per il "NULL" sarebbe per altra cosa. Se solo Bush e i suoi manechini si
litigavano a proposito di "NULL" invece di voler far la polizia universale, il mondo sarebbe molto
piů bello. ;-)
Claudio Puviani

 più bello. ;-)
non sono per niente d'accordo....
non è bush che vuol far la polizia ma gli altri che vogliono fare i
malfattori :))
va beh lasciamo perdere perchè vedo che non saremo mai d'accordo :))
ciao

 sempre così, invece il "NULL" è più credibile :))
Ti consiglio solo di non mantenere questa teoria in un'intervista se vuoi l'impiego. ;-)
Claudio Puviani

 permesso.
E chi ha mai detto che NULL č uguale a (void*)0 in C++?
Studia ragazzo, studia! 
-- 
Luc.

 Ti consiglio solo di non mantenere questa teoria in un'intervista se vuoi
l'impiego. ;-)
l'impiego ce l'ho da 20 anni e quello che dico è credibile,invece  il tuo
dare un valore unico  non solo per un puntatore è sempre sbagliato in quanto
potrebbe cambiare in qualsiasi momento.
Chi ti dice che in futuro non sia meglio mettere a 1 tutti i bit ?? Non puoi
conoscere adesso l'evoluzione del futuro e abituarsi ad un valore costante è
semrpe sbagliato.Poi se guardi altri compilatori tipo delphi non si usa mai
"0"..
ciao :)

 esattamente la stessa cosa.
Troppo buono...
Ciao,
Nicola

no.
jonathan shift.
john driver.
daniel default.


 Studia ragazzo, studia!
Rispondevo a Tommy che ha detto: "Ogni compilatore puo' dare la sua. Che sia 0, (void*)0, 0L, o
altro, ma non avra' mai valore diverso da 0 (il
tipo puo' cambiare invece)."
Prendi la pena di leggere i messaggi ai cui rispondi prima di gonfiarti il petto e far la morale. Ti
sei messo il dito nel occhio fino al gomito. Se invece di fare il pagliaccio avesti seguito il
discorso, avresti ben visto che l'ho anche citato nella mia risposta.
Claudio Puviani

 Poi se guardi altri compilatori tipo delphi non si usa mai "0"..
Ma cosa possono ben aver da fare il Delphi o il Java o il COBOL con le regole del C++? Non fai
senso. Resta nel mondo del C++.
Claudio Puviani

> Lo standard lo dice, a me come a tutti, nero su bianco. Leggilo. Ne hai
bisogno.
senti dei maleducati ne abbiamo abbastanza ,viste anche altri tuoi post su
questo thread.Io non ho bisogno di nulla  e che lo standard dica di usare 0
non significa che sia la cosa migliore.
Se non sai ragionare con il tuo cervello cerca di imparare a farlo.Non hai
mai dato ragioni valide ti sei solo riferito allo standard e non mi sembra
che sia valida come spiegazione.
PLONK


E dove sta scritto? Se io scrivo int x=NULL e me lo accetta (il compilatore)
vuol dire che è fattibile e quindi non capisco perchè dovrei utilizzarlo
solo coi puntatori (anche se io lo uso solo lì alla fine dei conti).
Ciao

 solo coi puntatori (anche se io lo uso solo lě alla fine dei conti).
questo č sbagliato...
perchč su altri coompilatori non sai che valore potrebbe avere NULL,
addirittura potrebbe essere una macro.
Non usare mai valori alfanumerici non creati per il motivo giusto e NULL č
solo per i ptr.

 Prendi la pena di leggere i messaggi ai cui rispondi prima di gonfiarti il petto e far la morale.
Fatto.
NULL, in C++, è 0L. Non ci sono particolari discussioni da fare. Quindi 
quello che si riempie il petto non sembro essere (solo) io...
-- 
Luc.

 addirittura potrebbe essere una macro.
NULL *e'* una macro, che a norma di standard deve essere definita come
un espressione intera di valore zero.
Ciao,
Nicola

...

Mi spiace, ma Claudio ha ragione. Se tu ti ostini a sostenere opinioni
non suffragate da fatti, non puoi che aspettarti risposte come la sua,
che tra l'altro, e' sicuramente "decisa", ma non mi pare maleducata.
Secondo lo standard del C++ un puntatore nullo e' rappresentato con
una qualsiasi espressione costante intera di valore zero. Quindi:
int * p = 3 * 4 - 12;
char * p2 = '\0';
sono inizializzazioni valide. La convenzione, che come ti e' stato
detto e' suggerita da Stroustrup stesso, e' di rappresentare i
puntatori nulli con lo zero. Nota che questa e' una rappresentazione
convenzionale: non e' detto che il sistema sottostante rappresenti i
puntatori nulli con una word di zeri; e' il compilatore che si
preoccupa di tradurre lo zero convenzionale nell'opportuna
rappresentazione.
NULL invece e' una macro che il C++ eredita dal C. La differenza e'
che in C NULL puo' assumere un qualsiasi valore definito
dall'implementazione (quindi ad esempio l'effettiva rappresentazione
del puntatore nullo, quale essa sia); invece  in C++ NULL deve essere
definita come un'espressione intera costante di valore zero.
A livello sintattico quindi NULL e 0 sono la stessa cosa. Ora, se da
una parte e' vero che quando vediamo NULL pensiamo ai puntatori,
dall'altra questa e' una convenzione molto debole, perche' non e'
assolutamente supportata dal compilatore. Prendi ad esempio il
seguente programma:
#include <iostream>
#include <cstdio>
template <typename T> void f(T t) {
  std::cout << "sono un valore\n";
}
template <typename T> void f(T * t) {
  std::cout << "sono un puntatore\n";
}
int main() {
  f(NULL);
}
Secondo te che cosa stampa?
Ciao,
Nicola

 un espressione intera di valore zero.
macro di solito si intende un insieme di operazioni,definire un ptr a 0 non
la si puo proprio definire macro ..
cmq son dettagli e le precisazioni son sempre ben accette tnx
ciao :)

 Secondo te che cosa stampa?
dipende dal compilatore e come definisce NULL ...
non si puo' dare una risposta.
potrebbe definirlo (void *)0 e stamperebbe "sono un puntatore " o credo che
è sia più diffuso come 0 ed ovvio che stampa come valore
Quello che ti voglio dire che non si puo' seguire lo standard se molto
probabilmente mettere a 0 il ptr in futuro potrebbe cambiare.Usare NULL ti
da la sicurezza che il tuo codice anche se NULL cambiasse sarà sempre
giusto.Poi se mi vuoi dire che è meglio seguire lo standard posso anche
capirti , però non mi smebra giusto visto che NULL è definito in tutti i
compilatori.
ciao

 Secondo te che cosa stampa?
E questo cosa stampa?
int main() {
  f(0);
}
la stessa cosa!!!
e... ad essere sincero con un main del genere:
int main() {
  int a=5;
  int *pa=&a;
  f(pa);
}
il mio compilatore dice:
"none of 2 overload have a best conversion - ambiguous call to overloaded
function"
Mentre il seguente codice:
<CODE>
#include <iostream>
#include <cstdio>
void f(int t) {
  std::cout << "sono un valore\n";
}
void f(int * t) {
  std::cout << "sono un puntatore\n";
}
int main() {
  int *p=NULL;
  f(p);
  return 0;
}
</CODE>
che ora funziona, stampa:
"sono un puntatore".
In pratica mi chiedo che cosa tu volessi dimostrare?
Che NULL di per se non e' un valore puntatore ma un valore "intero"? Ovvio,
ma anche lo zero che preferite usare.
Ad ogni modo da ora in poi ho deciso su questo NG di postare con 0 invece di
NULL, tanto a mio avviso vanno entrambe bene e cosi' evito di postare cose
che potrebbero creare solo casino!
Tommy

 compilatori.
Questa e' una cosa che funziona allo stesso modo da almeno vent'anni.
La probabilita' che cambi e' molto, ma molto, ma molto bassa.
Ciao,
Nicola

 compilatori.
"Molto probabilmente"... non capisco da dove tu possa trarre questa tua
convinzione. Comunque è proprio il seguire lo standard che ti può
permettere di ridurre al minimo sorprese derivanti da eventuali 
cambiamenti futuri del linguaggio.
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

 La probabilita' che cambi e' molto, ma molto, ma molto bassa.
Questo lo dici tu.Io Potrei anche dirti che NULL è sempre definito a 0 e che
la possibilità che cambi in futuro è minima.
Magari preferirei un tono meno arrogante da parte tua nessuno ti obbliga a
tenere la conversazione se non ti aggrata.
ciao

 Altrimenti si possono trovare segni (come il tuo ?) vaganti.
e chi se ne frega         ?
Queste trollate non mi interessano.
Per il resto hai scopiazzato quello che hanno detto gli altri.Le stesse
risposte valgono anche per te perciò rileggile.

 risposte valgono anche per te perciò rileggile.
Ho semplicemente detto quello che c'era da dire...
Per il resto le tue non sono risposte, ma vaneggiamenti. Pertanto chiudo
qui la discussione che è solo tempo perso.


 qui la discussione che è solo tempo perso.
vaneggiamenti saranno i tuoi idiota.
Rileggiti la netiquette
addio

 Prima di insultare almeno prova quello che scrivi
sarebbe buona norma.. contenersi ed evitare certi appellativi..
quando una discussione prende una piega simile diventa davvero poco
producente..
E' solo un invito a moderarsi..
Sbirish
 ( ... 'ha_cominciato_lui' is not a valid identifer... )

 E' solo un invito a moderarsi..
io sono d'accordissimo però non sono partiti da me ..
io ho cercato di mantenere la discussione obiettiva rispetto all'uso di
NULL,ma qui non interessa a nessuno ,almeno sembra cosi'
ciao :)

 tenere la conversazione se non ti aggrata.
Se ti sono sembrato arrogante me ne scuso. Resta il fatto che in
questa conversazione hai presentato quelli che secondo me sono
pregiudizi che non hanno riscontro nella realta', prova ne sia che
finora non hai presentato un esempio concreto di un compilatore che si
comporti, per questo aspetto specifico, in modo diverso da come
specificato dallo standard del linguaggio. Senza un simile esempio le
tue preoccupazioni suonano assolutamente infondate, poiche' riguardano
un aspetto, del C prima e del C++ poi, che non e' cambiato negli
ultimi venticinque anni.
Ciao,
Nicola

 che potrebbero creare solo casino!
Paura, eh? :-) :-) :-)
Ciao,
Nicola

 Ma cosa stai dicendo?! Sei sicuro di star parlando del C++?
Nicola, lascialo perdere, e` un troll.
Se vai a cercare i suoi post di qualche settimana fa ne trovi uno in cui 
si definisce "principiante di c++ e della programmazione", salvo poi 
scrivere qualche giorno dopo su it.comp.programmare di avere 23 anni di 
esperienza di programmazione...
Quando gli e` stato fatto notare che si era definito "principiante" ha 
detto di averlo fatto per scherzo... mah!
ciao Anto
-- 
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra

 della memoria diversi da new/delete.
malloc e free :) /* argh :P */
sbirish

> Nicola, lascialo perdere, e` un troll.
troll sei tu IMBECILLE soprattutto guardando le risposte che hai dato in
altri thread...
e impara un po' di educazione non vedo il motivo del perchč dai del troll
quando ti ho fatto notare che stai dicendo stupidate (in altri thread).
maleducato
ps : ho solo esposto i fatti di come la penso tu invece hai solo insultato.
ari-maleducato..
e qua il troll in questo caso sei tu.
ari-maleducato..

 ultimi venticinque anni.
Secondo me non hai capito o non mi sono spiegato bene cosa intendo.
capisco benissimo che lo standard dica di usare "0" e inutile che
continuiamo a dirlo.Quello che voglio dire che assolatamente poco
vantaggioso e te ne elenco i motivi:
1) migliore leggibilità     //e qua siamo d'accordo.
2) NULL è controllabile dal compilatore in quanto puo' definirlo come vuole
nelle versioni di upgrade.
3) anche un principiante quando vede NULL sa benissimo di cosa si sta
parlando.
4) in futuro semmai ci saranno cambiamenti della gestione della memoria,
NULL potrà essere ridifinito dal compilatore in quanto facente parte degli
header
5) NULL è definito in *tutti* i compilatori e solo un matto togliere questa
macro è assolutamente antiproducente e renderebbe moltissimi codici da
correggere.Di conseguenza si puo' dire che è standard (anche se non lo è
veramente).
6)Possiamo ridifinirlo noi stessi con facilita semmai avessimo bisogno di
gestire la memoria in un certo modo.
e bla bla bla
se parliamo di contro:
1) lo standard  (e questo è l'unico contro)
sulll'uso di 0 vediamo di elencare qualcosa (poi semmai concludi tu).
pro:
1) lo standard (se pur importante ma la vera utilità è opinabile)
contro:
1) leggibilità nulla.
2) non è controllabile in alcun modo dal compilatore (invece NULL essendo
una macro...)
3) se in futuro cambiasse la gestione della memoria è fonte di errori
(ovviamente è futuristica la cosa,ma non è detto che i compilatori c++ in
futuro non abbiano una gestione della memoria migliore di quanto possiamo
fare io e te)
4) è un valore fisso..sappiamo benissimo che qualsiasi tipo di variabile non
andrebbe mai inizializzata con un valore fisso ma dove possibile con una
macro.
questo è la mia conclusione visto che altri insinuano che ho voglia di far
casino, cosa che invece non è asolutamente vera.Ti ho semrpe risposto con
modi da persona civile e i newsgroup son fatti epr discutere qualsiasi
argomento e magari senza arroganza(non mi riferisco a te ovviamente ma altri
incivile che hanno risposto in malomodo)
ciao
ps: sarei curioso che mi elencassi qualche pro dell'uso dello '0'(che sia
dettato dallo standard lo si sa gia).

 altri thread...
non lamentarti della maleducazione altrui, se poi sei tu stesso maleducato,
dando dei titoli alla gente....


in parte hai ragione però non mi pare di aver cominciato io :)
cmq non hai torto chiedo scusa..
ciao

 dettato dallo standard lo si sa gia).
P.s: non è dettato dallo standard, e nessuno l'ha mai detto qui.
Sbirish

 invitato a mantenere un contegno, ma sembra non abbia giovato.
insulto io ??
se mi trovi un solo insulto dove ho cominciato ..
quel punto dove hai detto di mantenere un contegno non erano partiti da me
gli insulti.
ma anche qui sei solo diventando maleducato e non hai seguito per nulla.
Leggi tutto il thread prima di parlare
Non ti risponderò più in quanto oltre a dare motivazioni sbalgiate e
scopiazzando qualcosa di quello gia detto non sai conversare in modo civile
perciò addio
plonk

 0.
Si, come no....... Pensa te.... ;( 
-- 
Luc.

 plonk
Non ho sicuramente risposto per te in questo post..
ho risposto per evitare che le tue affermazione erronee
fossero prese per buone.
Per quanto riguarda il plonk.. grazie per la notifica.. ma credo
riuscirò a dormire lo stesso stanotte.
Sbirish

 riuscirò a dormire lo stesso stanotte.
buona notte

 non definisco stupidate per non rientrare nella vendetta)
non ero nel tuo killfile?
Uno sbirish e la coerenza.

 PURTROPPO ho dovuto seguire.
oohhh e si vede pure :))
cmq addio stammi bene :)))

 oohhh e si vede pure :))
mettimi davvero nel tuo killfile ora per favore.
Uno sbirish scusate gli ot.

 25 anni. credo 10 piu' di te ad occhio.
purtroppo 15 in più in aprile

 char * p = NullPtr<char>;
con quella sintassi e` ovviamente impossibile, pero` si puo` fare 
qualcosa del tipo (non testato):
class NullPointer {
public:
     template<class T> operator T*() const { return 0; }
};
const NullPointer Null;
char* p = Null;
int* p = Null;


 int* p = Null;
Non capisco come farebbe a funzionare!?!?
Tommy

 dettato dallo standard lo si sa gia).
Vedi sopra. In realta' ad entrambe ci si abitua. In C scrivevo NULL e
continuerei a farlo se scrivessi ancora C. In C++ mi sono abituato
allo 0 ed il NULL mi urta.
Ciao,
Nicola

 trova nel codice nel valore appropriato.
mi sono spiegato male vorrei precisarti alcune cose (e poi basta metto fine
alla discussione altrimenti è uno stress per tutit)
1) per compilatore intendevo il *programma* e nello stesso è incluso il
preprocessore. Chiaro che per il compilatore NULL = 0 ed è il preprocessore
che ci pensa.Quando dico che NULL è controllabile dal compilatore è dovuto
al fatto che il preprocessore sostituisce il codice più idoneo per NULL (in
questo caso 0).Se in futuro il codice più idoneo non sarà un semplice 0
l'upgrade allo stesso preprocessore o file header che definiscono NULL
aggiornerà automaticamente anche il codice e il compilatore agirà di
conseguenza.
3) NULL *puo'* essere definito da noi basta un semplice #undef non è
un'illusione(anche se  dovrebbe essere definito in modo correttto dalla casa
che ha programmato il compilatore o meglio il preprocessore, visto che
altrimenti si fa confusione).
4) poi dire che 0 è supportato è si  giusto ma sbagliato perchè non ha
nessun controllo,è permesso solo l'assegnamento al ptr.NULL puo' essere
aggiornato come meglio si crede(ovvio sempre dalla casa madre).
5) Poi ho preso in considerazione le macro in quanto hanno più flessibilità
e possono contenere codice di ogni genere ma anche un tipo enumerativo o
costante come dici tu va semrpe meglio che un semplice 0,in quanto una
futura modifica ha effetto su tutto il codice.
cmq penso che ne abbiamo dette a sufficienza magari punti dove non è chiaro
chiedi.La storia del preprocessore era ovvia dai,sono cose che si imparano
nei primi giorni d'uso di c++.
ciao:))
ps: come mai state discutendo una forma sostitutiva a NULL quando dici che
si deve cmq usare  0 ?
Questo "sembra" piuttosto in contrasto su quello che hai detto fino adesso.

 Non capisco come farebbe a funzionare!?!?
in effetti ci sono due errori, ma sono marginali:
1) la definizione "const NullPointer Null" e` errata; in alternativa 
possiamo usare una di queste:
    const NullPointer Null = NullPointer();
    NullPointer Null;
tra le due non c'e` differenza operativa, in quanto non ci sono metodi 
non-const all'interno della classe NullPointer.
2) ho cercato di definire due volte la variabile "p".
A parte questi piccoli errori l'esempio funziona: quando il compilatore 
vede "char* p = Null" vede che i tipi non corrispondono: p e` un "char*" 
mentre Null e` un "NullPointer"; a questo punto cerca una conversione 
implicita che consenta l'assegnazione e trova l'operatore di conversione 
template e istanzia operator char*() a partire da operator T*().


A parte questi piccoli errori l'esempio funziona.
Mi dici per favore quale compilatore te lo compila.
Grazie. (i miei non lo compilano, compilano senza il template, ma non con il
template).
Tommy

 con il template).
gcc 2.95.3
gcc 3.2
tra l'altro, questa e' carina :)
#include <iostream>
class NullPointer {
public:
     template<class T> operator T*() const { return 0; }
};
int main() {
  const NullPointer Null = NullPointer();
  char* p = Null;
  int* p_i = Null;
  cout << hex << "p vale " << p <<" e p_i " << p_i << endl;
}
output
[henry@homeland varie]$ ./nullptr
p vale (null) e p_i (nil)

 con il template).
con che compilatori hai provato?


 con che compilatori hai provato?
Vc++6
Vc++.NET
Oramai sono gli unici strumenti che uso! (tra parentesi mi piacciono, ma
specialmente il v6 e' vecchiotto e non e' molto aderente all'ultimo
standard!). Credo reinstallero' un port del gcc, ne avevo un paio ma dopo
VC++.NET li ho disinstallati credendo non servissero piu' visto che e' molto
piu' vicino allo standard rispetto al precedente v6. (ho anche linux sul PC,
ma non spegnendo mai il PC non riavvio MAI in modalita' linux ;-)
Tommy

 Vc++.NET
 
se e` cosi` Vc++.NET mi delude un po': avevo sentito che era molto piu` 
aderente allo standard, ma se non compila neppure quel pezzo di codice 
che ho postato direi che devono fare ancora un po' di strada...
g++ rules! ;-)
