Document Sample
c_ref Powered By Docstoc
					      C Reference Card (ANSI)                                           Constants                                                           Flow of Control
                                                                        long (suffix)                                 L or l                  statement terminator                        ;
Program Structure/Functions                                             float (suffix)                                 F or f                  block delimeters                            { }
type fnc(type 1 ,. . . )               function declarations            exponential form                            e                       exit from switch, while, do, for            break
type name                              external variable declarations   octal (prefix zero)                          0                       next iteration of while, do, for            continue
main() {                               main routine                     hexadecimal (prefix zero-ex)                 0x or 0X                go to                                       goto label
  declarations                         local variable declarations      character constant (char, octal, hex)     'a', '\ooo', '\xhh'       label                                       label :
  statements                                                            newline, cr, tab, backspace                 \n, \r, \t, \b          return value from function                  return expr
}                                                                       special characters                          \\, \?, \', \"          Flow Constructions
type fnc(arg 1 ,. . . ) {              function definition               string constant (ends with '\0')            "abc. . . de"           if statement              if (expr ) statement
  declarations                         local variable declarations                                                                                                    else if (expr ) statement
  statements                                                            Pointers, Arrays & Structures                                                                 else statement
  return value;                                                         declare pointer to type                    type *name               while statement           while (expr )
}                                                                       declare function returning pointer to type type *f()
                                       comments                                                                                             for statement             for (expr 1 ; expr 2 ; expr 3 )
/* */                                                                   declare pointer to function returning type type (*pf)()                                          statement
main(int argc, char *argv[])           main with args                   generic pointer type                       void *                   do statement              do     statement
exit(arg )                             terminate execution              null pointer                               NULL                                               while(expr );
                                                                        object pointed to by pointer               *pointer
C Preprocessor                                                          address of object name                     &name
                                                                                                                                            switch statement          switch (expr ) {
                                                                                                                                                                          case const 1 : statement 1 break;
include library file                  #include <filename>                 array                                       name[dim ]                                            case const 2 : statement 2 break;
include user file                     #include "filename"                 multi-dim array                         name[dim 1 ][dim 2 ]. . .                                 default: statement
replacement text                      #define name text                 Structures                                                                                    }
replacement macro                #define name(var ) text                     struct tag {            structure template
     Example. #define max(A,B) ((A)>(B) ? (A) : (B))                            declarations         declaration of members                 ANSI Standard Libraries
undefine                               #undef name                            };                                                             <assert.h>    <ctype.h>    <errno.h>     <float.h>     <limits.h>
quoted string in replace              #                                 create structure                           struct tag name          <locale.h>    <math.h>     <setjmp.h>    <signal.h>    <stdarg.h>
concatenate args and rescan           ##                                member of structure from template          name.member              <stddef.h>    <stdio.h>    <stdlib.h>    <string.h>    <time.h>
conditional execution         #if, #else, #elif, #endif                 member of pointed to structure             pointer -> member
is name defined, not defined?           #ifdef, #ifndef                        Example. (*p).x and p->x are the same
                                                                                                                                            Character Class Tests <ctype.h>
name defined?                          defined(name )                    single value, multiple type structure      union                    alphanumeric?                                isalnum(c)
line continuation char                \                                 bit field with b bits                       member : b               alphabetic?                                  isalpha(c)
                                                                                                                                            control character?                           iscntrl(c)
Data Types/Declarations                                                 Operators (grouped by precedence)                                   decimal digit?                               isdigit(c)
character (1 byte)                           char                       structure member operator                    name.member            printing character (not incl space)?         isgraph(c)
integer                                      int                        structure pointer                            pointer ->member       lower case letter?                           islower(c)
float (single precision)                      float                                                                                          printing character (incl space)?             isprint(c)
                                                                        increment, decrement                         ++, --
float (double precision)                      double                                                                                         printing char except space, letter, digit?   ispunct(c)
                                                                        plus, minus, logical not, bitwise not        +, -, !, ~
short (16 bit integer)                       short                                                                                          space, formfeed, newline, cr, tab, vtab?     isspace(c)
                                                                        indirection via pointer, address of object   *pointer , &name
long (32 bit integer)                        long                                                                                           upper case letter?                           isupper(c)
                                                                        cast expression to type                      (type) expr
positive and negative                        signed                                                                                         hexadecimal digit?                           isxdigit(c)
                                                                        size of an object                            sizeof
only positive                                unsigned                                                                                       convert to lower case?                       tolower(c)
pointer to int, float,. . .                  *int, *float,. . .         multiply, divide, modulus (remainder)        *, /, %                convert to upper case?                       toupper(c)
enumeration constant                         enum                       add, subtract                                +, -
constant (unchanging) value                  const                                                                                          String Operations <string.h>
declare external variable                    extern                     left, right shift [bit ops]                  <<, >>                    s,t are strings, cs,ct are constant strings
register variable                            register                   comparisons                                  >, >=, <, <=           length of s                                  strlen(s)
local to source file                          static                     comparisons                                  ==, !=                 copy ct to s                                 strcpy(s,ct)
no value                                     void                                                                                                up to n chars                           strncpy(s,ct,n)
                                                                        bitwise and                                  &
structure                                    struct                                                                                         concatenate ct after s                       strcat(s,ct)
create name by data type                     typedef typename           bitwise exclusive or                         ^
                                                                                                                                                 up to n chars                           strncat(s,ct,n)
size of an object (type is size_t)           sizeof object              bitwise or (incl)                            |                      compare cs to ct                             strcmp(cs,ct)
size of a data type (type is size_t)         sizeof(type name)          logical and                                  &&                          only first n chars                       strncmp(cs,ct,n)
                                                                                                                                            pointer to first c in cs                      strchr(cs,c)
Initialization                                                          logical or                                   ||
                                                                                                                                            pointer to last c in cs                      strrchr(cs,c)
initialize variable                         type name=value             conditional expression                   expr 1 ? expr 2 : expr 3
                                                                                                                                            copy n chars from ct to s                    memcpy(s,ct,n)
initialize array                     type name[]={value 1 ,. . . }      assignment operators                         +=, -=, *=, . . .      copy n chars from ct to s (may overlap) memmove(s,ct,n)
initialize char string                   char name[]="string "          expression evaluation separator              ,                      compare n chars of cs with ct                memcmp(cs,ct,n)
                                                                                                                                            pointer to first c in first n chars of cs      memchr(cs,c,n)
                                                                        Unary operators, conditional expression and assignment oper-
                                                                                                                                            put c into first n chars of cs                memset(s,c,n)
                                                                        ators group right to left; all others group left to right.

        c 1999 Joseph H. Silverman Permissions on back. v1.3
                                 1                                                                      2                                                                   3
      C Reference Card (ANSI)                                         Standard Utility Functions <stdlib.h>                             Integer Type Limits <limits.h>
                                                                      absolute value of int n                   abs(n)                  The numbers given in parentheses are typical values for the
Input/Output <stdio.h>                                                absolute value of long n                  labs(n)                 constants on a 32-bit Unix system.
                                                                      quotient and remainder of ints n,d        div(n,d)                   CHAR_BIT bits in char                                  (8)
Standard I/O
                                                                           retursn structure with div_t.quot and div_t.rem                 CHAR_MAX max value of char                   (127 or 255)
standard input stream                       stdin
                                                                      quotient and remainder of longs n,d       ldiv(n,d)                  CHAR_MIN min value of char                    (−128 or 0)
standard output stream                      stdout
                                                                           returns structure with ldiv_t.quot and ldiv_t.rem                INT_MAX max value of int                       (+32,767)
standard error stream                       stderr
                                                                      pseudo-random integer [0,RAND_MAX]        rand()                      INT_MIN min value of int                       (−32,768)
end of file                                  EOF
                                                                      set random seed to n                      srand(n)                   LONG_MAX max value of long              (+2,147,483,647)
get a character                             getchar()
                                                                      terminate program execution               exit(status)               LONG_MIN min value of long              (−2,147,483,648)
print a character                           putchar(chr )
                                                                      pass string s to system for execution     system(s)                 SCHAR_MAX max value of signed char                  (+127)
print formatted data                printf("format ",arg 1 ,. . . )
                                                                      Conversions                                                         SCHAR_MIN min value of signed char                  (−128)
print to string s               sprintf(s,"format ",arg 1 ,. . . )
                                                                      convert string s to double                atof(s)                    SHRT_MAX max value of short                     (+32,767)
read formatted data               scanf("format ",&name 1 ,. . . )
                                                                      convert string s to integer               atoi(s)                    SHRT_MIN min value of short                     (−32,768)
read from string s           sscanf(s,"format ",&name 1 ,. . . )
                                                                      convert string s to long                  atol(s)                   UCHAR_MAX max value of unsigned char                  (255)
read line to string s (< max chars)         gets(s,max)
                                                                      convert prefix of s to double              strtod(s,endp)             UINT_MAX max value of unsigned int                (65,535)
print string s                              puts(s)
                                                                      convert prefix of s (base b) to long       strtol(s,endp,b)          ULONG_MAX max value of unsigned long       (4,294,967,295)
File I/O
                                                                           same, but unsigned long              strtoul(s,endp,b)         USHRT_MAX max value of unsigned short             (65,536)
declare file pointer                         FILE *fp
                                                                      Storage Allocation
pointer to named file                   fopen("name ","mode ")
                                                                      allocate storage            malloc(size), calloc(nobj,size)       Float Type Limits <float.h>
     modes: r (read), w (write), a (append)                                                                                               FLT_RADIX         radix of exponent rep                          (2)
                                                                      change size of object                     realloc(pts,size)
get a character                             getc(fp)                                                                                      FLT_ROUNDS        floating point rounding mode
                                                                      deallocate space                          free(ptr)
write a character                           putc(chr ,fp)                                                                                 FLT_DIG           decimal digits of precision                   (6)
                                                                      Array Functions
write to file                   fprintf(fp,"format ",arg 1 ,. . . )
                                                                      search array for key        bsearch(key,array,n,size,cmp())         FLT_EPSILON       smallest x so 1.0 + x = 1.0                (10−5 )
read from file                    fscanf(fp,"format ",arg 1 ,. . . )
                                                                      sort array ascending order        qsort(array,n,size,cmp())         FLT_MANT_DIG      number of digits in mantissa
close file                                   fclose(fp)
                                                                                                                                          FLT_MAX           maximum floating point number               (1037 )
non-zero if error                           ferror(fp)                Time and Date Functions <time.h>                                    FLT_MAX_EXP       maximum exponent
non-zero if EOF                             feof(fp)
                                                                      processor time used by program              clock()                 FLT_MIN           minimum floating point number             (10−37 )
read line to string s (< max chars)         fgets(s,max,fp )
                                                                           Example. clock()/CLOCKS_PER_SEC is time in seconds             FLT_MIN_EXP       minimum exponent
write string s                              fputs(s,fp )
                                                                      current calendar time                       time()                  DBL_DIG           decimal digits of precision                   (10)
Codes for Formatted I/O: "%-+ 0w.pmc"
       - left justify                                                 time2 -time1 in seconds (double)        difftime(time2 ,time1 )     DBL_EPSILON       smallest x so 1.0 + x = 1.0                (10−9 )
       + print with sign                                              arithmetic types representing times         clock_t,time_t          DBL_MANT_DIG      number of digits in mantissa
     space print space if no sign                                     structure type for calendar time comps          tm                  DBL_MAX           max double floating point number            (1037 )
       0 pad with leading zeros                                            tm_sec        seconds after minute                             DBL_MAX_EXP       maximum exponent
       w min field width                                                    tm_min        minutes after hour                               DBL_MIN           min double floating point number          (10−37 )
       p precision                                                         tm_hour       hours since midnight                             DBL_MIN_EXP       minimum exponent
       m conversion character:                                             tm_mday       day of month
                 h short,      l long,       L long double                 tm_mon        months since January
       c    conversion character:                                          tm_year       years since 1900
          d,i integer           u unsigned                                 tm_wday       days since Sunday
           c single char        s char string                              tm_yday       days since January 1
           f double           e,E exponential                              tm_isdst      Daylight Savings Time flag
           o octal            x,X hexadecimal                         convert local time to calendar time         mktime(tp)
           p pointer            n number of chars written             convert time in tp to string                asctime(tp)
          g,G same as f or e,E depending on exponent                  convert calendar time in tp to local time ctime(tp)
                                                                      convert calendar time to GMT                gmtime(tp)
Variable Argument Lists <stdarg.h>                                    convert calendar time to local time         localtime(tp)
declaration of pointer to arguments       va_list name;               format date and time info       strftime(s,smax,"format ",tp)
initialization of argument pointer   va_start(name ,lastarg )              tp is a pointer to a structure of type tm
     lastarg is last named parameter of the function
access next unamed arg, update pointer va_arg(name ,type)             Mathematical Functions <math.h>
call before exiting function              va_end(name )               Arguments and returned values are double
                                                                      trig functions                     sin(x), cos(x), tan(x)
                                                                      inverse trig functions         asin(x), acos(x), atan(x)
                                                                      arctan(y/x)                            atan2(y,x)
                                                                      hyperbolic trig functions      sinh(x), cosh(x), tanh(x)                 May 1999 v1.3. Copyright c 1999 Joseph H. Silverman
                                                                      exponentials & logs             exp(x), log(x), log10(x)
                                                                                                                                        Permission is granted to make and distribute copies of this card pro-
                                                                      exponentials & logs (2 power)     ldexp(x,n), frexp(x,*e)         vided the copyright notice and this permission notice are preserved on
                                                                      division & remainder               modf(x,*ip), fmod(x,y)         all copies.
                                                                      powers                                 pow(x,y), sqrt(x)          Send comments and corrections to J.H. Silverman, Math. Dept., Brown
                                                                      rounding                      ceil(x), floor(x), fabs(x)          Univ., Providence, RI 02912 USA. jhs@math.brown.edu

                                4                                                                   5                                                                     6