List of Standard Library Functions

Automatic version identification

SpineViewer

It's easy to tell by looking at it.

Response Time Checker

I can leave my computer on and do it.

Mouse cleaning time

I can leave my computer on and do it.

Mouse cleaning time

C language learned by suffering

input-output

This function mainly handles files.
In C, peripheral devices other than disks can also be treated as files.
It is also possible to treat them as a defined file pointer.

Default file pointer

stdin Standard input (usually keyboard)
stdout Standard output (usually display)
stderr Standard error output (usually display)

These can be changed by the user through redirection or other means, or they can be changed by the
In some environments, it may be associated with a different device or disabled.

fopen

Function type : FILE *fopen(const char *filename, const char *mode);
Arguments : filename, mode string
Return value : Pointer to the opened file. NULL in case of failure.
Function: opens a file.
Mode : r read, w new, a append, b binary if appended, + for both input and output.

fclose

Function type : int fclose(FILE *fp);
Arguments : file pointer
Return value : 0 on success, EOF on failure
Function: Close a file.

fgetc

Function type : int fgetc(FILE *fp);
Arguments : file pointer
Returns: Characters read. EOF if failed or end reached.
Function: reads one character from a file.

getc

Function : same as fgetc.
Caution: Be careful of side effects because it may be a macro.

fgets

Function type : char *fgets(char *s, int n, FILE *fp);
Arguments : buffer to store strings, buffer size, file pointer
Return value : Buffer specified by argument. NULL if failed or end is reached.
Function : reads one line from a file. The result contains a newline.

fputc

Function type : int fputc(int c, FILE *fp);
Arguments : character, file pointer
Returns: Output character. EOF on failure.
Function : Write a character to a file.

putc

Function : Exactly the same as fputc.
Caution: Be careful of side effects because it may be a macro.

fputs

Function type : int fputs(const char *s, FILE *fp);
Arguments : string, file pointer
Return value : True on success, EOF on failure.
Function : Writes a string to a file.

fread

Function type : size_t fread(void *ptr, size_t size, size_t nelem, FILE *fp);
Arguments : buffer to store the result of reading, size of one item, number of items, file pointer
Return value : Number of items read. 0 in case of failure.
Function : reads fixed size items from a file.

fwrite

Function type : size_t fwrite(const void *ptr, size_t size, size_t nelem, FILE *fp);
Arguments : buffer to write, size of one item, number of items, file pointer
Return value : Number of items written. 0 in case of failure.
Function : writes fixed size items to a file.

fprintf

Function type : int fprintf(FILE *fp, const char *format, ...) ;
Arguments : file pointer, formatted string, variable
Return value : Number of output characters. Negative value on failure.
Function: write a formatted string to a file.

fscanf

Function type : int fscanf(FILE *fp, const char *format, ...) ;
Arguments : file pointer, conversion specified string, variable buffer
Returns: Number of successful conversions. Returns : the number of successful conversions, or -1 in case of failure.
Function : reads a string from a file and converts it to the specified format.

ftell

Function type : long ftell(FILE *fp);
Arguments : file pointer
Returns: Current file position.
Function : Obtains the file position.

fseek

Function : int fseek(FILE *fp, long offset, int ptrname);
Arguments : file pointer, number of file position moves, file position reference
Return value : 0 on success, non-zero on failure.
Function : Changes the file position.
Position : SEEK_SET first, SEEK_CUR current position, SEEK_END end.

fgetpos

Function type : int fgetpos(FILE *fp, fpos_t *ptr);
Arguments : file pointer, pointer to a variable that stores the file position
Return value : 0 on success, non-zero on failure. Function : Stores the current file position.

fsetpos

Function type : int fsetpos(FILE *fp, const fpos_t *ptr); Argument : file pointer, pointer to a variable that stores the file position
Return value : 0 on success, non-zero on failure.
Function : Change the file position.

feof

Function type : int feof(FILE *fp);
Arguments : file pointer
Return value : True if end is reached, false if not.
Function : Checks whether the end of the file has been reached.

ferror

Function type : int ferror(FILE *fp);
Arguments : file pointer
Return value: True if an error occurred, false if no error occurred.
Function : Checks whether an error has occurred in a file.

clearerr

Function type : void clearerr(FILE *fp);
Argument : file pointer
FUNCTION : Recover in case of a file error.

fflush

Function type : int fflush(FILE *fp);
Arguments : file pointer
Return value : 0 on success, false on failure.
Function : Force output buffer.
Note: Some compilers can clear the input buffer. However, it is not a good idea.

freopen

Function type : FILE *freopen(const char *filename, const char *mode, FILE *fp);
Arguments : filename, mode string, file pointer
Return value : file pointer specified by argument. NULL in case of failure.
Function : Reallocates the file pointer.

rename

Function type : int rename(const char *oldname, const char *newname);
Arguments : current file name, new file name
Return value : 0 on success, non-zero on failure.
Function : Renames a file.

remove

Function type : int remove(const char *filename);
Arguments : filename
Return value: 0 on success, non-zero on failure.
Deletes a file.

getchar

Function : delete a file;
Returns : the character read. If failed, EOF.
Function : reads one character from the standard input (keyboard).

putchar

Function : int putchar(char c);
Arguments : character
Returns: Output character. EOF on failure.
Function : Write a character to the standard output (display ).

gets

Function type : char *gets(char *s);
Argument : buffer to store the string read
Return value : Buffer specified by argument. NULL if failed or end is reached.
Function : reads one line from the standard input (keyboard). The result does not include a newline.
Caution : Do not use this function because it causes buffer overrun (virus invasion).

puts

Function type : int puts(const char *s);
Arguments : string
Return value : 0 on success, non-zero on failure.
Function : Write one line to standard output (display). A new line is written.

perror

Function type : void perror(const char *s);
Argument : string to display
Function : Displays the error that occurred immediately before with the specified string.

printf

Function : int printf(const char *format, ...) ;
Arguments : formatted string, variable
Return value : Number of output characters. If failed, -1.
Function : writes formatted string to standard output (display ).

scanf

Function type : int scanf(const char *format, ...) ;
Arguments : string to be converted, variable buffer
Return value : Number of successful conversions. Returns: the number of successful conversions, -1 in case of failure.
Function : reads a string from the standard input (keyboard) and converts it to the specified format.
Caution : If this function is used with other input functions, it may cause unexpected behavior.

general purpose

A collection of general-purpose functions that are not particularly classified.
Memory-related, process-related, conversions, etc.

malloc

Function type : void *malloc(size_t n);
Argument : size of memory to allocate
Return value : Address of allocated memory. NULL if memory could not be allocated.
Function : Allocates memory dynamically.

calloc

Function type : void *calloc(size_t int nelem, size_t elsize);
Arguments : number of elements, size of one element
Return value : Address of allocated memory. NULL if memory could not be allocated.
Function : Allocate memory dynamically. Allocated memory is cleared to zero.
Caution : Do not be mistaken that bugs are reduced because memory is cleared to zero.

realloc

Function type : void *realloc(void *ptr, size_t size);
Arguments : address of allocated memory, new memory size.
Return value : address of allocated memory. NULL if memory could not be allocated.
Function : changes the allocated memory size. The content is maintained.
Tip : Note that the memory address may be changed.

free

Function type : void free(void *p);
Argument : address of allocated memory
Function : Release dynamically allocated memory.

abs

Function : int abs(int n);
Arguments : number
Returns : absolute value of a number
Function : Obtain absolute values.

labs

Function : find the absolute value;
Arguments : number
Returns : absolute value of a number
Function : Obtain absolute values.

atof

Function type : double atof(const char *s);
Arguments : string containing a number
Return value : Value after conversion. 0 if conversion is not possible.
Function : Converts a string containing digits to a real number.

atoi

Function type : int atoi(const char *s);
Arguments : strings containing digits.
Return value : Value after conversion. 0 if conversion is not possible.
Function : Converts a string containing digits to an integer value.

atol

Function type : long atol(const char *s);
Arguments : strings containing digits.
Return value : Value after conversion. 0 if conversion is not possible.
Function : Converts a string containing digits to an integer value.

strtod

Function type : double strtod(const char *s, char **endptr);
Arguments : string containing digits, address of end position
Return value : Value after conversion. 0 if conversion is not possible.
Function : Converts a string containing digits to a real number.

strtol

Function type : long strtol(const char *s, char **endptr, int base);
Arguments : string containing a number, address of the end position, base of the number (binary or hexadecimal)
Return value : Value after conversion. 0 if conversion is not possible.
Function : Converts a string containing digits to an integer value.

strtoul

Function type : unsigned long strtoul(const char *s, char **endptr, int base);
Arguments : string containing a number, address of the end position, base of the number (binary or hexadecimal)
Return value : Value after conversion. 0 if conversion is not possible.
Function : Converts a string containing digits to an unsigned integer value.

div

Function type : div_t div(int num, int denom);
Arguments : number to be divided, number to be divided.
Return value : result of division.
Function : Calculates the quotient and the remainder at the same time.
Structure : div_t structure int quot quot quotient, int rem remainder
Tip: It is recommended to use the operator / or % instead of this function.

ldiv

Function type : ldiv_t ldiv(long num, long denom);
Arguments : number to be divided, number to be divided.
Return value : Result of division.
Function : Calculate the quotient and remainder at the same time.
Structure : ldiv_t structure long quot quotient, long rem remainder.
Tip: It is recommended to use the operator / or % instead of this function.

rand

Function type : int rand(void);
Return value : Random value. The range depends on the processor.
Function : Obtain a random number.
Usage : #define RANDOM(MIN,MAX) ((MIN)+(int)(rand()/(float)RAND_MAX*((MAX)-(MIN)+1)))
to obtain a random number between min and max.

srand

Function type : void srand(unsigned int seed);
Argument : Initial value of a random number series.
Function : gives the initial value of a random number series.
Usage : srand((unsigned int)time(0)); is standard.

exit

Function : void exit(int n);
Arguments : Exit code. Generally, EXIT_SUCCESS means normal exit, and EXIT_FAILURE means abnormal exit.
Function: Exits the program.

abort

Function type : void abort(void);
Aborts the program.
Supplemental: This is used to terminate the program when an error occurs.

atexit

Function type : int atexit(void (*func)(void));
Argument : function address
Return value : 0 in case of success, non-zero in case of failure.
Function : Register a function to be executed at the end of a program.

getenv

Function type : char *getenv(const char *name);
Arguments : name
Returns: First address of the string containing the value. NULL if not found.
Function : Obtain environment variables.

bsearch

Function type : void *bsearch(const void *key, const void *base,size_t nmemb,size_t size, int (*compar)(const void *x, const void *y));
Arguments : value to be searched for, array head, number of elements to be searched for, size of one element, address of comparison function
Return value : Address of the found element. NULL if not found.
Function : Performs a binary search. Data must be aligned in ascending order.
Comparison : The comparison function must return positive if x > y, 0 if x = y, and negative if x < y.

qsort

Function type : void qsort(void *base, size_t nel, size_t width,int(*compar)(const void *x, const void *y));
Arguments : array head, number of elements to be sorted, size of one element, address of comparison function
Function : Arrays are sorted in ascending order. Often uses quick sort.
Comparison : The comparison function should return positive if x > y, 0 if x = y, and negative if x < y.

system

Function type : int system(const char *string);
Argument : command string.
Return value : command dependent on the processing system. Returns -1 if the command could not be executed.
Function : executes a command provided by the processor.
Tip: Of course, commands are incompatible with different processors.
: If NULL is specified, 0 is returned in the environment where the command is not available.

text processing

A set of functions to handle a single one-byte character.
It is most often realized as a macro.

isalpha

Function type : int isalpha(int c);
Arguments : character
Returns: non-zero if the character is alphabetic, zero if different.
Function : checks if a character is alphabetic or not.

isupper

Function : int isupper(int c);
Arguments : character
Returns: non-zero if the character is an uppercase alphabetical letter, zero if the character is different.
Returns 0 if the character is not uppercase.

islower

Function : int islower(int c);
Arguments : character
Returns: non-zero if the character is a lowercase letter, zero if the character is not a lowercase letter.
Function : checks whether a character is lower case or not.

isdigit

Function : int isdigit(int c);
Arguments : character
Returns: non-zero if the character is a number, zero if the character is different.
Returns 0 if the character is different from a digit.

isspace

Function : int isspace(int c);
Arguments : character
Returns: non-zero if the character is a space character, zero if the character is different.
Returns 0 if the character is different from a whitespace character.

isalnum

Function : int isalnum(int c);
Arguments : character
Returns: non-zero if the character is alphabetic or numeric, zero if different.
Function : determines if a character is alphabetic or numeric.

iscntrl

Function : int iscntrl(int c);
Arguments : character
Returns: Non-zero if the character is a control character, zero if not.
Function : determines if the character is a control character or not.

isgraph

Function : int isgraph(int c);
Arguments : character
Returns: non-zero if the character is a printable character other than space, zero if different.
Function : Checks if a character is a printable character other than a space.

isprint

Function type : int isprint(int c);
Arguments : character
Returns: non-zero if the character is a printable character, zero if not.
Function : Checks if a character is a printable character or not.

ispunct

Function : int ispunct(int c);
Arguments : character
Returns: non-zero if the character is a delimiter, zero if the character is not.
Function : determines if a character is a delimiter.

isxdigit

Function : int isxdigit(int c);
Arguments : character
Returns: non-zero if the character is a hexadecimal character, zero if the character is different.
Returns 0 if the character is not a hexadecimal character.

string processing

A set of functions mainly for string processing.
Many functions can be shared with general-purpose memory processing.
Note that half-width characters are used as the standard, so be careful when processing full-width characters.

strcpy

Function type : char *strcpy(char *s, const char *t);
Arguments : character array, string
Return value : Argument character array is returned as it is.
Function : Copies a string to a character array. Used to assign strings.

strncpy

Function type : char *strncpy(char *s, const char *t, size_t n);
Arguments : character array, string, max copied characters
Return value : The character array of the argument is returned as it is.
Function : Copies the specified number of characters to the character array.
Note : If the number of characters is large, no null character is appended.
Be sure to add the null character as s = '\0';.

strcat

Function type : char *strcat(char *s, const char *t);
Arguments : character array, string
Return value : Argument character array is returned as it is.
Function: Join a string to the back of a character array.

strncat

Function type : char *strncat(char *s, const char *t, size_t n);
Arguments : character array, string, max concatenated characters
Return value : The character array of the argument is returned as it is.
Function : concatenates the specified number of characters after the character array.

strlen

Function type : size_t strlen(const char *s);
Arguments : string
Returns: Length of string. Null characters are not included.
Function : Returns the length of a string.

strcmp

Function type : int strcmp(const char *s, const char *t);
Arguments : string1, string2
Return value : Positive when string1 is larger, 0 when the same, negative when string2 is larger.
Function : Compares string1 and string2.

strncmp

Function type : int strncmp(const char *s, const char *t, size_t n);
Arguments : string1, string2, number of characters compared
Return value : Positive when string1 is greater than string1, 0 when they are the same, negative when string2 is greater than string2.
Function : Compares strings with the specified number of characters.

strchr

Function type : char *strchr(const char *s, int c);
Arguments : string, character
Returns : address of the found position, or NULL if not found.
Function : Searches for a character from the beginning of a string.

strrchr

Function type : char *strrchr(const char *s, int c);
Arguments : string, character
Returns : address of the found position, or NULL if not found.
Function : searches for a character from the back of a string.

strcspn

Function type : size_t strcspn(const char *s, const char *t);
Arguments : target string, search string
Returns: Number of characters to the found position.
Function : searches for characters in the target string that are included in the search string.

strspn

Function type : size_t strspn(const char *s, const char *t);
Arguments : target string, search string
Returns: Number of characters up to the missing position.
Function : searches for characters in the target string that are not included in the search string.

strpbrk

Function type : char *strpbrk(const char *s, const char *t);
Arguments : target string, search string
Returns: pointer to the first character found, or NULL if not found.
Function : searches for characters contained in the search string from the beginning of the target string.

strstr

Function type : char *strstr(const char *s, const char *t);
Arguments : target string, search string
Returns: pointer to the position found, or NULL if not found.
Function: searches for a search string from a target string.

strtok

Function type : char *strtok(char *s, const char *t);
Arguments : character array, delimited string
Returns: Pointer to the separated words. NULL if not found.
Function : Separates a character array at the position where a character in the delimited string exists.
If the character array is NULL, the next word can be obtained.

strerror

Function type : char *strerror(int n);
Argument : error number
Returns: An array containing error messages. Empty string if there is no corresponding error.
Function : Obtain error messages.
Note: Do not rewrite the contents of the acquired array.

memcpy

Function type : void *memcpy(void *dest, const void *source, size_t count);
Arguments : destination, source, copy size
Returns the destination of the argument
Function : Copy memory contents. If the copy area overlaps, it does not work.

memmove

Function type : void *memmove(void *dest, const void *source, size_t count);
Arguments : destination, source, copy size
Returns the destination of the argument
Function : Copy memory contents. It does not matter if the copied area overlaps.
Tip : Although the name "move" is used, it is not a move.

memset

Function type : void *memset(void *addr, int byte, size_t count);
Arguments : array, number, assigned size
Return value : Array of arguments is returned as is.
Function : Assign numerical values to all elements of the specified size of memory contents. Can also be used for characters.

memcmp

Function type : int memcmp(const void *addr1, const void *addr2, size_t n);
Arguments : array1, array2, comparison size
Return value : Positive when array 1 is larger, 0 when they are the same, negative when array 2 is larger.
Function : Compare two memory arrays. String comparison is also possible.

memchr

Function type : void *memchr(const void *addr, int byte, size_t count);
Arguments : array, 1 byte number, size to search
Return value : address of the found position, or NULL if not found.
Function : searches for a number in memory; can also be used for single-character search.

mathematical function

A set of basic mathematical functions.
Note that angles are expressed in radians.
The conversion from degrees to radians is as follows
radian = (degree * 3.14159 / 180)

fabs

Function type : double fabs(double x);
Arguments : real number
Return value : absolute value
Function : Calculates absolute values.

sqrt

Function type : double sqrt(double x);
Arguments : any real number
Return value : square root
Function: compute square roots

pow

Function type : double pow(double x, double y);
Arguments : value to be multiplied, exponent
Return value : x multiplied by y
Function : Computes the cumulative power.

fmod

Function type : double fmod(double x, double y);
Arguments : number to be divided, number to divide
Return value : remainder
Function: compute the remainder of a real number.

sin

Function type : double sin(double x);
Arguments : angle in radians
Returns: sine value
Function: compute the sine

cos

Function type : double cos(double x);
Arguments : angle in radians
Return value : Cosine value
Function: Calculates the cosine

tan

Function type : double tan(double x);
Arguments : angle in radians
Return value : Tangent value
Function: Calculates a tangent

acos

Function type : double acos(double x);
Arguments : value of cosine
Returns : arc-cosine (radian) value
Function: Calculates the arc cosine

asin

Function type : double asin(double x);
Arguments : sine value
Returns: Arc sine (radian) value
Function: Calculates the arc sine

atan

Function type : double atan(double x);
Arguments : tangent values
Returns : arc-tangent (radian) value
Function : Calculates the arc tangent.
The value is in the range π / 2.

atan2

Function type : double atan2(double y, double x);
Arguments : vertical value, horizontal value
Returns: arc-tangent (radian) value
Function : Calculates the arc tangent.
The value is in the range of π. It can be calculated even if the argument x is 0.

sinh

Function type : double sinh(double x);
Arguments : angle in radians
Return value : Hyperbolic sine value
Function : Calculates a hyperbolic sine value.
Same as (exp(x) - exp(-x)) / 2.

COSH

Function type : double cosh(double x);
Arguments : angle in radians
Return value : Hyperbolic cosine value
Function : Calculates the hyperbolic cosine value.
Same as (exp(x) + exp(-x)) / 2.

TANH

Function type : double tanh(double x);
Arguments : angle in radians
Return value : Hyperbolic tangent value
Function : Calculates hyperbolic tangent values
Same as sinh(x) / cosh(x).

ceil

Function type : double ceil(double x);
Argument : any real number
Returns an integer greater than or equal to the input value
Function: rounds a real number to an integer value.

floor

Function : double floor(double x);
Arguments : any real number
Returns an integer less than or equal to the input value.
Function: rounds a real number to an integer value.

exp

Function : double exp(double x);
Arguments : real number
Return value : x power of the base of the natural logarithm
Function : Computes an exponent.

log

Function type : double log(double x);
Arguments : any real number
Return value : natural logarithm
Function : Finds the natural logarithm.

log10

Function type : double log10(double x);
Arguments : any real number
Return value : Ordinary logarithm
Function: compute the ordinary logarithm.

modf

Function type : double modf(double x, double *ip);
Arguments : any real number, the value of the integer part to be returned
Return value : value of decimal part
Function: Separates a real number into integer and decimal parts.

frexp

Function type : double frexp(double x, int *p);
Arguments : any real number, the value of the exponent part to be returned
Return value : value of the mantissa portion
Function: Calculates the exponential and mantissa parts of a floating-point value

ldexp

Function type : double ldexp(double x, int p);
Arguments : exponential, exponential part
Returns: Composite floating-point value
Function : Obtains a floating-point value from its mantissa and exponent part.

Hours.

A set of functions for handling time. These functions are based on the UNIX convention to use
The time is based on January 1, 1970, 0:00:00: 00 in Universal Coordinated Time (UTC).
From now on, January 1, 1970, 0:0:0 will be used as the base time in the description.

time

Function type : time_t time(time_t *t);
Argument : address of a variable that stores time
Returns: Number of seconds elapsed from base time
Function : Returns the current time in seconds elapsed from the base time.
Tip: You can call this function with NULL argument to get only the return value. Units other than seconds may be used in some environments.

clock

Function type : clock_t clock(void);
Arguments : None
Return value : Process time used
Function : Returns the process time used by the program.
Tip: You can get the value in seconds by setting clock() / CLOCKS_PER_SEC.
Note: In a multithreaded environment, this does not match the elapsed time.

difftime

Function type : double difftime(time_t t1, time_t t2);
Arguments : number of elapsed seconds from the base time 1, number of elapsed seconds from the base time 2
Return value : Difference of two elapsed seconds
Function : Depending on the environment in which time subtraction is performed, units other than seconds may be used.

localtime

Function type : struct tm *localtime(const time_t *t);
Argument : number of seconds elapsed from the base time
Return value : Structure converted from seconds to domestic time information
Function : Converts the number of seconds elapsed from the base time to domestic time.
Note : Since the return value is a memory area shared by the entire system, it must be copied to a separately declared structure.

gmtime

Function type : struct tm *gmtime(const time_t *t);
Argument : Number of seconds elapsed from the base time
Returns: Structure with seconds converted to international time information
Function : Converts the number of seconds elapsed from the base time to international time.
Note : Since the return value is a memory area shared by the entire system, it must be copied to a separately declared structure.

asctime

Function type : char *asctime(const struct tm *tm);
Argument : Structure that stores the time
Returns: First address of the string converted to the time
Function : Converts the time to a string such as Wed Feb 17 20:14:04 1988.
Note : Since the return value is a memory area shared by the entire system, it must be copied to a separately declared structure.

ctime

Function type : char *ctime(const time_t *t);
Argument : Number of seconds elapsed from the base time
Returns: First address of the string converted to the time
Converts the time to a string such as Wed Feb 17 20:14:04 1988.
Note : Since the return value is a memory area shared by the entire system, it must be copied to a separately declared structure.

strftime

Function type : size_t strftime(char *s, size_t smax, const char *fmt, const struct tm *tp);
Arguments : a character array, the size of the character array, a string specifying the time format, a structure storing the time
Return value : Number of characters written to the array. 0 in case of failure.
Function : Converts the time into a string according to the specified format.

control

A group of functions that primarily control the program.
Note that each of these has a different header file.

Functions requiring <assert.h

assert

Function type : void assert(int expression);
Argument : value of variable to be asserted
Return value : None
Function : Perform diagnostics for debugging.
Tip : If the value set to the argument is 0, the running source file name and line number are printed and the program terminates acutely. if the NDEBUG constant is defined, it is removed at the compilation stage.

Functions requiring <signal.h

raise

Function type : int raise(int sig);
Argument : signal value to send
Return value : 0 on success, non-zero on failure.
Function : Send a signal to the program.

signal

Function type : void (*signal(int sig, void (*handler)())));
Arguments : signal value to be set, address of the function that processes the signal
Return value : address of the previously set function, or SIG_ERR in case of failure.
Function : Sets the function that processes the signal.

Functions requiring <setjmp.h

setjmp

Function type : int setjmp(jmp_buf env);
Argument : address of a variable that stores the jump destination state
Return value : 0 when first called, or the value when returned in longjmp.
Function : save the state in preparation for the longjmp function.
Caution : This is a heinous function that messes up the flow of the program and should not be used unless there is a good reason to do so.

longjmp

Function type : void longjmp(jmp_buf env, int val);
Arguments : address of a variable that stores the state to jump to, optional return value
Return value : None
Function: Perform wide-area jumps across functions
Caution : This is a heinous function that can mess up the flow of your program, and should not be used unless you have a good reason to do so.

About this Site

The C language (bitter C), which is learned by suffering, is
This is the definitive C language introductory site.
It systematically explains the basic functions of the C language and
It is as complete as or more complete than any book on the market.

SpineViewer

Response Time Checker

Mouse cleaning time

Mouse cleaning time