Top | ![]() |
![]() |
![]() |
![]() |
GLib defines a number of commonly used types, which can be divided into several groups:
New types which are not part of standard C (but are defined in various C standard library header files) — gboolean, gssize.
Integer types which are guaranteed to be the same size across all platforms — gint8, guint8, gint16, guint16, gint32, guint32, gint64, guint64.
Types which are easier to use than their standard C counterparts - gpointer, gconstpointer, guchar, guint, gushort, gulong.
Types which correspond exactly to standard C types, but are included for completeness — gchar, gint, gshort, glong, gfloat, gdouble.
Types which correspond exactly to standard C99 types, but are available to use even if your compiler does not support C99 — gsize, goffset, gintptr, guintptr.
GLib also defines macros for the limits of some of the standard
integer and floating point types, as well as macros for suitable
printf()
formats for these types.
Note that depending on the platform and build configuration, the format
macros might not be compatible with the system provided printf()
function,
because GLib might use a different printf()
implementation internally.
The format macros will always work with GLib API (like g_print()
), and with
any C99 compatible printf()
implementation.
#define G_GINT64_CONSTANT(val) (val##L)
This macro is used to insert 64-bit integer literals into the source code.
It is similar to the standard C INT64_C
macro,
which should be preferred in new code.
#define G_GUINT64_CONSTANT(val) (val##UL)
This macro is used to insert 64-bit unsigned integer literals into the source code.
It is similar to the standard C UINT64_C
macro,
which should be preferred in new code.
Since: 2.10
#define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
This macro is used to insert goffset 64-bit integer literals into the source code.
See also G_GINT64_CONSTANT()
.
Since: 2.20
typedef gint gboolean;
A standard boolean type.
Variables of this type should only contain the value
TRUE
or FALSE
.
Never directly compare the contents of a gboolean variable with the values
TRUE
or FALSE
. Use if (condition)
to check a gboolean is "true", instead
of if (condition == TRUE)
. Likewise use if (!condition)
to check a
gboolean is "false".
There is no validation when assigning to a gboolean variable and so it could
contain any value represented by a gint. This is why the use of if
(condition)
is recommended. All non-zero values in C evaluate to "true".
typedef void* gpointer;
An untyped pointer, exactly equivalent to void *
.
The standard C void *
type should usually be preferred in
new code, but gpointer
can be used in contexts where a type name
must be a single word, such as in the g_type_name()
of G_TYPE_POINTER
or when generating a family of function names for multiple types
using macros.
typedef const void *gconstpointer;
An untyped pointer to constant data, exactly equivalent to const void *
.
The data pointed to should not be changed.
This is typically used in function prototypes to indicate that the data pointed to will not be altered by the function.
The standard C const void *
type should usually be preferred in
new code, but gconstpointer
can be used in contexts where a type name
must be a single word.
typedef char gchar;
Equivalent to the standard C char
type.
This type only exists for symmetry with guchar
.
The standard C char
type should be preferred in new code.
typedef unsigned char guchar;
Equivalent to the standard C unsigned char
type.
The standard C unsigned char
type should usually be preferred in
new code, but guchar
can be used in contexts where a type name
must be a single word, such as in the g_type_name()
of G_TYPE_UCHAR
or when generating a family of function names for multiple types
using macros.
typedef int gint;
Equivalent to the standard C int
type.
Values of this type can range from INT_MIN
to INT_MAX
,
or equivalently from G_MININT
to G_MAXINT
.
This type only exists for symmetry with guint
.
The standard C int
type should be preferred in new code.
#define G_MININT INT_MIN
The minimum value which can be held in a gint.
This is the same as standard C INT_MIN
, which is available since C99
and should be preferred in new code.
#define G_MAXINT INT_MAX
The maximum value which can be held in a gint.
This is the same as standard C INT_MAX
, which is available since C99
and should be preferred in new code.
typedef unsigned int guint;
Equivalent to the standard C unsigned int
type.
Values of this type can range from 0 to UINT_MAX
,
or equivalently 0 to G_MAXUINT
.
The standard C unsigned int
type should usually be preferred in
new code, but guint
can be used in contexts where a type name
must be a single word, such as in the g_type_name()
of G_TYPE_UINT
or when generating a family of function names for multiple types
using macros.
#define G_MAXUINT UINT_MAX
The maximum value which can be held in a guint.
This is the same as standard C UINT_MAX
, which is available since C99
and should be preferred in new code.
typedef short gshort;
Equivalent to the standard C short
type.
Values of this type can range from SHRT_MIN
to SHRT_MAX
,
or equivalently G_MINSHORT
to G_MAXSHORT
.
This type only exists for symmetry with gushort
.
The standard C short
type should be preferred in new code.
#define G_MINSHORT SHRT_MIN
The minimum value which can be held in a gshort.
This is the same as standard C SHRT_MIN
, which is available since C99
and should be preferred in new code.
#define G_MAXSHORT SHRT_MAX
The maximum value which can be held in a gshort.
This is the same as standard C SHRT_MAX
, which is available since C99
and should be preferred in new code.
typedef unsigned short gushort;
Equivalent to the standard C unsigned short
type.
Values of this type can range from 0 to USHRT_MAX
,
or equivalently from 0 to G_MAXUSHORT
.
The standard C unsigned short
type should usually be preferred in
new code, but gushort
can be used in contexts where a type name
must be a single word, such as when generating a family of function
names for multiple types using macros.
#define G_MAXUSHORT USHRT_MAX
The maximum value which can be held in a gushort.
This is the same as standard C USHRT_MAX
, which is available since C99
and should be preferred in new code.
typedef long glong;
Equivalent to the standard C long
type.
Values of this type can range from LONG_MIN
to LONG_MAX
,
or equivalently G_MINLONG
to G_MAXLONG
.
This type only exists for symmetry with gulong
.
The standard C long
type should be preferred in new code.
#define G_MINLONG LONG_MIN
The minimum value which can be held in a glong.
This is the same as standard C LONG_MIN
, which is available since C99
and should be preferred in new code.
#define G_MAXLONG LONG_MAX
The maximum value which can be held in a glong.
This is the same as standard C ULONG_MAX
, which is available since C99
and should be preferred in new code.
typedef unsigned long gulong;
Equivalent to the standard C unsigned long
type.
Values of this type can range from 0 to G_MAXULONG
.
The standard C unsigned long
type should usually be preferred in
new code, but gulong
can be used in contexts where a type name
must be a single word, such as in the g_type_name()
of G_TYPE_ULONG
or when generating a family of function names for multiple types
using macros.
#define G_MAXULONG ULONG_MAX
The maximum value which can be held in a gulong.
This is the same as standard C ULONG_MAX
, which is available since C99
and should be preferred in new code.
typedef signed char gint8;
A signed integer guaranteed to be 8 bits on all platforms,
similar to the standard C int8_t
.
The int8_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires use of gint8
(see gsize for more details).
Values of this type can range from G_MININT8
(= -128) to
G_MAXINT8
(= 127).
#define G_MININT8 ((gint8) (-G_MAXINT8 - 1))
The minimum value which can be held in a gint8.
Since: 2.4
#define G_MAXINT8 ((gint8) 0x7f)
The maximum value which can be held in a gint8.
This is the same as standard C INT8_MAX
, which should be
preferred in new code.
Since: 2.4
typedef unsigned char guint8;
An unsigned integer guaranteed to be 8 bits on all platforms,
similar to the standard C uint8_t
.
The uint8_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires use of guint8
(see gsize for more details).
Values of this type can range from 0 to G_MAXUINT8
(= 255).
#define G_MAXUINT8 ((guint8) 0xff)
The maximum value which can be held in a guint8.
This is the same as standard C UINT8_MAX
, which should be
preferred in new code.
Since: 2.4
typedef signed short gint16;
A signed integer guaranteed to be 16 bits on all platforms,
similar to the standard C int16_t
.
The int16_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires use of gint16
(see gsize for more details).
Values of this type can range from G_MININT16
(= -32,768) to
G_MAXINT16
(= 32,767).
To print or scan values of this type, use
G_GINT16_MODIFIER
and/or G_GINT16_FORMAT
.
#define G_MININT16 ((gint16) (-G_MAXINT16 - 1))
The minimum value which can be held in a gint16.
Since: 2.4
#define G_MAXINT16 ((gint16) 0x7fff)
The maximum value which can be held in a gint16.
This is the same as standard C INT16_MAX
, which should be
preferred in new code.
Since: 2.4
#define G_GINT16_MODIFIER "h"
The platform dependent length modifier for conversion specifiers for scanning and printing values of type gint16 or guint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier and append a conversion specifier.
The following example prints "0x7b";
1 2 |
gint16 value = 123; g_print ("%#" G_GINT16_MODIFIER "x", value); |
This is not necessarily the correct modifier for printing and scanning
int16_t
values, even though the in-memory representation is the same.
Standard C macros like PRId16
and SCNd16
should be used for int16_t
.
Since: 2.4
#define G_GINT16_FORMAT "hi"
This is the platform dependent conversion specifier for scanning and printing values of type gint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier.
1 2 3 4 5 6 7 8 9 |
gint16 in; gint32 out; sscanf ("42", "%" G_GINT16_FORMAT, &in) out = in * 1000; g_print ("%" G_GINT32_FORMAT, out); This is not necessarily the correct format for printing and scanning `int16_t` values, even though the in-memory representation is the same. Standard C macros like `PRId16` and `SCNd16` should be used for `int16_t`. |
typedef unsigned short guint16;
An unsigned integer guaranteed to be 16 bits on all platforms,
similar to the standard C uint16_t
.
The uint16_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires use of guint16
(see gsize for more details).
Values of this type can range from 0 to G_MAXUINT16
(= 65,535).
To print or scan values of this type, use
G_GINT16_MODIFIER
and/or G_GUINT16_FORMAT
.
#define G_MAXUINT16 ((guint16) 0xffff)
The maximum value which can be held in a guint16.
This is the same as standard C UINT16_MAX
, which should be
preferred in new code.
Since: 2.4
#define G_GUINT16_FORMAT "hu"
This is the platform dependent conversion specifier for scanning
and printing values of type guint16. See also G_GINT16_FORMAT
This is not necessarily the correct modifier for printing and scanning
uint16_t
values, even though the in-memory representation is the same.
Standard C macros like PRIu16
and SCNu16
should be used for uint16_t
.
typedef signed int gint32;
A signed integer guaranteed to be 32 bits on all platforms.
The int32_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires use of gint16
(see gsize for more details).
Values of this type can range from G_MININT32
(= -2,147,483,648)
to G_MAXINT32
(= 2,147,483,647).
To print or scan values of this type, use
G_GINT32_MODIFIER
and/or G_GINT32_FORMAT
.
Note that on platforms with more than one 32-bit standard integer type,
gint32
and int32_t
are not necessarily implemented by the same
32-bit integer type.
For example, on an ILP32 platform where int
and long
are both 32-bit,
it might be the case that one of these types is int
and the other
is long
.
See gsize for more details of what this implies.
#define G_MININT32 ((gint32) (-G_MAXINT32 - 1))
The minimum value which can be held in a gint32.
Since: 2.4
#define G_MAXINT32 ((gint32) 0x7fffffff)
The maximum value which can be held in a gint32.
This is the same as standard C INT32_MAX
, which should be
preferred in new code.
Since: 2.4
#define G_GINT32_MODIFIER ""
The platform dependent length modifier for conversion specifiers
for scanning and printing values of type gint32 or guint32. It
is a string literal. See also G_GINT16_MODIFIER
.
This is not necessarily the correct modifier for printing and scanning
int32_t
values, even though the in-memory representation is the same.
Standard C macros like PRId32
and SCNd32
should be used for int32_t
.
Since: 2.4
#define G_GINT32_FORMAT "i"
This is the platform dependent conversion specifier for scanning
and printing values of type gint32. See also G_GINT16_FORMAT
.
This is not necessarily the correct modifier for printing and scanning
int32_t
values, even though the in-memory representation is the same.
Standard C macros like PRId32
and SCNd32
should be used for int32_t
.
typedef unsigned int guint32;
An unsigned integer guaranteed to be 32 bits on all platforms,
similar to the standard C uint32_t
.
The uint32_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires use of guint32
(see gsize for more details).
Values of this type can range from 0 to G_MAXUINT32
(= 4,294,967,295).
To print or scan values of this type, use
G_GINT32_MODIFIER
and/or G_GUINT32_FORMAT
.
Note that on platforms with more than one 32-bit standard integer type,
guint32
and uint32_t
are not necessarily implemented by the same
32-bit integer type.
See gsize for more details of what this implies.
#define G_MAXUINT32 ((guint32) 0xffffffff)
The maximum value which can be held in a guint32.
This is the same as standard C UINT32_MAX
, which should be
preferred in new code.
Since: 2.4
#define G_GUINT32_FORMAT "u"
This is the platform dependent conversion specifier for scanning
and printing values of type guint32. See also G_GINT16_FORMAT
.
This is not necessarily the correct modifier for printing and scanning
uint32_t
values, even though the in-memory representation is the same.
Standard C macros like PRIu32
and SCNu32
should be used for uint32_t
.
typedef signed long gint64;
A signed integer guaranteed to be 64 bits on all platforms,
similar to the standard C int64_t
.
The int64_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires use of gint64
(see gsize for more details).
Values of this type can range from G_MININT64
(= -9,223,372,036,854,775,808) to G_MAXINT64
(= 9,223,372,036,854,775,807).
To print or scan values of this type, use
G_GINT64_MODIFIER
and/or G_GINT64_FORMAT
.
Note that on platforms with more than one 64-bit standard integer type,
gint64
and int64_t
are not necessarily implemented by the same
64-bit integer type.
For example, on a platform where both long
and long long
are 64-bit,
it might be the case that one of those types is used for gint64
and the other is used for int64_t
.
See gsize for more details of what this implies.
#define G_MININT64 ((gint64) (-G_MAXINT64 - G_GINT64_CONSTANT(1)))
The minimum value which can be held in a gint64.
#define G_MAXINT64 G_GINT64_CONSTANT(0x7fffffffffffffff)
The maximum value which can be held in a gint64.
#define G_GINT64_MODIFIER "l"
The platform dependent length modifier for conversion specifiers for scanning and printing values of type gint64 or guint64. It is a string literal.
Some platforms do not support printing 64-bit integers, even
though the types are supported. On such platforms G_GINT64_MODIFIER
is not defined.
This is not necessarily the correct modifier for printing and scanning
int64_t
values, even though the in-memory representation is the same.
Standard C macros like PRId64
and SCNd64
should be used for int64_t
.
Since: 2.4
#define G_GINT64_FORMAT "li"
This is the platform dependent conversion specifier for scanning
and printing values of type gint64. See also G_GINT16_FORMAT
.
Some platforms do not support scanning and printing 64-bit integers,
even though the types are supported. On such platforms G_GINT64_FORMAT
is not defined. Note that scanf()
may not support 64-bit integers, even
if G_GINT64_FORMAT
is defined. Due to its weak error handling, scanf()
is not recommended for parsing anyway; consider using g_ascii_strtoull()
instead.
This is not necessarily the correct format for printing and scanning
int64_t
values, even though the in-memory representation is the same.
Standard C macros like PRId64
and SCNd64
should be used for int64_t
.
typedef unsigned long guint64;
An unsigned integer guaranteed to be 64-bits on all platforms,
similar to the standard C uint64_t
type.
The uint64_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires use of guint64
(see gsize for more details).
Values of this type can range from 0 to G_MAXUINT64
(= 18,446,744,073,709,551,615).
To print or scan values of this type, use
G_GINT64_MODIFIER
and/or G_GUINT64_FORMAT
.
Note that on platforms with more than one 64-bit standard integer type,
guint64
and uint64_t
are not necessarily implemented by the same
64-bit integer type.
See gsize for more details of what this implies.
#define G_MAXUINT64 G_GUINT64_CONSTANT(0xffffffffffffffff)
The maximum value which can be held in a guint64.
This is the same as standard C UINT64_MAX
, which should be
preferred in new code.
#define G_GUINT64_FORMAT "lu"
This is the platform dependent conversion specifier for scanning
and printing values of type guint64. See also G_GINT16_FORMAT
.
Some platforms do not support scanning and printing 64-bit integers,
even though the types are supported. On such platforms G_GUINT64_FORMAT
is not defined. Note that scanf()
may not support 64-bit integers, even
if G_GINT64_FORMAT
is defined. Due to its weak error handling, scanf()
is not recommended for parsing anyway; consider using g_ascii_strtoull()
instead.
This is not necessarily the correct modifier for printing and scanning
uint64_t
values, even though the in-memory representation is the same.
Standard C macros like PRIu64
and SCNu64
should be used for uint64_t
.
typedef float gfloat;
Equivalent to the standard C float
type.
Values of this type can range from -FLT_MAX
to FLT_MAX
,
or equivalently from -G_MAXFLOAT
to G_MAXFLOAT
.
#define G_MINFLOAT FLT_MIN
The minimum positive value which can be held in a gfloat.
If you are interested in the smallest value which can be held
in a gfloat, use -G_MAXFLOAT
.
This is the same as standard C FLT_MIN
, which is available since C99
and should be preferred in new code.
#define G_MAXFLOAT FLT_MAX
The maximum value which can be held in a gfloat.
This is the same as standard C FLT_MAX
, which is available since C99
and should be preferred in new code.
typedef double gdouble;
Equivalent to the standard C double
type.
Values of this type can range from -DBL_MAX
to DBL_MAX
,
or equivalently from -G_MAXDOUBLE
to G_MAXDOUBLE
.
#define G_MINDOUBLE DBL_MIN
The minimum positive value which can be held in a gdouble.
If you are interested in the smallest value which can be held
in a gdouble, use -G_MAXDOUBLE
.
This is the same as standard C DBL_MIN
, which is available since C99
and should be preferred in new code.
#define G_MAXDOUBLE DBL_MAX
The maximum value which can be held in a gdouble.
This is the same as standard C DBL_MAX
, which is available since C99
and should be preferred in new code.
typedef unsigned long gsize;
An unsigned integer type of the result of the sizeof
operator,
corresponding to the size_t
type defined in C99.
The standard size_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires gsize
(see below for more details).
gsize
is usually 32 bit wide on a 32-bit platform and 64 bit wide
on a 64-bit platform. Values of this type can range from 0 to
G_MAXSIZE
.
This type is wide enough to hold the size of the largest possible
memory allocation, but is not guaranteed to be wide enough to hold
the numeric value of a pointer: on platforms that use tagged pointers,
such as CHERI, pointers can be numerically
larger than the size of the address space.
If the numeric value of a pointer needs to be stored in an integer
without information loss, use the standard C types intptr_t
or
uintptr_t
, or the similar GLib types gintptr or guintptr.
To print or scan values of this type, use
G_GSIZE_MODIFIER
and/or G_GSIZE_FORMAT
.
Note that on platforms where more than one standard integer type is
the same size, size_t
and gsize
are always the same size but are
not necessarily implemented by the same standard integer type.
For example, on an ILP32 platform where int
, long
and pointers
are all 32-bit, size_t
might be unsigned long
while gsize
might be unsigned int
.
This can result in compiler warnings or unexpected C++ name-mangling
if the two types are used inconsistently.
As a result, changing a type from gsize
to size_t
in existing APIs
might be an incompatible API or ABI change, especially if C++
is involved. The safe option is to leave existing APIs using the same type
that they have historically used, and only use the standard C types in
new APIs.
Similar considerations apply to all the fixed-size types (gint8, guint8, gint16, guint16, gint32, guint32, gint64, guint64 and goffset), as well as gintptr and guintptr. Types that are 32 bits or larger are particularly likely to be affected by this.
#define G_MAXSIZE G_MAXULONG
The maximum value which can be held in a gsize.
This is the same as standard C SIZE_MAX
(available since C99),
which should be preferred in new code.
Since: 2.4
#define G_GSIZE_MODIFIER "l"
The platform dependent length modifier for conversion specifiers for scanning and printing values of type gsize. It is a string literal.
Note that this is not necessarily the correct modifier to scan or
print a size_t
, even though the in-memory representation is the
same. The Standard C "z"
modifier should be used for size_t
,
assuming a C99-compliant printf
implementation is available.
Since: 2.6
#define G_GSIZE_FORMAT "lu"
This is the platform dependent conversion specifier for scanning
and printing values of type gsize. See also G_GINT16_FORMAT
.
Note that this is not necessarily the correct format to scan or
print a size_t
, even though the in-memory representation is the
same. The standard C "zu"
format should be used for size_t
,
assuming a C99-compliant printf
implementation is available.
Since: 2.6
typedef signed long gssize;
A signed variant of gsize, corresponding to the
ssize_t
defined in POSIX or the similar SSIZE_T
in Windows.
In new platform-specific code, consider using ssize_t
or SSIZE_T
directly.
Values of this type can range from G_MINSSIZE
to G_MAXSSIZE
.
Note that on platforms where ssize_t
is implemented, ssize_t
and
gssize
might be implemented by different standard integer types
of the same size. Similarly, on Windows, SSIZE_T
and gssize
might be implemented by different standard integer types of the same
size. See gsize for more details.
This type is also not guaranteed to be the same as standard C
ptrdiff_t
, although they are the same on many platforms.
To print or scan values of this type, use
G_GSSIZE_MODIFIER
and/or G_GSSIZE_FORMAT
.
#define G_MINSSIZE G_MINLONG
The minimum value which can be held in a gssize.
Since: 2.14
#define G_MAXSSIZE G_MAXLONG
The maximum value which can be held in a gssize.
Since: 2.14
#define G_GSSIZE_MODIFIER "l"
The platform dependent length modifier for conversion specifiers for scanning and printing values of type gssize. It is a string literal.
Note that this is not necessarily the correct modifier to scan or print
a POSIX ssize_t
or a Windows SSIZE_T
, even though the in-memory
representation is the same.
On POSIX platforms, the "z"
modifier should be used for ssize_t
.
Since: 2.6
#define G_GSSIZE_FORMAT "li"
This is the platform dependent conversion specifier for scanning
and printing values of type gssize. See also G_GINT16_FORMAT
.
Note that this is not necessarily the correct format to scan or print
a POSIX ssize_t
or a Windows SSIZE_T
, even though the in-memory
representation is the same.
On POSIX platforms, the "zd"
format should be used for ssize_t
.
Since: 2.6
typedef gint64 goffset;
A signed integer type that is used for file offsets,
corresponding to the POSIX type off_t
as if compiling with
_FILE_OFFSET_BITS
set to 64. goffset is always 64 bits wide, even on
32-bit architectures, and even if off_t
is only 32 bits.
Values of this type can range from G_MINOFFSET
to
G_MAXOFFSET
.
To print or scan values of this type, use
G_GOFFSET_MODIFIER
and/or G_GOFFSET_FORMAT
.
On platforms with more than one 64-bit standard integer type,
even if off_t
is also 64 bits in size, goffset
and off_t
are not
necessarily implemented by the same 64-bit integer type.
See gsize for more details of what this implies.
Since: 2.14
#define G_GOFFSET_MODIFIER G_GINT64_MODIFIER
The platform dependent length modifier for conversion specifiers
for scanning and printing values of type goffset. It is a string
literal. See also G_GINT64_MODIFIER
.
This modifier should only be used with goffset values, and not
with off_t
, which is not necessarily the same type or even the same size.
Since: 2.20
#define G_GOFFSET_FORMAT G_GINT64_FORMAT
This is the platform dependent conversion specifier for scanning
and printing values of type goffset. See also G_GINT64_FORMAT
.
This format should only be used with goffset values, and not
with off_t
, which is not necessarily the same type or even the same size.
Since: 2.20
typedef signed long gintptr;
Corresponds to the C99 type intptr_t, a signed integer type that can hold any pointer.
The standard intptr_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires gintptr
.
Note that intptr_t
and gintptr
might be implemented by different
standard integer types of the same size. See gsize for more details.
gintptr is not guaranteed to be the same type or the same size as gssize, even though they are the same on many CPU architectures.
To print or scan values of this type, use
G_GINTPTR_MODIFIER
and/or G_GINTPTR_FORMAT
.
Since: 2.18
#define G_GINTPTR_MODIFIER "l"
The platform dependent length modifier for conversion specifiers for scanning and printing values of type gintptr or guintptr. It is a string literal.
Note that this is not necessarily the correct modifier to scan or
print an intptr_t
, even though the in-memory representation is the
same.
Standard C macros like PRIdPTR
and SCNdPTR
should be used for
intptr_t
.
Since: 2.22
#define G_GINTPTR_FORMAT "li"
This is the platform dependent conversion specifier for scanning and printing values of type gintptr.
Note that this is not necessarily the correct format to scan or
print an intptr_t
, even though the in-memory representation is the
same.
Standard C macros like PRIdPTR
and SCNdPTR
should be used for
intptr_t
.
Since: 2.22
typedef unsigned long guintptr;
Corresponds to the C99 type uintptr_t, an unsigned integer type that can hold any pointer.
The standard uintptr_t
type should be preferred in new code, unless
consistency with pre-existing APIs requires guintptr
.
Note that uintptr_t
and guintptr
might be implemented by different
standard integer types of the same size. See gsize for more details.
guintptr is not guaranteed to be the same type or the same size as gsize, even though they are the same on many CPU architectures.
To print or scan values of this type, use
G_GINTPTR_MODIFIER
and/or G_GUINTPTR_FORMAT
.
Since: 2.18
#define G_GUINTPTR_FORMAT "lu"
This is the platform dependent conversion specifier for scanning and printing values of type guintptr.
Note that this is not necessarily the correct format to scan or
print a uintptr_t
, even though the in-memory representation is the
same.
Standard C macros like PRIuPTR
and SCNuPTR
should be used for
uintptr_t
.
Since: 2.22