On 02.04.2025 07:59, Alexis wrote:"nullptr_t" is the type of "nullptr". And "nullptr" is always a null pointer constant, just like the literal "0". But unlike "0", it can never be mistaken for an integer - thus compilers will be able to detect mistakes more easily. Consider the three basic ways of specifying a null pointer, and how they can be converted to an integer:>A nice overview. - I have questions on some of these types...
Thought people here might be interested in this image on Jens Gustedt's
blog, which translates section 6.2.5, "Types", of the C23 standard
into a graph of inclusions:
>
https://gustedt.wordpress.com/2025/03/29/a-diagram-of-c23-basic-types/
The _Decimal* types - are these just types with other implicit
encodings, say, BCD encoded, or some such?
The nullptr_t seems to be a special beast concerning the "NULL"
entity; what purpose does that type serve, where is it used?
int * p = 0;
int * q = NULL;
int * r = nullptr;
int a = 0; // No complaints from the compiler!
int b = NULL; // Usually an error
int c = (int) NULL; // No complaints
int d = nullptr; // Error
int e = (int) nullptr; // Error
int f = (int) (void*) nullptr; // You really mean it!
This is what makes "nullptr" safer, and thus a useful addition to C. It is also consistent with C++, where "nullptr" is more important (for use in function overloads).
The type "nullptr_t" itself is unlikely to be particularly useful, but has to exist because "nullptr" needs a type. It could conceivably be used in a _Generic, but I have not seen any applications of that.
I see the 'bool' but recently seen mentioned some '_Bool' type.Yes. The tradition in C has been that added keywords have had this _Form, since that type of identifier is reserved. Thus between C99 (when _Bool was added) and C17, the type was named "_Bool", and the header <stdboolh> contained:
The latter was probably chosen in that special syntax to avoid
conflicts during "C" language evolution?
#define bool _Bool
#define true 1
#define false 0
For C23, it was decided that after 20-odd years people should be using the standard C boolean types, and thus the type was renamed "bool" (with "_Bool" kept as a synonym), and "true" and "false" became keywords. <stdbool.h> is now basically empty (and unnecessary) in C23 mode, but of course still exists for compatibility.
How do regular "C" programmers handle that multitude of booleanFor anything that is not hampered by ancient legacy code, you use :
types; ranging from use of 'int', over own "bool" types, then
'_Bool', and now 'bool'? Since it's a very basic type it looks
like you need hard transitions in evolution of your "C" code?
#include <stdbool.h>
bool a = false;
bool b = true;
That applies from C99 up to and including C23 - though if your code is definitely C23-only, you can happily omit the #include.
For pre-C99 code that uses home-made boolean types, it is common in reusable code (such as libraries) for the types and everything else to be prefixed - "MYLIB_boolean", etc. But some code might use the names "bool", "true" and "false" with their own definitions. If those are #define definitions, the code will probably work much as before though it is technically UB, but if they are typedefs, enums, etc., they cannot be compiled as C23.
Les messages affichés proviennent d'usenet.