# <stdlib.h>

<head><title>&lt;stdlib.h&gt;</title></head>

# `<stdlib.h>`

* * *

**`EXIT_FAILURE· EXIT_SUCCESS· MB_CUR_MAX· NULL· RAND_MAX`**

**`abort· abs· atexit· atof· atoi· atol· atoll· bsearch· calloc· div· div_t· _Exit· exit· free· getenv· labs· llabs· ldiv· ldiv_t· ldiv· ldiv_t· malloc· mblen· mbstowcs· mbtowc· qsort· rand· realloc· size_t· srand· strtod· strtof· strtol· strtold· strtoll· strtoul· strtoull· system· wchar_t· wcstombs· wctomb`**

* * *

Include the standard header **`<stdlib.h>`** to declare an
assortment of useful functions and to define the macros and types
that help you use them.

        /* MACROS */
    #define EXIT_FAILURE <rvalue integer expression>
    #define EXIT_SUCCESS <rvalue integer expression>
    #define MB_CUR_MAX <rvalue integer expression >= 1>
    #define NULL <either 0, 0L, or (void *)0> [0 in C++]
    #define RAND_MAX <integer constant expression >= 32,767>
    
        /* TYPES */
    typedef struct {
        int quot, rem;
        } div_t;
    typedef struct {
        long quot, rem;
        } ldiv_t;
    typedef struct { [added with C99]
        long long quot, rem;
        } lldiv_t;
    
    typedef ui-type size_t;
    typedef i-type wchar_t; [keyword in C++]
    
        /* FUNCTIONS */
    int abs(int i);
    long abs(long i); [C++ only]
    long long abs(long long i); [C++ only, added with C99]
    long long llabs(long long i); [added with C99]
    long labs(long i);
    
    div_t div(int numer, int denom);
    ldiv_t div(long numer, long denom); [C++ only]
    lldiv_t div(long long numer, long long denom); [C++ only, added with C99]
    lldiv_t lldiv(long long numer, long long denom); [added with C99]
    ldiv_t ldiv(long numer, long denom);
    
    int rand(void);
    void srand(unsigned int seed);
    
    double atof(const char *s);
    int atoi(const char *s);
    long atol(const char *s);
    long long atoll(const char *s); [added with C99]
    
    double strtod(const char *restrict s, char **restrict endptr);
    float strtof(const char *restrict s, char **restrict endptr); [added with C99]
    long double strtold(const char *restrict s,
        char **restrict endptr); [added with C99]
    
    long long strtoll(const char *restrict s, char **restrict endptr,
        int base); [added with C99]
    unsigned long long strtoull(const char *restrict s, char **restrict endptr,
        int base); [added with C99]
    
    long strtol(const char *restrict s, char **restrict endptr, int base);
    unsigned long strtoul(const char *restrict s, char **restrict endptr,
        int base);
    
    void *calloc(size_t nelem, size_t size);
    void free(void *ptr);
    void *malloc(size_t size);
    void *realloc(void *ptr, size_t size);
    
    int mblen(const char *s, size_t n);
    size_t mbstowcs(wchar_t *restrict wcs, const char *restrict s, size_t n);
    int mbtowc(wchar_t *restrict pwc, const char *restrict s, size_t n);
    size_t wcstombs(char *restrict s, const wchar_t *restrict wcs, size_t n);
    int wctomb(char *s, wchar_t wchar);
    
    void _Exit(int status); [added with C99]
    void exit(int status);
    void abort(void);
    char *getenv(const char *name);
    int system(const char *s);
    
    extern "C++"
        int atexit(void (*func)(void)); [C++ only]
    extern "C" [C++ only]
        int atexit(void (*func)(void));
    
    extern "C++"
        void *bsearch(const void *key, const void *base,
            size_t nelem, size_t size,
                int (*cmp)(const void *ck,
                    const void *ce)); [C++ only]
    extern "C" [C++ only]
        void *bsearch(const void *key, const void *base,
            size_t nelem, size_t size,
                int (*cmp)(const void *ck,
                    const void *ce));
    
    extern "C++"
        void qsort(void *base, size_t nelem, size_t size,
            int (*cmp)(const void *e1, const void *e2));
                [C++ only]
    extern "C" [C++ only]
        void qsort(void *base, size_t nelem, size_t size,
            int (*cmp)(const void *e1, const void *e2));Copy to clipboard

## `abort`

    void abort(void);Copy to clipboard

The function calls
`raise(SIGABRT)`,
which reports the abort signal,
[`SIGABRT`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_signal.html#SIGABRT).
Default handling for the abort signal is to cause abnormal
program termination and report unsuccessful termination to the target
environment. Whether or not the target environment flushes output
streams, closes open files, or removes temporary files on abnormal
termination is implementation defined. If you specify handling that causes
[`raise`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_signal.html#raise)
to return control to `abort`, the function calls
`exit(EXIT_FAILURE)`,
to report unsuccessful termination with
[`EXIT_FAILURE`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#EXIT_FAILURE).
`abort` never returns control to its caller.

## `abs`

    int abs(int i);
    long abs(long i); [C++ only]
    long long abs(long long i); [C++ only, added with C99]Copy to clipboard

The function returns the absolute value of
`i`, `|i|`. The version that accepts
a *long* argument behaves the same as
[`labs`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#abs)

## `atexit`

    extern "C++"
        int atexit(void (*func)(void)); [C++ only]
    extern "C" [C++ only]
        int atexit(void (*func)(void));Copy to clipboard

The function registers the function whose address is `func`
to be called by
[`exit`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#exit) (or when
[`main`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_lib_over.html#main) returns)
and returns zero if successful.
The functions are called in reverse order of registry. You can register at
least 32 functions.

Furthermore, in C++, if control leaves a called function because
it fails to handle a thrown exception, `terminate`
is called.

## `atof`

    double atof(const char *s);Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *double* and then returns
`x.` The conversion is the same as for
`strtod(s, 0)`,
except that a value is not necessarily stored in
[`errno`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#errno)
if a conversion error occurs.

## `atoi`

    int atoi(const char *s);Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *int* and then returns
`x.` The conversion is the same as for
`(int)strtol(s, 0, 10)`,
except that a value is not necessarily stored in
[`errno`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#errno)
if a conversion error occurs.

## `atol`

    long atol(const char *s);Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *long* and then returns
`x.` The conversion is the same as for
`strtol(s, 0, 10)`,
except that a value is not necessarily stored in
[`errno`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#errno)
if a conversion error occurs.

## `atoll`

    long long atoll(const char *s); [added with C99]Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *long long* and then returns
`x.` The conversion is the same as for
`strtoll(s, 0, 10)`,
except that a value is not necessarily stored in
[`errno`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#errno)
if a conversion error occurs.

## `bsearch`

    extern "C++"
        void *bsearch(const void *key, const void *base,
            size_t nelem, size_t size,
                int (*cmp)(const void *ck,
                    const void *ce)); [C++ only]
    extern "C" [C++ only]
        void *bsearch(const void *key, const void *base,
            size_t nelem, size_t size,
                int (*cmp)(const void *ck,
                    const void *ce));Copy to clipboard

The function searches an array of ordered values and returns
the address of an array element that equals the search key `key`
(if one exists); otherwise, it returns a null pointer. The array consists
of `nelem` elements, each of `size` bytes,
beginning with the element whose address is `base`.

`bsearch` calls the comparison function whose address is
`cmp` to compare the search key with elements of the array. The
comparison function must return:

- a negative value if the search key `ck` is less than the
array element `ce`
- zero if the two are equal
- a positive value if the search key is greater than the array
element

`bsearch` assumes that the array elements are in nondescending
order according to the same comparison rules that are used by the
comparison function.

## `calloc`

    void *calloc(size_t nelem, size_t size);Copy to clipboard

The function allocates an array object containing `nelem`
elements each of size `size`, stores zeros in all bytes of the
array, and returns the address of the first element of the array if
successful; otherwise, it returns a null pointer. You can safely convert
the return value to an object pointer of any type whose size in bytes
is not greater than `size`.

## `div`

    div_t div(int numer, int denom);
    ldiv_t div(long numer, long denom); [C++ only]
    lldiv_t div(long long numer, long long denom); [C++ only, added with C99]Copy to clipboard

The function divides `numer` by `denom` and returns
both quotient and remainder in the structure
result `x`, if the quotient can be represented.
The structure member `x.quot`
is the algebraic quotient truncated toward zero.
The structure member `x.rem` is the remainder, such
that `numer == x.quot*denom + x.rem`.

## `div_t`

    typedef struct {
        int quot, rem;
        } div_t;Copy to clipboard

The type is the structure type returned by the function
[`div`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#div).
The structure contains members that represent the quotient
(`quot`) and remainder (`rem`)
of a signed integer division with operands of type *int.* The
members shown above can occur in either order.

## `exit`

    void exit(int status);Copy to clipboard

The function calls all functions registered by
[`atexit`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#atexit),
closes all files, and returns control to the target environment. If
`status` is zero or
[`EXIT_SUCCESS`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#EXIT_SUCCESS),
the program reports successful termination. If `status` is
[`EXIT_FAILURE`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#EXIT_FAILURE), the
program reports unsuccessful termination. An implementation can define
additional values for `status`.

## `_Exit`

    void _Exit(int status); [added with C99]Copy to clipboard

The function returns control to the target environment. The value of
`status` has the same effect as for a call to
[`exit`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#exit). The function does *not*
call functions registered by
[`atexit`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#atexit). It may or may not
close files.

## `EXIT_FAILURE`

    #define EXIT_FAILURE <rvalue integer expression>Copy to clipboard

The macro yields the value of the `status` argument to
[`exit`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#exit)
that reports unsuccessful termination.

## `EXIT_SUCCESS`

    #define EXIT_SUCCESS <rvalue integer expression>Copy to clipboard

The macro yields the value of the `status` argument to
[`exit`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#exit)
that reports successful termination.

## `free`

    void free(void *ptr);Copy to clipboard

If `ptr` is not a null pointer, the function deallocates
the object whose address is `ptr`; otherwise, it does nothing.
You can deallocate only objects that you first allocate by calling
[`calloc`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#calloc),
[`malloc`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#malloc), or
[`realloc`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#realloc).

## `getenv`

    char *getenv(const char *name);Copy to clipboard

The function searches an
**environment list**,
which each implementation defines, for an entry
whose name matches the string `name`. If
the function finds a match, it returns a pointer to a static-duration
object that holds the definition associated with the target environment
name. Otherwise, it returns a null pointer. Do not alter the value
stored in the object. If you call `getenv` again, the value stored
in the object can change. No target environment names are required
of all environments.

## `labs`

    long labs(long i);Copy to clipboard

The function returns the absolute value of `i`,
`|i|`, the same as
[`abs`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#abs).

## `llabs`

    long long llabs(long long i); [added with C99]Copy to clipboard

The function returns the absolute value of `i`,
`|i|`, the same as
[`abs`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#abs).

## `ldiv`

    ldiv_t ldiv(long numer, long denom);Copy to clipboard

The function divides `numer` by `denom` and returns
both quotient and remainder in the structure
result `x`, if the quotient can be represented.
The structure member `x.quot`
is the algebraic quotient truncated toward zero.
The structure member `x.rem` is the remainder, such
that `numer == x.quot*denom + x.rem`.

## `lldiv`

    lldiv_t lldiv(long long numer, long long denom); [added with C99]Copy to clipboard

The function divides `numer` by `denom` and returns
both quotient and remainder in the structure
result `x`, if the quotient can be represented.
The structure member `x.quot`
is the algebraic quotient truncated toward zero.
The structure member `x.rem` is the remainder, such
that `numer == x.quot*denom + x.rem`.

## `ldiv_t`

    typedef struct {
        long quot, rem;
        } ldiv_t;Copy to clipboard

The type is the structure type returned by the function
[`ldiv`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#ldiv).
The structure contains members that represent the quotient
(`quot`) and remainder (`rem`)
of a signed integer division with operands of type *long.* The
members shown above can occur in either order.

## `lldiv_t`

    typedef struct { [added with C99]
        long long quot, rem;
        } lldiv_t;Copy to clipboard

The type is the structure type returned by the function
[`lldiv`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#lldiv).
The structure contains members that represent the quotient
(`quot`) and remainder (`rem`)
of a signed integer division with operands of type *long long.* The
members shown above can occur in either order.

## `malloc`

    void *malloc(size_t size);Copy to clipboard

The function allocates an object of size `size`, and returns
the address of the object if successful; otherwise, it returns a null
pointer. The values stored in the object are indeterminate. You can
safely convert the return value to an object pointer of any type whose
size is not greater than `size`.

## `MB_CUR_MAX`

    #define MB_CUR_MAX <rvalue integer expression >= 1>Copy to clipboard

The macro yields the maximum number of characters that constitute a
[multibyte character](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#Multibyte%20Characters)
in the current
[locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html). Its value is &lt;=
[`MB_LEN_MAX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_limits.html#MB_LEN_MAX).

## `mblen`

    int mblen(const char *s, size_t n);Copy to clipboard

If `s` is not a null pointer, the function returns the
number of bytes in the multibyte string `s` that constitute the
next multibyte character, or it returns -1 if the next `n`
(or the remaining) bytes do not constitute a valid multibyte character.
`mblen` does not include the terminating null in the count of
bytes. The function can use a
[conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#conversion%20state)
stored in an internal
static-duration object to determine how
to interpret the multibyte string.

If `s` is a null pointer and if multibyte characters have a
[state-dependent encoding](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#state-dependent%20encoding)
in the current
[locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#locale), the function stores the
[initial conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#initial%20conversion%20state)
in its internal static-duration object and
returns nonzero; otherwise, it returns zero.

## `mbstowcs`

    size_t mbstowcs(wchar_t *restrict wcs, const char *restrict s, size_t n);Copy to clipboard

The function stores a wide character string, in successive elements
of the array whose first element has the address `wcs`,
by converting, in turn, each of the multibyte characters
in the multibyte string `s`.
The string begins in the
[initial conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#initial%20conversion%20state).
The function converts each character as if by calling
[`mbtowc`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#mbtowc) (except that
the internal conversion state stored for that function is unaffected).
It stores at most `n` wide characters, stopping after it stores
a null wide character. It returns the number of wide characters it
stores, not counting the null wide character, if all conversions are
successful; otherwise, it returns -1.

## `mbtowc`

    int mbtowc(wchar_t *restrict pwc, const char *restrict s, size_t n);Copy to clipboard

If `s` is not a null pointer,
the function determines `x`,
the number of bytes in the multibyte string `s` that constitute
the next multibyte character.
(`x` cannot be greater than
[`MB_CUR_MAX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#MB_CUR_MAX).)
If `pwc` is not a null pointer, the function converts the next
multibyte character to its corresponding wide-character value and
stores that value in `*pwc`.
It then returns `x,` or it
returns -1 if the next `n` or the remaining bytes do not
constitute a valid multibyte character. `mbtowc` does not include
the terminating null in the count of bytes. The function can use a
[conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#conversion%20state)
stored in an internal static-duration object to determine
how to interpret the multibyte string.

If `s` is a null pointer and if multibyte characters have a
[state-dependent encoding](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#state-dependent%20encoding)
in the current
[locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#locale), the function stores the
[initial conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#initial%20conversion%20state)
in its internal static-duration object and
returns nonzero; otherwise, it returns zero.

## `NULL`

    #define NULL <either 0, 0L, or (void *)0> [0 in C++]Copy to clipboard

The macro yields a null pointer constant that is usable as an
[address constant expression](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_express.html#address%20constant%20expression).

## `qsort`

    extern "C++"
        void qsort(void *base, size_t nelem, size_t size,
            int (*cmp)(const void *e1, const void *e2));
                [C++ only]
    extern "C" [C++ only]
        void qsort(void *base, size_t nelem, size_t size,
            int (*cmp)(const void *e1, const void *e2));Copy to clipboard

The function sorts, in place, an array consisting of `nelem`
elements, each of `size` bytes, beginning with the element whose
address is `base`. It calls the comparison function whose address
is `cmp` to compare pairs of elements. The comparison function
must return a negative value if `e1` is less than `e2`,
zero if the two are equal, or a positive value if `e1` is greater
than `e2`. Two array elements that are equal can appear in the
sorted array in either order.

## `rand`

    int rand(void);Copy to clipboard

The function computes a pseudo-random number `x` based
on a seed value stored in an internal static-duration object, alters
the stored seed value, and returns `x`.
`x` is in the interval [0,
[`RAND_MAX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#RAND_MAX)].

## `RAND_MAX`

    #define RAND_MAX <integer constant expression >= 32,767>Copy to clipboard

The macro yields the maximum value returned by
[`rand`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#rand).

## `realloc`

    void *realloc(void *ptr, size_t size);Copy to clipboard

The function allocates an object of size `size`, possibly
obtaining initial stored values from the object
whose address is `ptr`.
It returns the address of the new object if successful; otherwise,
it returns a null pointer. You can safely convert the return value
to an object pointer of any type
whose size is not greater than `size`.

If `ptr` is not a null pointer, it must be the address
of an existing object that you first allocate by calling
[`calloc`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#calloc),
[`malloc`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#malloc), or
`realloc`. If the existing object is not larger
than the newly allocated object, `realloc` copies the entire
existing object to the initial part of the allocated object. (The
values stored in the remainder of the object are indeterminate.) Otherwise,
the function copies only the initial part of the existing object that
fits in the allocated object. If `realloc` succeeds in allocating
a new object, it deallocates the existing object. Otherwise, the existing
object is left unchanged.

If `ptr` is a null pointer, the function does not store
initial values in the newly created object.

## `size_t`

    typedef ui-type size_t;Copy to clipboard

The type is the unsigned integer type `ui-type`
of an object that you declare to store the result of the
[*sizeof*](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_express.html#sizeof%20operator) operator.

## `srand`

    void srand(unsigned int seed);Copy to clipboard

The function stores the seed value `seed`
in a static-duration object that
[`rand`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#rand)
uses to compute a pseudo-random number. From a given seed value,
that function always generates the same sequence of return
values. The program behaves as if the target environment calls
`srand(1)` at program startup.

## `strtod`

    double strtod(const char *restrict s, char **restrict endptr);Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *double.*
If `endptr` is not a null pointer,
the function stores a pointer to the unconverted
remainder of the string in `*endptr`. The function then returns
`x`.

The initial characters of the string `s` must consist of
zero or more characters for which
[`isspace`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_ctype.html#isspace) returns nonzero,
followed by the longest sequence of one or more characters that match
any part of the full pattern for `strtod` shown in the diagram.

![](data:image/gif;base64,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)

**Boldface** indicates a feature added with
[C99](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_lib_over.html#C99).

Here, `inf` is the sequence of characters `inf`
or `infinity` with individual letters in either case,
to represent the special value infinity. Similarly, `nan`
is the sequence of characters `nan` or `nan(qualifier)`
with individual letters in either case, to represent the
special value not-a-number (NaN). A `qualifier` is any sequence
of zero or more letters, digits, and underscores. Each implementation defines
what effect, if any, a `qualifier` has on the actual encoding
of a NaN.

The pattern for a `strtod` hexadecimal string
is shown in the diagram.

![](data:image/gif;base64,R0lGODdhcQLYAPcAAAAAAAEBAQICAgMDAwQEBAUFBQYGBgcHBwgICAkJCQoKCgsLCwwMDA0NDQ4ODg8PDxAQEBERERISEhMTExQUFBUVFRYWFhcXFxgYGBkZGRoaGhsbGxwcHB0dHR4eHh8fHyAgICEhISIiIiMjIyQkJCUlJSYmJicnJygoKCkpKSoqKisrKywsLC0tLS4uLi8vLzAwMDExMTIyMjMzMzQ0NDU1NTY2Njc3Nzg4ODk5OTo6Ojs7Ozw8PD09PT4+Pj8/P0BAQEFBQUJCQkNDQ0REREVFRUZGRkdHR0hISElJSUpKSktLS0xMTE1NTU5OTk9PT1BQUFFRUVJSUlNTU1RUVFVVVVZWVldXV1hYWFlZWVpaWltbW1xcXF1dXV5eXl9fX2BgYGFhYWJiYmNjY2RkZGVlZWZmZmdnZ2hoaGlpaWpqamtra2xsbG1tbW5ubm9vb3BwcHFxcXJycnNzc3R0dHV1dXZ2dnd3d3h4eHl5eXp6ent7e3x8fH19fX5+fn9/f4CAgIGBgYKCgoODg4SEhIWFhYaGhoeHh4iIiImJiYqKiouLi4yMjI2NjY6Ojo+Pj5CQkJGRkZKSkpOTk5SUlJWVlZaWlpeXl5iYmJmZmZqampubm5ycnJ2dnZ6enp+fn6CgoKGhoaKioqOjo6SkpKWlpaampqenp6ioqKmpqaqqqqurq6ysrK2tra6urq+vr7CwsLGxsbKysrOzs7S0tLW1tba2tre3t7i4uLm5ubq6uru7u7y8vL29vb6+vr+/v8DAwMHBwcLCwsPDw8TExMXFxcbGxsfHx8jIyMnJycrKysvLy8zMzM3Nzc7Ozs/Pz9DQ0NHR0dLS0tPT09TU1NXV1dbW1tfX19jY2NnZ2dra2tvb29zc3N3d3d7e3t/f3+Dg4OHh4eLi4uPj4+Tk5OXl5ebm5ufn5+jo6Onp6erq6uvr6+zs7O3t7e7u7u/v7/Dw8PHx8fLy8vPz8/T09PX19fb29vf39/j4+Pn5+fr6+vv7+/z8/P39/f7+/v///yH5BAAAAAAALAAAAABxAtgAQAj/AP8JHEiwoMGDCBMqXMiwocOHECNKnEixosWLGDNq3Mixo8ePIEOKHEmypMmTKFOqXMmypcuXMGPKnEmzps2bOHPq3Mmzp8+fQINOBKBwDgA/IokiBKBUqNOnUKOWbCp1INWqQxdeHegtAoAF6ToxhTLQKFMAZP8NYyrjn1mkCZWenbsUq927eO1ulbo3r1atfadKDOy3sOHDKefS/cdUIWGjcEESZlywcdyOw9punCxQ8Vm9iEOLHi25oeemfbt+DTu27Ny0awG0fet4qGerBYf5cXLWFEGxbAmaPQv2n2oDyFSnFTjct0HOpC9Hn06dOnTH1z9mf2jZZvfq3MGL/x/vdzv580DNo18/ce1y9hXVP2f5Hf55+fZvDpdt8N6H4AL5NxdyBAnI30AGrsaVV0yZcWB+g11EWFeaOeGcW5EN856Faml22Wn4QShUiCIaF0GFF86R4Ya+ZYaQNx2kM5ATmt1Twg8yYjiQhgSt5VwnxRGURY4zguUEFPdEcRCMRJZ1IVQgRinlZxRNZuVLhG1FolNbevdXiWBW15duA3US2RxpeYMBMrVBdNVictXH5WBdeiQnY1TGCV2dtjH0Zp6d3RmmS7rxxtSFqhHXpFu9FdSccK+5NpdzxyXn1Xs1gdjZSOYFthhoz522aW4AUBojc0F2guk/QxbUFVxzPIbpzRBtHvSpVaJSlhCFAnHI3IoEcehirXUtReWgg2rq05UH8SiQmQWWQMWpxJp235c5dYotfVXeZiuypOXKp07jfhsRs3eVC65K6JaoLkztrmvntli9K69J8fppkb2c5pXvvRrtpaygoyIEWVL0AtxTvATralCs1vI0cJYKCUigQ7GVqm+18/8pHFOuDrvqFVjALbcfbMHRJp3H5IG85b8tHYurYrgllPGTCiW6qrksG9Zwvz27exDEEa8c82dE3WpszEE37TTAU05ZtEMvJ/z01VhnDSpBNFcmodVahy322OnJXHNBhp7lYcdkt+3223hVDffcdNdt991456333nz37fffgAcu+OCEFz4dv34ibvjijCM24Ym9pgjsjC2u/a2yjWc+or/XcpwYx4prLjp3gOK5J32cqffzSqubLlegoQs2+uzwmu06nDlD/o+vOgrkbOQdgn021+Ia5KNATKKao6oGtUrQq8zJSqvRgLX+U+y0Z++151xjea7wMmEflfjaF05++UE3nY9+4Oqvv7D7xqflX2TP0l/gfzj/A+3DHqI5I1zuuZrcDHYUhC0Nfm7S2sFS0pUgXWRYGDFQ/v9YBrPhPW9krEGLpFqjlpQxxX7bA9n2otM+oFEvaKohGQcZdRaU8UdliWKKAw1lAGDgjzmR+o2iNijDdFjMhjX8AIFiqCD9KeZi6TNgArmHK6Z973CcY2Ljjmccaj3PisibnkFmNbTJzYhAKkJeBGA1wdpx73f76xVSnADCEVLNViIcX2UoxhEIZkRg4qIjAdu4GathDoEKcxlCyFS/Kj3xPt4KmVp206gyqQ1ScylOpZQDSY2xzU2JTA0GS8ZDF87mg1JMnB4BuS85xZEvJnxjmKzHrnexcl50akzSbFdCwdFllq/kS9R2mchDFitdpOTZLzHJS6VdL4onvNufLKOjp6mhZHW1pFsFhykcUy3Kgt4pne2E+czUgW9unqJl8XalO96F0XcsCl4oowlOP44zPtcTp7cCk8bfpQ1AvjtLFrRIzUtyM3PTlF0wldhPtzyJaP5MKOq6FlCSsHOgEK3Xvja2xKx8M6IYzShHtCWyI7Lpn27UqEhHGrBibpOYUiKpSld6kgGy9KUwfSY8Y0rTmtr0pjjNqU53ytOe+vSnQA2qUP+HStSiGvWoSTGpUnuJ1KZq7qEPdapUV7kQ55WGeCedquiWytWuejWqWIqaQvLw0XuoYHllFGMBsbNUrT4VmeJpaCphJzC3AhSu4JErQZ1pV8KF6KttDU98AEvYXCo0VIVVqiH7asso8fVzoTzsTFLn2KqAlbEQ6mXXuqcQq2onYZvFpkoQKtk5GhNKmAVcYcda1rM+K60mWitbEysnKnxUIHco5I7s9zsnDcSzZJ0tbYdLXK+mtp3Vq6tLVLdNqpj1mstN1nHh5lLWdeSyybQPdqd7mDoVl5ec+u5X5bVd7hamvHZFr3njtl5usTSND4GvRHobtHGJ9489VW/W/PcuGz4+9yDy/UeSCmJb44ihRzvzWHXZxVP9tteyX+ssdPuIVcPCz8FQ8exJCGkTLv8KMLmVRUhwBexa/cFWNXycmWIPd98WSy2yABvxf02cO9m6pX8XKnCZ4NKJtHrjwAqhL7TI1GPm4HiL/HRaQKGKWOWSEK+lfXB6rupLkHLWiYJ9MnthDFHSVlO7CbHYbSNU0YI22cWhLXMs0fziLK8ZzWqO8uJ0jFsj+7YgIzZInssEWw5/WSAaXhZC6okpo8C2YKqsMFOfwtFsnTnNZm4paEPcuBk/DdKBuZmkkMLJSJt50ag1rSlh4uUri/o7mK7qhAMGNlAbFdIfI2yY/4PEN7P51rjG7z/o/I/c6o9+flbLqhAK3DE/erUJkXGJi0xOGxsr19COtrSnDe2FNXf/0F6cn/4caOXssvhOzi1x+NbcbXwNNqsYtltoTyvRQTbSiBpUWbnnjZ50q4vJtr72TSntuLlS9NnU/m63Au7qzUh7sRZ8U7IILnBTKzLdrP4smb3NaI3qdTwQr7Kc33ZxQWe044jWuMSgHFK8gVzRLo5zMEG+4J38Fdcqd7jJj51VmUOW4he+aMmjFyBx7zxT/Pa0QIWe8dD0RbPGnEygN6pz9OUr1Q97JJdrdyuoNysyAW7WcrzBiG+ePGwNF3Fr0VrjFKuY4WhPe7RBDN5Sql28NltO1hdyzrjImnanxfdR8z40S3bCcjYPPOuqrm8s61TvjN3LHBzElFr/XLStEzwlvf2d02mbt+WCF24xqalwUVZpW8qgT/TEcb5x0hc99Kj3XsxJvOqQlz71sM/rHJloaaLH/vb5weM8I0x63Pse45nk/e+Hj6yvZ574yAcX5pPPfOnOtPnQJ69xo0/96lv/+tjPvva3z/3ue//74A+/+MdP/vKb//zoT7/66dfP/va7//3wj7/883s+C8///pA3N/7372br8v//ocRsVIZVAMh/hJEkwGE5aTNDAIAcsZFWqAFrBQh/hJFGI5YxUhcg/8FtcCR5E2gdJAdFtFdiP7Yj74FQasImbMR26PaBo3F6oid7UzeAEgiDLohwWxNXTRcSR+dkN+gzIahlvbdX//aD5RGE4bKDA/hYRpiD7YZxRShpo9eE40MVVrgn9Xcd+GF/dpIdqEY8qESF9ZJSSghLM6hImWIaZChHYjiGHvh4+jeE+TdunieBSdSGbggnJzUZAihx1MNu6sI8EBFsx3d2XJiG/3iYh1e4bhUTBQmINjvUKw2IDA+Ic1qiWQUhFinwH5PYIxkoYJz4JP4hA4biQPvhbGhodzV3h4loWaa0hgAWGRfoGWsjIBwYZbqna6RVYCWIIEryPEm2SAOxZ3Pnemy1Za24OTbnWIExY70obH9mHGuyO2aXinV4SyIDF9qmTtu2KKWmYx7WczLiH/nTaEmYjF7CdnA4dFSTZldRatFFVeiIiKooh0soSiuTMYBneCJigze4fHEYcY4mj/M4WcLnfxQ2kGDijy7YJbWEOOjFkAhZkB+jfhI5gRf5UxkJgBuZXxRpkOnXkQpTjAlBkgxBXz0jkjulkvkxHGYQGUSERKhisQDhEIqxdRa1BhwaFCwy1AoJFkgWCVFpA3hzV3s71h+/OBC8CGTo9GEYcYh0opEDVXfytT9AQiRGqVtXyXNNKRA65h8/CTUHeXOH95F0+HzuVZZmCS9jmYmH1parGFEsORN9eBLPeBGCqBFZSUFt6YuPyJM9NCOTWIm/VHAWpzUIiE+SGJiS6ICHIpgr9Cy9kWcLuCgGsgBhUFY2KZgOIgNGwYCReZT/TomWBmGBH4WBimmLrXc77DZScxkTpplPilGLG9gkOrmTv/Y8QIaaD2JpAwaMrkIr9/AGBuZILdQfPtc0SxZmJMiUvYWC07iCmteCIghMZzgozuicJ4go0SmLp2mKaRIBF/OciKJFVHRnSskmwTViF3iLJimW66R6dHV0IIiMQreW7IiL8jl7r+eEEHadHNmFFmWJ+8mE3YWE1ihShOg71Vif9xiF64h4BgqE9jl5hKOJnFhraVNoinEmHQqYRRRbg4BBoEiKjMmKfth/cvaQA3qO1mmPgrOLH3WbqzJ3AcabaxOOPeKdc4IQHJI8jAJGj3mfIfWFTcSGURlrdmdq/60DleeihfyJaE46N9ADinDRnpbpWuSIIFr6Ac5BntFIEOAYjB5Xml7kFkhSAsbWn2jYZqGmojSRi284hw4VhW7KOPAoNn1BaJDYoOZoiHH5Pqt3ligXqBKqUEFXOPp4aXuYEK1iaXUnnUQaeHM6ZRU2qfEVlleXXXkkKHz4lhPFPZUKVK1pbYxIhMJjh8pYqA6HoY03ZouKIJupgSYaoqcIQuEkMyJ0gI6omLsTib/qmJY0b7k6pTQ1qjdxp2YYg6ZVofO5aDJanL4YnMbDo6LpafKka/01jKdJi/cTorZXj24Fiy6nKYHxo1g0qMT6guaajRoIQB6ylWHqlR+lo5z/taUR2oG30YzNaYLRmILUWIZRiqmuKaelCnRKs6eTQ0lG4XiFuI7smrCOAqpSiFL1caik0zCvWV9mY5g4QZ1m6q/BogP7CLEm6zgE0xSxWpHEBKPLarGeUnmbFahv2jzjKG7Hc54WSqf15nLXVaDt6Gobq2DI6p8/q649Sy5Hy49qqK1DCzWJel6UB6Biko4pKlOxdDajVlPHEoH/Lzi1BOqsKyewDmq0D4ugfRmfYktKxieEZsuzFLq06vqaTwsfbeuib2uM6ka2SvtxAruFPfqiBDs2d5ush3mGJOKPdMu3WVO4ViuXZZi4q5q3CSpNA3uFathNzDq2iNt3OLmmcLtcVgiGiaO5E1q5yFWoB4u6YBu65cNyBpMiZQRxysqmchuue2Owhgq0J/u6kUtA72a7g4esGHt8dXtM+ponjaoQdXm7wjs6DLO8DwOqRdep9JkQ6LqaAaKmAsa9auuyYKeKqIaJYdarD7KYIcobwgqBjPtWoEO+pEkuhHeqsSiyC2EjH0UjXte+o9mBNFdzsdlBs/mtt5ivfus5lrWLtHH6ilGbm105iCVLp47LccmLjQiRnfZrUFzRnfwbU8yYtnqLOhWMNBLGehExBxHsumzrjrwrVEy1FbzhCZyYwhNcUhfLwvG4UiCblkW1w2VBP3tmvOEzsynbwlxrxFKleEGiowYcVh6rwleLU8U7VYpHsTXsdsSLxMfKw5gFw68KoWfLg93htWBcp/iJdyDMus97OnlnvF6S+7vx+7xt3MM4CKNvTLVzTHx/WiDJqZ95/H17zKWrecV/jHqBLI77W8jdt0zXexB7KcSKzH2XSL91LMeRHHu6u7qJfMnh98Ghysnr98JpDMrg58NTSMrxB5CoHMqjvMrop8qu/MqtHMvld8e0TIGVfMu6vMu8F9zLvvzLwBzMwjzMxFzMxnzMyJzM4BIQADs=)

Here, `hex` is a hexadecimal digit, in either case, and
a `point` is the
[decimal-point](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#decimal_point)
character for the current
[locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#locale).
(It is the dot (`.`) in the
[`"C"`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#C%20locale) locale.)
If the string `s` matches this pattern, its equivalent value
is the hexadecimal integer represented by any digits to the left of the
`point`, plus the hexadecimal fraction
represented by any digits to the right of the `point`,
times 2 raised to the signed decimal integer power
that follows an optional `p` or `P`. A leading
minus sign negates the value.

The pattern for a `strtod`
decimal string is shown in the diagram.

![](data:image/gif;base64,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)

Here, a `point` is the
[decimal-point](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#decimal_point)
character for the current
[locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#locale).
(It is the dot (`.`) in the
[`"C"`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#C%20locale) locale.)
If the string `s` matches this pattern, its equivalent value
is the decimal integer represented by any digits to the left of the
`point`, plus the decimal fraction
represented by any digits to the right of the `point`,
times 10 raised to the signed decimal integer power
that follows an optional `e` or `E`. A leading
minus sign negates the value.

In locales other than the
[`"C"`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#C%20locale) locale,
`strtod` can define additional patterns as well.

If the string `s` does not match a valid pattern, the value
stored in `*endptr` is `s`,
and `x` is zero. If a
[range error](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_math.html#range%20error) occurs,
`strtod` behaves exactly as the functions declared in
[`<math.h>`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_math.html#&lt;math.h&gt;).

## `strtof`

    float strtof(const char *restrict s, char **restrict endptr); [added with C99]Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *float.*
If `endptr` is not a null pointer,
the function stores a pointer to the unconverted
remainder of the string in `*endptr`. The function then returns
`x`. `strtof` converts strings exactly as does
[`strtod`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#strtod).

If the string `s` does not match a valid pattern, the value
stored in `*endptr` is `s`,
and `x` is zero. If a
[range error](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_math.html#range%20error) occurs,
`strtod` behaves exactly as the functions declared in
[`<math.h>`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_math.html#&lt;math.h&gt;).

## `strtol`

    long strtol(const char *restrict s, char **restrict endptr,
        int base);Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *long.*
If `endptr` is not a null pointer,
it stores a pointer to the unconverted remainder
of the string in `*endptr`.
The function then returns `x`.

The initial characters of the string `s` must consist of
zero or more characters for which
[`isspace`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_ctype.html#isspace) returns nonzero,
followed by the longest sequence of one or more characters that match
the pattern for `strtol` shown in the diagram.

![](data:image/gif;base64,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)

The function accepts the sequences
`0x` or `0X` only
when `base` equals zero or 16.
The letters `a-z` or `A-Z`
represent digits in the range [10, 36).
If `base` is in the range
[2, 36], the function accepts only digits
with values less than `base`.
If `base` == 0, then a leading `0x` or `0X`
(after any sign) indicates a hexadecimal (base 16) integer, a leading
`0` indicates an octal (base 8) integer, and any other valid
pattern indicates a decimal (base 10) integer.

If the string `s` matches this pattern, its equivalent
value is the signed integer of the appropriate base represented by
the digits that match the pattern. (A leading minus sign negates the
value.) In locales other than the
[`"C"`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#C%20locale) locale,
`strtol` can define additional patterns as well.

If the string `s` does not match a valid pattern, the value
stored in `*endptr` is `s`,
and `x` is zero. If the
equivalent value is too large to represent as type *long,*
`strtol` stores the value of
[`ERANGE`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#ERANGE) in
[`errno`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#errno)
and returns either
[`LONG_MAX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_limits.html#LONG_MAX),
if `x` is positive, or
[`LONG_MIN`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_limits.html#LONG_MIN),
if `x` is negative.

## `strtold`

    long double strtold(const char *restrict s,
        char **restrict endptr); [added with C99]Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *long double.*
If `endptr` is not a null pointer,
the function stores a pointer to the unconverted
remainder of the string in `*endptr`. The function then returns
`x`. `strtold` converts strings exactly as does
[`strtod`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#strtod).

If the string `s` does not match a valid pattern, the value
stored in `*endptr` is `s`,
and `x` is zero. If a
[range error](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_math.html#range%20error) occurs,
`strtod` behaves exactly as the functions declared in
[`<math.h>`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_math.html#&lt;math.h&gt;).

## `strtoll`

    long long strtoll(const char *restrict s, char **restrict endptr,
        int base); [added with C99]Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *long long.*
If `endptr` is not a null pointer,
it stores a pointer to the unconverted remainder
of the string in `*endptr`.
The function then returns `x`.
`strtoll` converts strings exactly as does
[`strtol`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#strtol).

If the string `s` does not match a valid pattern, the value
stored in `*endptr` is `s`,
and `x` is zero. If the
equivalent value is too large to represent as type *long long,*
`strtoll` stores the value of
[`ERANGE`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#ERANGE) in
[`errno`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#errno)
and returns either
[`LLONG_MAX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_limits.html#LLONG_MAX),
if `x` is positive, or
[`LLONG_MIN`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_limits.html#LLONG_MIN),
if `x` is negative.

## `strtoul`

    unsigned long strtoul(const char *restrict s, char **restrict endptr,
        int base);Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *unsigned long.*
If `endptr` is not a null pointer,
it stores a pointer to the unconverted remainder
of the string in `*endptr`.
The function then returns `x`.

`strtoul` converts strings exactly as does
[`strtol`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#strtol),
but reports a range error only if the equivalent value is too large
to represent as type *unsigned long.*
In this case, `strtoul` stores the value of
[`ERANGE`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#ERANGE) in
[`errno`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#errno) and returns
[`ULONG_MAX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_limits.html#ULONG_MAX).

## `strtoull`

    unsigned long long strtoull(const char *restrict s, char **restrict endptr,
        int base); [added with C99]Copy to clipboard

The function converts the initial characters of the string `s`
to an equivalent value `x` of type *unsigned long long.*
If `endptr` is not a null pointer,
it stores a pointer to the unconverted remainder
of the string in `*endptr`.
The function then returns `x`.
`strtoull` converts strings exactly as does
[`strtoul`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#strtoul).

If the string `s` does not match a valid pattern, the value
stored in `*endptr` is `s`,
and `x` is zero. If the
equivalent value is too large to represent as type *unsigned long long,*
`strtoull` stores the value of
[`ERANGE`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#ERANGE) in
[`errno`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_errno.html#errno) and returns
[`ULLONG_MAX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_limits.html#ULLONG_MAX).

## `system`

    int system(const char *s);Copy to clipboard

If `s` is not a null pointer, the function passes the string
`s` to be executed by a
**command processor**, supplied by
the target environment, and returns the status reported by the command
processor. If `s` is a null pointer, the function returns nonzero
only if the target environment supplies a command processor. Each
implementation defines what strings its command processor accepts.

## `wchar_t`

    typedef i-type wchar_t; [keyword in C++]Copy to clipboard

The type is the integer type `i-type` of a
[wide-character constant](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#wide-character%20constant), such as `L'X'`.
You declare an object of type `wchar_t` to hold a
[wide character](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#Wide-Character%20Encoding).

## `wcstombs`

    size_t wcstombs(char *restrict s, const wchar_t *restrict wcs, size_t n);Copy to clipboard

The function stores a multibyte string, in successive elements
of the array whose first element has the address `s`,
by converting in turn each of the wide characters
in the string `wcs`. The multibyte string begins in the
[initial conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#initial%20conversion%20state).
The function converts each wide character as if by calling
[`wctomb`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#wctomb) (except that the
[conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#conversion%20state)
stored for that function is unaffected). It stores no
more than `n` bytes, stopping after it stores a null byte. It
returns the number of bytes it stores, not counting the null byte,
if all conversions are successful; otherwise, it returns -1.

## `wctomb`

    int wctomb(char *s, wchar_t wchar);Copy to clipboard

If `s` is not a null pointer,
the function determines `x,`
the number of bytes needed to represent
the multibyte character corresponding
to the wide character `wchar`.
`x` cannot exceed
[`MB_CUR_MAX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_stdlib.html#MB_CUR_MAX).
The function converts `wchar` to its corresponding multibyte
character, which it stores in successive elements of the array whose
first element has the address `s`.
It then returns `x,` or it returns -1
if `wchar` does not correspond to a valid
multibyte character. `wctomb` includes the terminating
null byte in the count of bytes. The function can use a
[conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#conversion%20state)
stored in a static-duration object to determine how to interpret the
multibyte character string.

If `s` is a null pointer and if multibyte characters have a
[state-dependent encoding](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#state-dependent%20encoding)
in the current
[locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_locale.html#locale), the function stores the
[initial conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_charset.html#initial%20conversion%20state)
in its static-duration object and returns
nonzero; otherwise, it returns zero.

* * *

See also the
**[Table of Contents](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_index.html#Table%20of%20Contents)** and the
**[Index](https://docs.qualcomm.com/doc/80-N3040-23/topic/_c_index.html)**.

*[Copyright](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_crit_pjp.html) © 1992-2006by P.J. Plauger and Jim Brodie. All rights reserved.*

<!--V5.01:1566-->

Last Published: Oct 06, 2026

Previous Topic
 
<stdio.h></stdio.h> Next Topic

<string.h></string.h>