Path: ...!weretis.net!feeder8.news.weretis.net!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: Keith Thompson <Keith.S.Thompson+u@gmail.com>
Newsgroups: comp.lang.c
Subject: Re: question about nullptr
Date: Mon, 12 Aug 2024 18:33:04 -0700
Organization: None to speak of
Lines: 87
Message-ID: <87mslhgqb3.fsf@nosuchdomain.example.com>
References: <v6bavg$3pu5i$1@dont-email.me> <20240706054641.175@kylheku.com>
	<v6bfi1$3qn4u$1@dont-email.me> <l9ciO.7$cr5e.2@fx05.iad>
	<877cdyuq0f.fsf@bsb.me.uk> <2ckiO.19403$7Ej.4487@fx46.iad>
	<87plrpt4du.fsf@bsb.me.uk> <9bCiO.7108$sXW9.3805@fx41.iad>
	<877cdwu9s1.fsf@nosuchdomain.example.com>
	<20240708222804.00001654@yahoo.com> <86le2b9ru6.fsf@linuxsc.com>
	<8734ojxlg7.fsf@nosuchdomain.example.com> <86msmp8fld.fsf@linuxsc.com>
	<87cynluekl.fsf@nosuchdomain.example.com>
	<v6n36o$239h6$2@dont-email.me> <861q2t1ce8.fsf@linuxsc.com>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Date: Tue, 13 Aug 2024 03:33:05 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="75b586a96d8f13b1a18286173fed3ce1";
	logging-data="3733360"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+OnuQDNDSKc1pVLYFkJsBr"
User-Agent: Gnus/5.13 (Gnus v5.13)
Cancel-Lock: sha1:dPVrswZrLM4qnXPAZaKC5RmEst4=
	sha1:g5acPRgC3TND0ybHqLiaO9QdE4U=
Bytes: 5081

Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
> James Kuyper <jameskuyper@alumni.caltech.edu> writes:
>> On 7/10/24 17:23, Keith Thompson wrote:
>>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>>>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>>>> [...]
>>>>>> This posting has inspired me to try using (long)0.0
>>>>>> whenever a null pointer constant is needed.  As for
>>>>>> example
>>>>>>
>>>>>> (void*){ (long)0.0 }
>>>>>>
>>>>>> as an argument to a variadic function where a pointer
>>>>>> is expected.
>>>>>
>>>>> But surely ((void*)('/'/'/'-'/'/'/')) is more elegant.
>>>>
>>>> Surely not.  Furthermore the form I showed has a point,
>>>> whereas this example is roughly the equivalent of a
>>>> first grade knock-knock joke.
>>>
>>> I was of course joking.  I assumed you were as well.
>>>
>>> What is the point of (void*){ (long)0.0 }?  I don't believe it's
>>> a null pointer constant even in C23.
>>
>> I think you're right about that.
>
> The compound literal is not a null pointer constant.  I didn't
> say it is.  The null pointer constant is (long)0.0, like my
> earlier posting pointed out.
>
>> "An integer constant expression132) ... shall only have operands
>> that are ... compound literal constants of arithmetic type that
>> are the immediate operands of casts. ... Cast operators in an
>> integer constant expression shall only convert arithmetic types to
>> integer types, ...", so (long)0.0 is permitted."
>>
>> While (void*) looks like a cast, in this context it is a compound
>> literal of pointer type, which is not allowed.  [..]
>
> Don't be silly.  The compound literal works just fine in the
> context I mentioned for it:
>
>     #include <stdio.h>
>
>     int
>     main(){
>         printf( " null pointer : %p\n", (void*){ (long)0.0 } );
>         return  0;
>     }
>
> Compile it for yourself if you don't believe me.

You're right, a null pointer constant is not required in that context.
`(long)0.0` is null pointer constant.  `(void*){ (long)0.0 }` is not a
null pointer constant, but it is an expression whose value is a null
pointer of type void*.  (It is, for example, not valid as an initializer
for a pointer object with static storage duration.)

The question you're refusing to answer is: *what is the point*?  Why
would you want to use `(void*){ (long)0.0 }` in a context where a null
pointer is required, rather than the much clearer `(void*)NULL`, or
`(void*)0`, or any of several other possible expressions?

Yes, it's valid and is guaranteed to work properly, but why?

Again, my reference to `((void*)('/'/'/'-'/'/'/'))` was nothing more or
less than a joke.  It is a valid null pointer constant, written for the
sole purpose of deliberate obfuscation.  I found it amusing.  If you
don't, that's fine.  It is not something I would write in real code
unless my goal were either obfuscation, testing a compiler's handling of
odd code, or just demonstrating the range of weird expressions that can
be null pointer constants.

I initially assumed that you had written `(void*){ (long)0.0 }` with a
similar intent.  I'm still not sure you didn't.

I cannot force you to explain, and if you choose not to do so I will
simply cease caring about this.  But I continue to be annoyed by your
habit of telling us that something obscure has some significance and
refusing to explain, even when asked, what that sigificance is.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */