Knowledge baseExam Center
ENEnglish
Choose language13

CKTIS / C

Knowledge base — C

Programming syntax, operators and concepts. Find an explanation, explore an example and return to learning.

Entries: 472

C

iscntrl — C23 character classification function

`iscntrl(c)` from `<ctype.h>` returns a nonzero value when `c` is a control character in the current locale. A control character is not printable; in the initial `C` locale, newline and horizontal tab are among the members of this class.

Basic · C23
C

isdigit — C23 character classification function

`isdigit(c)` from `<ctype.h>` tests whether `c` is a decimal digit from the basic execution character set: one of `0` through `9`. It returns a nonzero value for a digit and zero for every other valid argument.

Basic · C23
C

isfinite — C23 floating-point classification macro

`isfinite(x)` from `<math.h>` is a classification macro: it returns nonzero exactly when its real floating argument has a finite value. Normal numbers, subnormal numbers, and both signed zeros are finite; infinities and NaNs are not.

Basic · C23
C

isgraph — C23 character classification function

`isgraph(c)` from `<ctype.h>` returns a nonzero value for a printing character other than space in the current locale. It therefore covers characters that leave a visible mark—letters, digits, and punctuation—but excludes the spacing character and control characters.

Basic · C23
C

isinf — C23 floating-point classification macro

`isinf(x)` from `<math.h>` is a classification macro that returns nonzero exactly when its real floating argument is positive or negative infinity. Finite values and every NaN produce zero.

Basic · C23
C

islower — C23 character classification function

`islower(c)` from `<ctype.h>` returns a nonzero value when `c` is a lowercase letter in the current locale. In the `C` locale it includes at least the characters `a` through `z`; another locale may classify additional single-byte letters.

Basic · C23
C

isprint — C23 character classification function

`isprint(c)` from `<ctype.h>` returns a nonzero value for a printing character in the current locale. Unlike `isgraph`, it also includes the space character; control characters such as newline and horizontal tab are not printing.

Basic · C23
C

ispunct — C23 character classification function

`ispunct(c)` from `<ctype.h>` returns a nonzero value for a punctuation character: a printing character that is neither space nor alphanumeric in the current locale. Underscore is punctuation even though C permits it in identifiers.

Basic · C23
C

isspace — C23 character classification function

`isspace(c)` from `<ctype.h>` returns a nonzero value for a white-space character in the current locale. In the `C` locale the class contains space, `\f`, `\n`, `\r`, `\t`, and `\v`, so it is broader than horizontal-only `isblank`.

Basic · C23
C

isupper — C23 character classification function

`isupper(c)` from `<ctype.h>` returns a nonzero value when `c` is an uppercase letter in the current locale; in the `C` locale this covers `A` through `Z`. The result is merely logically nonzero, not necessarily exactly `1`.

Basic · C23
C

isxdigit — C23 character classification function

`isxdigit(c)` from `<ctype.h>` returns nonzero for a hexadecimal digit: `0`–`9`, `A`–`F`, or `a`–`f`. It classifies one character; it does not parse a complete literal or its `0x` prefix.

Basic · C23
C

labs — C23 arithmetic utility function

`labs(j)` from `<stdlib.h>` returns the absolute value of a `long int` argument. Its result has type `long int`; the function neither parses text nor reports an error through `errno`.

Basic · C23
C

ldexp — C23 mathematical function

`ldexp(x, exp)` from `<math.h>` returns `x * 2^exp`; `ldexpf` and `ldexpl` serve `float` and `long double`. It therefore scales by an integral power of two regardless of the value of `FLT_RADIX`.

Intermediate · C23
C

ldiv — C23 arithmetic utility function

`ldiv(numer, denom)` from `<stdlib.h>` computes a `long int` quotient and remainder in one operation and returns an `ldiv_t` with `quot` and `rem` members. Division truncates toward zero, and `numer == quot * denom + rem`.

Basic · C23
C

llabs — C23 arithmetic utility function

`llabs(j)` from `<stdlib.h>` returns the absolute value of a `long long int` argument with the same result type. It neither parses text nor sets `errno`.

Basic · C23
C

lldiv — C23 arithmetic utility function

`lldiv(numer, denom)` from `<stdlib.h>` computes a `long long int` quotient and remainder and returns an `lldiv_t` with `quot` and `rem`. Division truncates toward zero, and `numer == quot * denom + rem`.

Basic · C23
C

llround — C23 mathematical function

`llround(x)` from `<math.h>` rounds to the nearest `long long int`; an exact halfway case always moves away from zero, independently of the current floating-point rounding mode.

Intermediate · C23
C

localeconv — C23 locale function

`localeconv()` from `<locale.h>` returns a pointer to a `struct lconv` describing current numeric and monetary formatting, including `decimal_point`, grouping separators, and currency signs. It does not change the locale.

Intermediate · C23
C

localtime — C23 time function

`localtime(timer)` from `<time.h>` converts the designated `time_t` to local broken-down calendar time and returns a pointer to `struct tm`; it applies the environment’s time-zone and daylight-saving rules. It may return null on failure.

Intermediate · C23
C

log — C23 mathematical function

`log(x)` from `<math.h>` computes the natural logarithm of positive `x` and returns `ln(x)` as `double`; `logf` and `logl` serve `float` and `long double`. The result is negative for `0 < x < 1`, zero for `x == 1`, and positive for `x > 1`.

Basic · C23
C

log10 — C23 mathematical function

`log10(x)` from `<math.h>` returns the base-ten logarithm of positive `x` as `double`; `log10f` and `log10l` serve the other floating types. The result states which power of `10` produces the argument.

Basic · C23
C

log1p — C23 mathematical function

`log1p(x)` from `<math.h>` computes `ln(1 + x)` without the digit loss caused by separately forming `1 + x` for very small `x`; `log1pf` and `log1pl` serve the other types. Its real domain is `x >= -1`.

Intermediate · C23
C

log2 — C23 mathematical function

`log2(x)` from `<math.h>` returns the base-two logarithm of positive `x`; `log2f` and `log2l` serve the other types. Powers of two produce integral results, useful for tree levels, block sizes, and bit-oriented analysis.

Basic · C23