🚀 go-pugleaf

John Bokma wrote:
> Dr.Ruud wrote:
>>Toen ik John Bokma kietelde, kwam er dit uit:
>>
>>>dus is het *soms* gevaarlijk om zomaar:
>>>
>>>  if ( !ptr ) ... te gebruiken.
>>
>>Die redenering begrijp ik niet. In C is !ptr heel eenduidig
>>(als er geen geniepige redefine van 'ptr' meespeelt).
> 
> Het schoot mij te binnen, tenminste als ik het mij goed herinner, dat C 
> geen NULL kent, maar dat het gewoon
> 
> #define NULL (0)
> 
> is?

In C komt ook wel ((void *)0) voor, maar in C++ moet het een
"integrale compile-time constante gelijk aan 0" zijn.
(En dat mag dus 0, 0L, 0UL, (2-2), (6-3-3), ... zijn)

En dat is wel degelijk een speciale pointerwaarde, zie Dr. Ruud's
reaktie.

> (Ik herinnerde mij iets van: NULL en 0 zijn twee dingen in C, een 
> pointer kan NULL zijn, maar ook naar geheugenlocatie 0 wijzen. Als dat 
> echt twee dingen zouden zijn, dan is 0 en NULL beide false)

Het probleem is dat je een geldige waarde moet opofferen om NULL
te representeren, soort van in-band-signaling.

Ik ken C op dit gebied minder goed dan C++, maar in C++ wordt een zero
omgezet in een pointer die als NULL pointer dient (C vereist dacht ik
wel gewoon een zero, maar dat weet ik niet zeker). De C++ standaard
doet zijn best om niet te zeggen dat dat adres 0 is en de optie open
te laten daar b.v. 0xFFFFFFFF van te maken. Maar elke compiler die ik
ken, representeert een NULL pointer door een pointer naar adres 0,
en ik ken een heleboel code die fout zou gaan als dat niet het geval
zou zijn (code die memset(), memzero() en zo gebruikt om een pointer
te initialiseren). Maar een compiler mag dat dus anders doen!

>>Ik nam aan dat je met ptr een variabele van een
>>integer type beDoelt, specifiek beDoeld en geschikt
>>voor het bevatten van een geheugenadres. In C.
>>Maar misschien bedoelde je het wel heel anders.
> 
> Zie boven. Ik bedoel dat ptr twee false waarden kan hebben. Indien niet, 
> dan gaat dat deel van mijn verhaal niet op.

Er is maar 1 false waarde (nl NULL), maar i.h.a. wordt de pointer
naar adres 0 opgeofferd om die NULL waarde te representeren.

Overigens is het best mogelijk om zo'n pointer te gebruiken in C.
Je zult dan het geheugen op adres 0 proberen te benaderen, en als
dat precies is wat je wilt (in een embedded device of zo), dan zal
C je dat niet verbieden. Je hebt wel een probleem wat je dan als
"ongeldige pointer" gebruikt, maar daar valt waarschijnlijk wel
weer iets op te vinden. Maar op een PC is adres 0 i.h.a. niet
leesbaar/schrijfbaar en krijg je een crash of zo.

> In Perl ken ik het probleem wat ik al schetste:
> 
> $filename ||= "default.txt";
> 
> Wat $filename gelijk maakt aan default.txt o.a. als $filename niet 
> gedefinieerd is, maar ook als deze de waarde 0 bevat. Lastig als je met 
> een lusje "deze" sub aanroept en je bestanden 0, 1, 2, etc. noemt.

Tja, dat krijg je met dynamische typering. In C is er verschil tussen
"0" en 0L, in Perl blijkbaar niet.

In C is er dus wel verschil tussen
   filename = NULL;
en
   filename = "0";
Bij die laatste geldt gewoon dat (filename != NULL). Je probleem
is dus Perl-specifiek en komt niet in C voor.

> Ander voorbeeld:
> 
> $speed ||= 5;    	# use default
> 
> Probeer $speed nu maar eens op 0 te zetten.

Misschien is dat ook wel niet handig (maar dan zou ik if (speed < 1)
o.i.d. verwachten).

Sjoerd