Re: question about nullptr

On 09/07/2024 14:50, Michael S wrote:

On Tue, 09 Jul 2024 04:32:50 -0700
Tim Rentsch <tr.17687@z991.linuxsc.com> wrote:
 

Michael S <already5chosen@yahoo.com> writes:
>

On Mon, 8 Jul 2024 15:23:47 -0700
"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> wrote:
 

On 7/8/2024 12:28 PM, Michael S wrote:
 

On Sun, 07 Jul 2024 15:17:34 -0700
Keith Thompson <Keith.S.Thompson+u@gmail.com> wrote:
 

I just about always use NULL, not 0, when I want a null pointer
constant.  Similarly, I use '\0', not 0, when I want a null
character, 0.0 when I want a floating-point zero, and false when
I want a Boolean zero.  I just like being explicit.

>
Pointer:  I very rarely use NULL.
Character:  I never use '\0'.

>
Not even something like:
>
#define CLINE 128
>
char x[CLINE] = { '\0' };
>
?
>
;^)

>
I see nothing special about your case. {0} is the most appropriate.
 

>
Any use of '\0' almost always strikes me as an affectation.  It's
like people want to somehow pretend that it's not the same as
just 0.
>

And, BTW, I never use #define for integer constants.

>
What do you do if you need to define a compile-time constant
whose value is outside the range of signed int?  With the
understanding that the context is C as it is now, and not
C++ or some imagined other language.

 In comment above "integer constant" meant "within the range of signed
int". But let's accept more general meaning. Then, when it happens, I
have a problem and forced to flex my principles :(
Luckily, it's pretty rare. I mean, it's pretty rare that the constant
is both outside the range of signed int and I really really have to
have it as compile-time constant. More often big numbers like these are
used in arithmetic/logic, so 'const wide_type' or 'static const
wide_type' is practically as good as a "real" compile-time constant
despite being "less constant" in theory.
 

static const of the appropriate type should be as good as a define'd value in almost any circumstance (assuming, of course, an optimising compiler).
There are circumstances where you can use an enumeration constant as a named integer constant, but where a static const int value cannot be used, such as the size of statically allocated arrays.  But you are very unlikely to need such a large value to be an integer constant, rather than just a value that the compiler sees as a compile-time constant for optimisation purposes.
(And C23 helpfully allows enum values that are of larger integer types. And also "constexpr" declarations.)