※スタイルシート未対応ブラウザではレイアウトを正確に再現できません。
 < The returning   contents  advance >   
                   <戻 進> Color magazine monochrome light and shade   font predetermined, Gothic Ming-style type longhand   size Konaka large   standard  


  Standard library function list   

  1. Clause 1: I/O < stdio.h >
  2. Clause 2: General purpose < stdlib.h >
  3. Clause 3: Character manipulation < ctype.h >
  4. Clause 4: String manipulation < string.h >
  5. Clause 5: Mathematics function < math.h >
  6. Clause 6: Time < time.h >
  7. ..clause 7..: Control

[1] I/O < stdio.h >

It is a function that chiefly handles the file.
In C language, peripherals other than the disk can also treat the file.
Moreover, these can be treated as a regulated file pointer.

[   Regulated file pointer   ]
Stdin standard input(It is usually a keyboard. )
Stdout standard output(It is usually a display. )
Stderr standard error output(It is usually a display. )
The user can change these by the method such as redirecting.
Might it be related to another equipment according to the environment, and it be invalid.
[  fopen  ]
Function type: FILE *fopen(const char *filename, const char *mode);
Argument  : File name and mode character string
Return value: Open file pointer. NULL when failing.
The function  : Open the file.
Mode: R reading, new w, and a addition. b addition, and it is binary and + addition and inputting and outputting two-way.
[  fclose  ]
Function type: Int fclose(FILE *fp);
Argument  : File pointer
The return value: When 0 and failing, succeeding is EOF.
The function  : Shut the file.
[  fgetc  ]
Function type: Int fgetc(FILE *fp);
Argument  : File pointer
Return value: Read character. EOF when having failed or ending and reaching.
The function  : Read one character from the file.
[  getc  ]
The function  : It is quite same as fgetc.
Attention  : The side effect is noted because it might be a macro.
[  fgets  ]
Function type: Char *fgets(char *s, int n, FILE *fp);
Argument  : Buffer, size of buffer, and file pointer that stores character string
Return value: Buffer specified by argument. NULL when having failed or ending and reaching.
The function  : Read one line from the file. Contain changing line in the result.
[  fputc  ]
Function type: Int fputc(int c, FILE *fp);
Argument  : Character and file pointer
Return value: Output character. When failing, EOF.
The function  : Write one character in the file.
[  putc  ]
The function  : It is quite same as fputc.
Attention  : The side effect is noted because it might be a macro.
[  fputs  ]
Function type: Int fputs(const char *s, FILE *fp);
Argument  : Character string and file pointer
The return value: When true and failing, succeeding is EOF.
The function  : Write the character string in the file.
[  fread  ]
Function type: Size_t fread(void *ptr, size_t size, size_t nelem, FILE *fp);
Argument  : Size, number of items, and file pointer of buffer and one item that stores reading result
Return value: Read number of items. 0 when failing.
The function  : Read the item of the fixed-size from the file.
[  fwrite  ]
Function type: Size_t fwrite(const void *ptr, size_t size, size_t nelem, FILE *fp);
Argument  : Written size, number of items, and file pointer of buffer and one item
Return value: Written number of items. 0 when failing.
The function  : Write the item of the fixed-size in the file.
[  fprintf  ]
Function type: Int fprintf(FILE *fp, const char *format, ...);
Argument  : Character string with file pointer and format and variables of changeability piece
Return value: Number of output characters. When failing, a negative value.
The function  : Write the character string with the format in the file.
[  fscanf  ]
Function type: Int fscanf(FILE *fp, const char *format, ...);
Argument  : Buffer of file pointer, conversion specification character string, and changeability piece
Return value: Number that succeeds in conversion. -1 when failing.
The function  : Read the character string from the file and convert it into the specified form.
[  ftell  ]
Function type: Long ftell(FILE *fp);
Argument  : File pointer
Return value: Present file position.
The function  : Acquire the file position.
[  fseek  ]
Function type: Int fseek(FILE *fp, long offset, int ptrname);
Argument  : Number of movements of file pointer and file position and standards at file position
The return value: Excluding 0 when 0 and failing when succeeding.
The function  : Change the file position.
Position  : Present position and SEEK_END ends of SEEK_SET head and SEEK_CUR.
[  fgetpos  ]
Function type: Int fgetpos(FILE *fp, fpos_t *ptr);
Argument  : Pointer of variable that stores file pointer and file position
The return value: Excluding 0 when 0 and failing when succeeding.
The function  : Store a present file position.
[  fsetpos  ]
Function type: Int fsetpos(FILE *fp, const fpos_t *ptr);
Argument  : Pointer of variable that stores file pointer and file position
The return value: Excluding 0 when 0 and failing when succeeding.
The function  : Change the file position.
[  feof  ]
Function type: Int feof(FILE *fp);
Argument  : File pointer
Return value: Imitation when true and not reaching when ending and reaching.
The function  : Whether the file ends and it reached are examined.
[  ferror  ]
Function type: Int ferror(FILE *fp);
Argument  : File pointer
The return value: When true and not generated, it is bogus when the error generation is done.
The function  : Whether the error occurred in the file is examined.
[  clearerr  ]
Function type: Void clearerr(FILE *fp);
Argument  : File pointer
The function  : Recover at the error of the file.
[  fflush  ]
Function type: Int fflush(FILE *fp);
Argument  : File pointer
The return value: When 0 and failing, it is bogus when succeeding.
The function  : Compulsion output the output buffer.
Attention  : The input buffer can be cleared according to the compiler. However, it is evil ways.
[  freopen  ]
Function type: FILE *freopen(const char *filename, const char *mode, FILE *fp);
Argument  : File name, mode character string, and file pointer
Return value: File pointer specified by argument. NULL when failing.
Function  : Rediscount application of file pointer.
[  rename  ]
Function type: Int rename(const char *oldname, const char *newname);
Argument  : Present file name and new file name
The return value: Excluding 0 when 0 and failing when succeeding.
The function  : Change the name of the file.
[  remove  ]
Function type: Int remove(const char *filename);
Argument  : File name
The return value: Excluding 0 when 0 and failing when succeeding.
The function  : Delete the file.
[  getchar  ]
Function type: Int getchar(void);
Return value: Read character. EOF when failing.
The function  : Read one character from a standard input (keyboard).
[  putchar  ]
Function type: Int putchar(char c);
Argument  : Character
Return value: Output character. When failing, EOF.
The function  : Write one character in a standard output (display).
[  gets  ]
Function type: Char *gets(char *s);
Argument  : Buffer where read character string is stored
Return value: Buffer specified by argument. NULL when having failed or ending and reaching.
The function  : Read one line from a standard input (keyboard). Changing line is not included in the result.
Attention  : Do not use it because it causes overrunning (virus penetration) in the buffer.
[  puts  ]
Function type: Int puts(const char *s);
Argument  : Character string
The return value: Excluding 0 when 0 and failing when succeeding.
The function  : Write one line in a standard output (display). It changes line.
[  perror  ]
Function type: Void perror(const char *s);
Argument  : Displayed character string
The function  : Display the error that occurs with the specified character string immediately before.
[  printf  ]
Function type: Int printf(const char *format, ...);
Argument  : Character string with format and variable of changeability piece
Return value: Number of output characters. When failing, -1.
The function  : Write the character string with the format in a standard output (display).
[  scanf  ]
Function type: Int scanf(const char *format, ...);
Argument  : Buffer of conversion specification character string and changeability piece
Return value: Number that succeeds in conversion. -1 when failing.
The function  : Read the character string from a standard input (keyboard) and convert it into the specified form.
Attention  : Unexpected operation might be done when using it with other input functions.

It returns to contents.


[2] general purpose < stdlib.h >

Especially, group of general function not classified.
Memory relation, process relation, and conversion, etc.

[  malloc  ]
Function type: Void *malloc(size_t n);
Argument  : Secured memory size
Return value: Address of secured memory. NULL when it is not possible to secure it.
The function  : Secure the memory dynamically.
[  calloc  ]
Function type: Void *calloc(size_t int nelem, size_t elsize);
Argument  : Number of elements and size of one element
Return value: Address of secured memory. NULL when it is not possible to secure it.
The function  : Secure the memory dynamically. 0 clearing of the secured memory.
Attention  : Do not misunderstand it when the bug decreases because 0 clearing of it.
[  realloc  ]
Function type: Void *realloc(void *ptr, size_t size);
Argument  : Address of secured memory and new memory size.
Return value: Address of secured memory. NULL when it is not possible to secure it.
The function  : Change the secured memory size. Contents are maintained.
The supplementation  : It is noted that there is a possibility that the memory address is changed.
[  free  ]
Function type: Void free(void *p);
Argument  : Address of secured memory
The function  : Liberate the memory dynamically secured.
[  abs  ]
Function type: Int abs(int n);
Argument  : Numerical value
Return value: Absolute value of numerical value
The function  : Request the absolute value.
[  labs  ]
Function type: Long labs(long n);
Argument  : Numerical value
Return value: Absolute value of numerical value
The function  : Request the absolute value.
[  atof  ]
Function type: Double atof(const char *s);
Argument  : Character string including figure
Return value: Value after it converts it. 0 when it is not possible to convert it.
The function  : Convert the character string including the figure into the real number value.
[  atoi  ]
Function type: Int atoi(const char *s);
Argument  : Character string including figure
Return value: Value after it converts it. 0 when it is not possible to convert it.
The function  : Convert the character string including the figure into the integral value.
[  atol  ]
Function type: Long atol(const char *s);
Argument  : Character string including figure
Return value: Value after it converts it. 0 when it is not possible to convert it.
The function  : Convert the character string including the figure into the integral value.
[  strtod  ]
Function type: Double strtod(const char *s, char **endptr);
Argument  : Character string including figure and address at end position
Return value: Value after it converts it. 0 when it is not possible to convert it.
The function  : Convert the character string including the figure into the real number value.
[  strtol  ]
Function type: Long strtol(const char *s, char **endptr, int base);
Argument  : Character string including figure, address at end position, and cardinal number of numerical value(binary number and hexadecimal number)
Return value: Value after it converts it. 0 when it is not possible to convert it.
The function  : Convert the character string including the figure into the integral value.
[  strtoul  ]
Function type: Unsigned long strtoul(const char *s, char **endptr, int base);
Argument  : Character string including figure, address at end position, and cardinal number of numerical value(binary number and hexadecimal number)
Return value: Value after it converts it. 0 when it is not possible to convert it.
The function  : Convert the character string including the figure into [totono] numerical value without the sign.
[  div  ]
Function type: Div_t div(int num, int denom);
Argument  : Broken number and divided number.
Return value: Result of dividing calculation.
The function  : Calculate commerce and the remainder at the same time.
The structure: div_t structure ..int quot quotient.. ..int rem.. too much.
The supplementation  : The operator/% as soon as is recommended to be used from this function.
[  ldiv  ]
Function type: Ldiv_t ldiv(long num, long denom);
Argument  : Broken number and divided number.
Return value: Result of dividing calculation.
The function  : Calculate commerce and the remainder at the same time.
The structure: ldiv_t structure ..long quot quotient.. ..long rem.. too much.
The supplementation  : The operator/% as soon as is recommended to be used from this function.
[  rand  ]
Function type: Int rand(void);
Return value: Random value. The range depends on the processing system.
The function  : Obtain random numbers.
Directions :# define RANDOM(MIN,MAX)((MIN)+(int)(rand()/(float)RAND_MAX*((MAX)-(MIN)+1)))
        Then, min - The random numbers between max can be obtained.
[  srand  ]
Function type: Void srand(unsigned int seed);
Argument  : Initial value of random numbers system.
The function  : Give an initial value of the random numbers system.
Directions: Srand((unsigned int)time(0));However, it is standard.
[  exit  ]
Function type: Void exit(int n);
Argument  : Exit code. In general, As for EXIT_SUCCESS, the normal termination and EXIT_FAILURE terminate abnormally.
The function  : End the program.
[  abort  ]
Function type: Void abort(void);
The function  : Terminate the program abnormally.
The supplementation  : Use it to end when the error occurs.
[  atexit  ]
Function type: Int atexit(void (*func)(void));
Argument  : Address of function
The return value: Excluding 0 when 0 and failing when succeeding.
The function  : Register the function executed when the program ends.
[  getenv  ]
Function type: Char *getenv(const char *name);
Argument  : Name
Return value: Initial address of character string that stores value. NULL when not found.
The function  : Acquire the environment variable.
[  bsearch  ]
Function type: Const void *key and void *bsearch (const void *base
       size_t nmemb,size_t size, int (*compar)(const void *x, const void *y));
Argument  : Address of size of head of value which it looks for and array, numbers of searches, and one element and comparison functions
Return value: Address of found element. NULL when not found.
The function  : Search for two minutes. Data must line up in ascending order.
The comparison  : The comparison function is x > positive and x in case of y = 0 and x < in case of y Return negative for y.
[  qsort  ]
Function type: Void *base, size_t nel, and void qsort (size_t width
       int(*compar)(const void *x, const void *y));
Argument  : Address of size and comparison function of head, line number of arrays, and one element
The function  : It .. array.. lines up in ascending order. The quick sort is often used.
The comparison  : The comparison function is x > positive and x in case of y = 0 and x < in case of y Return negative for y.
[  system  ]
Function type: Int system(const char *string);
Argument  : Command statement [azaretsu].
Return value: Dependence for command of processing system. -1 when command cannot be executed.
The function  : Execute the command that the processing system is preparing.
The supplementation  : When the processing system is different it, the command is incompatible though it is natural.
      : Return 0 in the environment for which the command cannot be used when you specify NULL.

It returns to contents.


[3] character manipulation < ctype.h >

Function group that handles one-byte character one character.
Being achieved as a macro is most.

[  isalpha  ]
Function type: Int isalpha(int c);
Argument  : Character
The return value: If the character is an alphabet, it is 0 when differing excluding 0.
The function  : Judge whether the character is an alphabet.
[  isupper  ]
Function type: Int isupper(int c);
Argument  : Character
The return value: If the character is an English capital letter, it is 0 when differing excluding 0.
The function  : Judge whether the character is an English capital letter.
[  islower  ]
Function type: Int islower(int c);
Argument  : Character
The return value: If the character is an English small letter, it is 0 when differing excluding 0.
The function  : Judge whether the character is an English small letter.
[  isdigit  ]
Function type: Int isdigit(int c);
Argument  : Character
The return value: If the character is a figure, it is 0 when differing excluding 0.
The function  : Judge whether the character is a figure.
[  isspace  ]
Function type: Int isspace(int c);
Argument  : Character
The return value: If the character is a null character, it is 0 when differing excluding 0.
The function  : Judge whether the character is a null character.
[  isalnum  ]
Function type: Int isalnum(int c);
Argument  : Character
The return value: If the character is an alphabet or a figure, it is 0 when differing excluding 0.
The function  : Judge whether the character is an alphabet or a figure.
[  iscntrl  ]
Function type: Int iscntrl(int c);
Argument  : Character
The return value: If the character is a control character, it is 0 when differing excluding 0.
The function  : The character is a control character or judge.
[  isgraph  ]
Function type: Int isgraph(int c);
Argument  : Character
The return value: If it is a character, it is 0 on which they can be the prints of the character other than space when differing excluding 0.
The function  : Judge whether it is a character on which they can be the prints of the character other than space.
[  isprint  ]
Function type: Int isprint(int c);
Argument  : Character
The return value: If it is a character on which the character can be printed, it is 0 when differing excluding 0.
The function  : Judge whether it is a character on which the character can be printed.
[  ispunct  ]
Function type: Int ispunct(int c);
Argument  : Character
The return value: If the character is a delimiter, it is 0 when differing excluding 0.
The function  : Judge whether the character is a delimiter.
[  isxdigit  ]
Function type: Int isxdigit(int c);
Argument  : Character
The return value: If the character is a character for the hexadecimal number, it is 0 when differing excluding 0.
The function  : The character is a character for the hexadecimal number or judge.

It returns to contents.


[4] string manipulation < string.h >

Function group that chiefly processes character string.
The function that can be shared with the general-purpose memory processing is abundant.
Note the processing of the em-size character because it is based on the one-byte character.

[  strcpy  ]
Function type: Char *strcpy(char *s, const char *t);
Argument  : Character array and character string
The return value: Return the character array of the argument as it is.
The function  : Copy the character string onto the character array. Use it to substitute the character string.
[  strncpy  ]
Function type: Char *strncpy(char *s, const char *t, size_t n);
Argument  : Character array, character string, and number of maximum copy characters
The return value: Return the character array of the argument as it is.
The function  : Only the number of specified characters copies the character string onto the character array.
Attention  : Because it doesn't add the null character when there are a lot of numbers of characters
        S[n] without fail '\0 =';Make and add the null character.
[  strcat  ]
Function type: Char *strcat(char *s, const char *t);
Argument  : Character array and character string
The return value: Return the character array of the argument as it is.
The function  : The character string must tie behind the character array.
[  strncat  ]
Function type: Char *strncat(char *s, const char *t, size_t n);
Argument  : Character array, character string, and the maximum copulative sentence number of strokes
The return value: Return the character array of the argument as it is.
The function  : Only the number of specified characters ties the character string behind the character array.
[  strlen  ]
Function type: Size_t strlen(const char *s);
Argument  : Character string
Return value: Length of character string. Do not include the null character.
The function  : Return the length of the character string.
[  strcmp  ]
Function type: Int strcmp(const char *s, const char *t);
Argument  : Character string 1 and character string 2
The return value: It is negative when 0 and character string 2 are large when it is positive and the same when character string 1 is large.
The function  : Compare character string 1 and character string 2.
[  strncmp  ]
Function type: Int strncmp(const char *s, const char *t, size_t n);
Argument  : Number of relation characters of character string 1 and character string 2
The return value: It is negative when 0 and character string 2 are large when it is positive and the same when character string 1 is large.
The function  : Only the number of specified characters compares character strings.
[  strchr  ]
Function type: Char *strchr(const char *s, int c);
Argument  : Character string and character
Return value: NULL when not found address at found position.
The function  : Retrieve the character of the head of a string.
[  strrchr  ]
Function type: Char *strrchr(const char *s, int c);
Argument  : Character string and character
Return value: NULL when not found address at found position.
The function  : Retrieve the character from the back of the character string.
[  strcspn  ]
Function type: Size_t strcspn(const char *s, const char *t);
Argument  : Object character string and retrieval character string
Return value: Number of characters to found positions.
The function  : Retrieve the character included in the retrieval character string from among the object character string.
[  strspn  ]
Function type: Size_t strspn(const char *s, const char *t);
Argument  : Object character string and retrieval character string
Return value: Number of characters to positions not found.
The function  : Retrieve the character not included in the retrieval character string from among the object character string.
[  strpbrk  ]
Function type: Char *strpbrk(const char *s, const char *t);
Argument  : Object character string and retrieval character string
Return value: NULL when not found pointer to the first found character.
The function  : Retrieve the character included from the head of the object character string to the retrieval character string.
[  strstr  ]
Function type: Char *strstr(const char *s, const char *t);
Argument  : Object character string and retrieval character string
Return value: NULL when not found pointer to found position.
The function  : Retrieve the retrieval character string of the object character string.
[  strtok  ]
Function type: Char *strtok(char *s, const char *t);
Argument  : Character array and delimiter row
Return value: Pointer to delimited word. NULL when not found.
The function  : Delimit the character array at the position with the character included in the delimiter row.
        The following word can be acquired by making the character array NULL and calling it.
[  strerror  ]
Function type: Char *strerror(int n);
Argument  : Error number
Return value: Array where error message is stored. The null character string when there is no corresponding error.
The function  : Acquire the error message.
Attention  : Contents of the acquired array do not rewrite it.
[  memcpy  ]
Function type: Void *memcpy(void *dest, const void *source, size_t count);
Argument  : Copy origin and size of copy at copy destination
The return value: Return the copy destination of the argument.
The function  : Copy the content of the memory. It doesn't go well when the copy area comes in succession.
[  memmove  ]
Function type: Void *memmove(void *dest, const void *source, size_t count);
Argument  : Copy origin and size of copy at copy destination
The return value: Return the copy destination of the argument.
The function  : Copy the content of the memory. Even if the copy area comes in succession, it is unquestionable.
The supplementation  : It is noted that it is not a movement though it is a name of move.
[  memset  ]
Function type: Void *memset(void *addr, int byte, size_t count);
Argument  : Array, numerical value, and substitution size
The return value: Return the argument vector as it is.
The function  : Substitute the numerical value for all elements for a specified size of the content of the memory. It is possible to use it also for the character.
[  memcmp  ]
Function type: Int memcmp(const void *addr1, const void *addr2, size_t n);
Argument  : Array 1, array 2, and comparison size
The return value: It is negative when 0 and array 2 are large when it is positive and the same when array 1 is large.
The function  : Compare the memories mutually. The string comparison can be done.
[  memchr  ]
Function type: Void *memchr(const void *addr, int byte, size_t count);
Argument  : Numerical value in array and one byte and retrieved sizes
Return value: NULL when not found address at found position.
The function  : Retrieve the numerical value in the memory. It is possible to use it also for one character retrieval.

It returns to contents.


[5] mathematics function < math.h >

Basic mathematics function group.
Note that the angle is shown by the radian.
Conversion from times to the radian is as follows.

Radian =(times * 3.14159/ 180)

[  fabs  ]
Function type: Double fabs(double x);
Argument  : Real number value
Return value: Absolute value
The function  : Calculate the absolute value.
[  sqrt  ]
Function type: Double sqrt(double x);
Argument  : Arbitrary real number value
Return value: Square root
The function  : Calculate the square root.
[  pow  ]
Function type: Double pow(double x, double y);
Argument  : Involved value and index
The return value: X The value in which y is multiplied.
The function  : Request the involution.
[  fmod  ]
Function type: Double fmod(double x, double y);
Argument  : Broken number and divided number
The return value: Too much
The function  : Request the remainder of the real number value.
[  sin  ]
Function type: Double sin(double x);
Argument  : Angle of each radian
Return value: Signature value
The function  : Calculate the signature.
[  cos  ]
Function type: Double cos(double x);
Argument  : Angle of each radian
Return value: Cosine value
The function  : Calculate the cosine.
[  tan  ]
Function type: Double tan(double x);
Argument  : Angle of each radian
Return value: Tangent value
The function  : Calculate the tangent.
[  acos  ]
Function type: Double acos(double x);
Argument  : Value of cosine
Return value: Arc cosine (radian) value
The function  : Calculate the arc cosine.
[  asin  ]
Function type: Double asin(double x);
Argument  : Value of signature
Return value: Arc signature (radian) value
The function  : Calculate the arc signature.
[  atan  ]
Function type: Double atan(double x);
Argument  : Value of tangent
Return value: Arc tangent (radian) value
The function  : Calculate the arc tangent.
        The value It becomes the range of π÷2.
[  atan2  ]
Function type: Double atan2(double y, double x);
Argument  : Value of length and value of side
Return value: Arc tangent (radian) value
The function  : Calculate the arc tangent.
        The value It becomes the range of π, and argument x is computable by even 0.
[  sinh  ]
Function type: Double sinh(double x);
Argument  : Angle of each radian
Return value: [Haipaborikkusain] value
The function  : Calculate the [haipaborikkusain] value.
        (exp(x) - exp(-x))/ It is the same as two.
[  cosh  ]
Function type: Double cosh(double x);
Argument  : Angle of each radian
Return value: [Haipaborikkukosain] value
The function  : Calculate the [haipaborikkukosain] value.
        (exp(x) + exp(-x))/ It is the same as two.
[  tanh  ]
Function type: Double tanh(double x);
Argument  : Angle of each radian
Return value: [Haipaborikkutanjento] value
The function  : Calculate the [haipaborikkutanjento] value.
        Sinh(x)/ It is the same as cosh(x).
[  ceil  ]
Function type: Double ceil(double x);
Argument  : Arbitrary real number value
Return value: Integral value more than input value
The function  : Round the real number value to the integral value.
[  floor  ]
Function type: Double floor(double x);
Argument  : Arbitrary real number value
Return value: Integral value below input value
The function  : Round the real number value to the integral value.
[  exp  ]
Function type: Double exp(double x);
Argument  : Real number value
Return value: x multiplication in base of natural logarithm
The function  : Calculate the index.
[  log  ]
Function type: Double log(double x);
Argument  : Arbitrary real number value
Return value: Natural logarithm value
The function  : Request the naturalized logarithm.
[  log10  ]
Function type: Double log10(double x);
Argument  : Arbitrary real number value
Return value: Common logarithm value
The function  : Request the common logarithm.
[  modf  ]
Function type: Double modf(double x, double *ip);
Argument  : Value of arbitrary real number value and returned integer part part
Return value: Value of fractional portion
The function  : Divide the real number value into the integer part and the fractional portion.
[  frexp  ]
Function type: Double frexp(double x, int *p);
Argument  : Value of arbitrary real number value and returned index part
Return value: Value for mantissa
The function  : Request the exponent part and the mantissa of the floating point value.
[  ldexp  ]
Function type: Double ldexp(double x, int p);
Argument  : Mantissa and exponent part
Return value: Synthetic floating point value
The function  : Request the floating point value from the mantissa and the exponent part.

It returns to contents.


[6] time < time.h >

Function group that handles time. These functions : from the custom of UNIX.
World agreement time (UTC) It is based on 0:0:0, January 1, 1970.
In the explanation in the future 0:0:0, January 1, 1970 is written as standard time.

[  time  ]
Function type: Time_t time(time_t *t);
Argument  : Address of variable that stores time
Return value: Passage second number from standard time
The function  : Return present time by passage second number from standard time.
The supplementation  : The argument Only the return value can be acquired by calling it with NULL.
      :Units other than the second might be used according to the environment.
[  clock  ]
Function type: Clock_t clock(void);
The argument  : It is not.
Return value: Use process time
The function  : Return the process time that the program used.
The supplementation  : clock()/ The value every second is obtained by assuming CLOCKS_PER_SEC.
Attention  : It doesn't agree to the passage time under the multithreaded environment.
[  difftime  ]
Function type: Double difftime(time_t t1, time_t t2);
Argument  : Passage second several 1 from standard time and passage second several 2 from standard time
Return value: Differences of passage seconds of two number
The function  : Subtract time.
      :Units other than the second might be used according to the environment.
[  localtime  ]
Function type: Struct tm *localtime(const time_t *t);
Argument  : Passage second number from standard time
Return value: Structure that converts number of seconds into domestic time information
The function  : Convert passage second number from standard time at domestic time.
Attention  : Because the return value is a memory area shared by the entire system
        It is necessary to copy it onto the structure separately declared.
[  gmtime  ]
Function type: Struct tm *gmtime(const time_t *t);
Argument  : Passage second number from standard time
Return value: Structure that converts number of seconds into international time information
The function  : Convert passage second number from standard time at international time.
Attention  : Because the return value is a memory area shared by the entire system
        It is necessary to copy it onto the structure separately declared.
[  asctime  ]
Function type: Char *asctime(const struct tm *tm);
Argument  : Structure that stored time
Return value: Initial address of character string that converts time
   Convert it into the character string like The function: Time At Wed Feb 17 20:14:04 1988.
Attention  : Because the return value is a memory area shared by the entire system
        It is necessary to copy it onto the structure separately declared.
[  ctime  ]
Function type: Char *ctime(const time_t *t);
Argument  : Passage second number from standard time
Return value: Initial address of character string that converts time
   Convert it into the character string like The function: Time At Wed Feb 17 20:14:04 1988.
Attention  : Because the return value is a memory area shared by the entire system
        It is necessary to copy it onto the structure separately declared.
[  strftime  ]
Function type: Size_t strftime(char *s, size_t smax, const char *fmt, const struct tm *tp);
Argument  : Structure that stored size of character array and character array, format specification character strings of time, and time
Return value: Number of characters written in array. 0 when failing.
The function  : Convert it into the character string according to the format for which time is specified.

It returns to contents.


[7] Control

Function group that chiefly controls program.
As for these, the header file is different respectively.

Function group that needs < assert.h >
[  assert  ]
Function type: Void assert(int expression);
Argument  : Diagnosed value of a variable
The return value: It is not.
Function..debugging..diagnose.  
The supplementation  : When the value set to the argument is 0
        The source file name and the line number under execution must be displayed and acute must end.
        When the NDEBUG constant is defined, it is removed at the stage of the compilation.

Function group that needs < signal.h >
[  raise  ]
Function type: Int raise(int sig);
Argument  : Transmitted signal value
The return value: Excluding 0 when 0 and failing when succeeding.
The function  : Transmit the signal to the program.
[  signal  ]
Function type: Void (*signal(int sig, void (*handler)())) ();
Argument  : Address of function that processes set signal value and signal
Return value: SIG_ERR when address of function that had been set before and failing.
The function  : Set the function that processes the signal.

Function group that needs < setjmp.h >
[  setjmp  ]
Function type: Int setjmp(jmp_buf env);
Argument  : Address of variable that stores state at jump destination
The return value: When returning with 0 and longjmp when called first, the value.
The function  : Preserve the state in preparation for the longjmp function.
Attention  : It is a brutal function that makes the flow of the program [guchagucha].
        Do not use it as long as it is not great circumstances either.
[  longjmp  ]
Function type: Void longjmp(jmp_buf env, int val);
Argument  : Address of variable where state at jump destination is stored and arbitrary return value
The return value: It is not.
The function  : The large area where it steps over between functions jumps.
Attention  : It is a brutal function that makes the flow of the program [guchagucha].
        Do not use it as long as it is not great circumstances either.

It returns to contents.


< -  Advanced -> to the returning following. the first  that returns