Program Structure / Functions
| type func(type1, …); | //function prototype |
|---|---|
| type name; | //variable declaration |
| int main(void){ | //main routine |
| declarations | //local variable declarations |
| statements | |
| } | |
| /* */ | /*Original C comments (block/multiple line comments*/ |
| // | //single line comments recognized by most all compilers |
| int main(int argc, char *argv[]) | //main with args |
| exit(arg); | //terminate execution |
C Preprocessor
| #include <filename> | include library file | |
| #include “filename” | include user file | |
| #define name text | replacement text | |
| #define name(var) text | replacement macro | Ex: #define max(a,b) ((a)>(b) ? (a) : (b)) |
| #undefine name | undefine | |
| # | quoted string in replace | Ex: #define msg(a) printf(“%s = %d, #a, (a)) |
| ## | concatenate args and rescan | |
| #if, #else, #elif, #endif | conditional execution | |
| #ifdef, #ifndef | is name defined, not defined? | |
| defined(name) | name defined? | |
| \ | line continuation char |
Data Type / Declarations
| char | character (1 byte) |
|---|---|
| int | integer |
| float, double | real number (single, double precision) |
| short | short (16 bit integer) |
| long | long (32 bit integer) |
| long long | double long (64 bit integer) |
| signed | positive or negative |
| unsigned | non-negative modulo 2m |
| int*, float*,… | pointer to int, float,… |
| enum tag {name1=value1,…}; | enumeration constant |
| type const name; | constant (read-only) value |
| extern | declare external variable |
| static | internal to source file |
| static | local persistent between calls |
| struct tag {…}; | Structure |
| typedef type name; | Create new name for data type |
| sizeof object | size of an object (type is size_t) |
| sizeof(type) | size of a data type (type is size_t) |
Initialization
| type name=value; | initialize variable |
| type name[]={value1,…}; | initialize array |
| char name[]=”string”; | initialize char string |
Constants
| 65536L, -1U, 3.0F | Long, unsigned, float | |
| 4.2e1 | exponential form | |
| 0, 0x or 0X | octal, hexadecimal | Ex: 031 is 25, 0x31 is 49 decimal |
| ‘a’, ‘\ooo’, ‘\xhh’ | character constant (char, octal, hex) | |
| \n, \r, \t, \b | newline, cr, tab, backspace | |
| \\, \?, \’, \” | special characters | |
| “abc…de” | string constant (ends with ‘\0’) |
Pointers, Arrays and Structures
| type *name; | declare pointer to type |
| type *f(); | declare function returning pointer to type |
| type (*pf)(); | declare pointer to function returning type |
| void * | generic pointer type |
| NULL | null pointer constant |
| *pointer | object pointed to by pointer |
| &name | address of object name |
| name[dim] | array |
| name[dim1][dim2]… | multi-dimensional array |
Structures
| struct tag { | structure template | |
| declarations | declaration of members | |
| } | ||
| struct tag name | create structure | |
| name.member | member of structure from template | |
| pointer -> member | member of pointed-to structure | Ex: (*p).x and p->x are the same |
| union | single object, multiple possible types | |
| unsigned member: b; | bit field with b bits |
Operators By Precedence
| name, member | struct member operator |
| pointer -> member | struct member through pointer |
| ++, — | increment, decrement |
| +, -, !, ~ | plus, minus, logical not, bitwise not |
| *pointer, | indirection via pointer, address of object |
| (type) expr | cast expression to type |
| sizeof | size of any object |
| *, /, % | Multiply, divide, modulus (remainder) |
| +, – | Add, subtract |
| <<, >> | left, right shift [bit op] |
| >, >=, <, <= | relational comparisons |
| ==, != | Equality comparison |
| & | And [bit op] |
| ^ | exclusive or [bit op] |
| | | or (inclusive) |
| && | logical and |
| || | logical or |
| expr1 ? expr2 : expr3 | Conditional expression |
| +=, -=, *=, … | assignment operators |
| , | Expression evaluation separator |
Unary operators, conditional expression and assignment operators group right to left; all others group left to right
Flow Control
| ; | Statement terminator |
| {} | Block delimiters |
| break; | exit from switch, while, do, for |
| continue; | next iteration of while, do, for |
| goto label; | go to |
| label: statement | label |
| return expr | return value from function |
Flow Constructions
| if (expr1) statement1 else if (expr2) statement 2 else statement3 |
if statement | |
| while (expr) statement |
while statement | |
| for (expr1; expr2; expr3) statement |
for statement | |
| do statement while (expr); |
do statement | |
| switch (expr) { case const1: statement1 break; case const2: statement2 break; default: statement |
switch statement | |
ANSI Standard Libraries
<assert.h>
<ctype.h>
<errno.h>
<float.h>
<limits.h>
<locale.h>
<math.h>
<setjmp.h>
<signal.h>
<stdarg.h>
<stddef.h>
<stdio.h>
<stdlib.h>
<string.h>
<time.h>
Character Class Test <ctype.h>
| isalnum(c) | Alphanumeric? |
| isalpha(c) | Alphabetic? |
| iscntrl(c) | Control character? |
| isdigit(c) | Decimal digit? |
| isgraph(c) | printing character (not including space)? |
| islower(c) | Lower case letter? |
| isprint(c) | Printing Character (Including space)? |
| ispunct(c) | Printing Character except space, letter, digit? |
| isspace(c) | space, formfeed, newline, cr, tab, vtab? |
| isupper(c) | Upper case letter? |
| isxdigit(c) | Hexadecimal digit? |
| tolower(c) | Convert to lower case |
| toupper(c) | Convert to upper case |
String Operations <string.h>
s is a string; cs, ct are constant strings
| strlen(s) | length of s |
| strcopy(s, ct) | Copy ct to s |
| strcat(s, ct) | Concatenate ct after s |
| strcmp(cs, ct) | compare cs to ct |
| strcmp(cs, ct, n) | compare cs to ct, only first n chars |
| strchr(cs, c) | Pointer to first c in cs |
| strrchr(cs, c) | Pointer to last c in cs |
| memcpy(s,ct,n) | Copy n chars from ct to s |
| memmove(s,ct,n) | Copy n chars from ct to s, may overlap |
| memcmp(cs,ct,n) | Compare n chars of cs with ct |
| memchr(cs,c,n) | Pointer to first c in first n char of cs |
| memset(s,c,n) | Put c into first n chars of s |
Input / Output <stdio.h>
Standard I/O
| stdin | Standard input stream |
| stdout | Standard output stream |
| stderr | Standard Errros stream |
| EOF | End of file (type is int) |
| getchar() | Get a character |
| putchar(chr) | Print a character |
| printf(“format”, arg1, …) | Print formatted data |
| sprintf(s, “format”, ard1, …) | Print to string s |
| scanf(“format”, &name1, …) | Read formatted data |
| sscanf(s, “format”, &name, …) | read from string s |
| puts(s) | Print string s |
File I/O
| FILE *fp; | Declare file pointer | |
| fopen(“name”, “mode”) | Pointer to named file | modes: r (read), w (write), a (append), b (binary) |
| getc(fp) | Get a character | |
| putc(chr, fp) | Write to character | |
| fprintf(fp, “format”, arg1, …) | Write to file | |
| fscanf(fp, “format”, arg1, …) | Read from file | |
| fread(*ptr, eltsize, n, fp) | Read and store n elts to *ptr | |
| fwrite(*ptr, eltsize, n, fp) | Write n elts from *ptr to file | |
| fclose(fp) | Close file | |
| ferror(fp) | non-zero if error | |
| feof(fp) | non-zero if already reached EOF | |
| fgets(s, max, fp) | read line to string s ( < max chars) | |
| fputs(s, fp) | Write string s |
Codes for Formatted I/O “%-+ 0w.pmc”
| – | Left justify |
| + | Print with sign |
| space | Print space if no sign |
| 0 | Pad with leading zeros |
| w | Min field width |
| p | Precision |
| m h short l long L long double |
Conversion character: |
| c d,i integer c Single Char f Double (printf) f Float(scanf) o Octal p Pointer g,G same as f or e,E depending on exponent u Unsigned s Char string e,E Exponential lf Double (scanf) x,X Hexadecimal n Number of chars written |
Conversion character: |
Variable Argument Lists <stdarg.h>
| va_list ap; | Declaration of pointer to arguments | |
| va_start(ap,lastarg); | Initialization of argument pointer | /* lastarg is last named parameter of the function*/ |
| va_arg(ap,type); | Access next unamed tag, update pointer | |
| va_end(ap); | Call before exiting function |
Standard Utility Functions <stdlib.h>
| abs(n) | Absolute value of int n |
| labs(n) | Absolute value of long n |
| div(n,d) | Quotient and remainder of ints n,d returns structure with div_t.quot and div_t.rem |
| ldiv(n,d) | Quotient and remainder of longs n,d returns structure with ldiv_t.quot and ldiv_t.rem |
| rand() | Pseudo random integer [0,RAND_MAX] |
| srand(n) | Set random seed to n |
| exit(status) | Terminate program execution |
| system(s) | Pass string s to system for execution |
Conversions
| atof(s) | Convert string s to double |
| atoi(s) | Convert string s to integer |
| atol(s) | Convert string s to long |
| strtod(s,&endp) | Convert prefix of s to double |
| strtol(s,&endp,b) | Convert prefix of s (base b) to long |
| strtoul(s,&endp,b) | Convert prefix of s (base b) to unsigned long |
Storage Allocation
| malloc(size), calloc(nobj,size) | Allocate storge |
| newptr = realloc(ptr,size); | Change Size of storage |
| free(ptr); | Deallocate storage |
Array Functions
| bsearch(key,array,n,size,cmpf) | Search Array for key |
| qsort(array,n,size,cmpf) | Sort Array ascending order |
Time and Date Functions <time.h>
| clock() | processor time used by program | Ex: clock()/CLOCKS_PER_SEC is time in seconds |
| time() | Current calendar time |
| difftime(time2,time1) | time2-time1 in seconds (double) |
| clock_t,time_t | Arithmetic types representing times |
| struct tm | Structure type for calendar time comps |
| tm_sec | Seconds after minute |
| tm_min | Minutes after hour |
| tm_hour | Hours since mindnight |
| tm_mday | Day of month |
| tm_mon | Months since January |
| tm_year | Years since 2000 |
| tm_wday | Days since Sunday |
| tm_yday | Days since January 1 |
| tm_isdst | Daylight savings time flag |
| mktime(tp) | Convert local time to calendar time |
| asctime(tp) | Convert time in tp to string |
| ctime(tp) | Convert calendar time in tp to local time |
| gmtime(tp) | Convert calendar time to GMT |
| localtime(tp) | Convert calendar time to local time |
| strftime(s,smax,”format”,tp) | tp is a pointer to a structure of type tm |
Mathematical Functions <math.h>
Arguments and returned values are double
| sin(x), cos(x), tan(x) | Trig functions |
| asin(x), acos(x), atan(x), atan2(y,x), atan2(y,x) | Inverse Trig functions |
| sinh(x), cosh(x), tanh(x) | Hyperbolic trig functions |
| exp(x), log(x), log10(x) | Exponentials & logs |
| ldexp(x,n), frexp(x,&e) | Exponentials & logs (2 power) |
| modf(x,ip), fmod(x,y) | Division & remainder |
| pow(x,y), sqrt(x) | Powers |
| ceil(x), floor(x), fabs(x) | rounding |
Interger Type Limits <limits.h>
32bit Linux system
| CHAR_BIT | Bits in char | (8) |
| CHAR_MAX | Max value of char | (SCHAR_MAX or UCHAR_MAX) |
| CHAR_MIN | Min value of char | (SCHAR_MIN or 0) |
| SCHAR_MAX | Max signed char | (+127) |
| SCHAR_MIN | Min signed char | (-128) |
| SHRT_MAX | Max value of short | (+32,767) |
| SHRT_MIN | Min value of short | (-32,768) |
| INT_MAX | Max value of int | (+2,147,483,647)(+32,767) |
| INT_MIN | Min value of int | (-2,147,483,648)(-32,767) |
| LONG_MAX | Max value of long | (+2,147,483,647) |
| LONG_MIN | Min value of long | (-2,147,483,648) |
| UCHAR_MAX | Max unsigned char | (255) |
| USHRT_MAX | Max unsigned short | (65,535) |
| UINT_MAX | Max unsigned int | (4,294,967,295)(65,535) |
| ULONG_MAX | Max unsigned long | (4,294,967,295) |
Float Type Limits <float.h>
32bit Linux system
| FLT_RADIX | Radix of exponent rep | (2) |
| FLT_ROUNDS | Floating point rounding mode | |
| FLT_DIG | Decimal digits of precision | (6) |
| FLT_EPSILON | Smallest x so 1.0f + x ≠ 1.0f | (1.1E-7) |
| FLT_MANT_DIG | Number of digits in mantissa | |
| FLT_MAX | Max float number | (3.4E38) |
| FLT_MAX_EXP | Max Exponent | |
| FLT_MIN | Min float number | (1.2E-38) |
| FLT_MIN_EXP | Min Exponent | |
| DBL_DIG | Decimal digits of precision | (15) |
| DBL_EPSILON | Smallest x so 1.0 + x ≠ 1.0 | (2.2E-16) |
| DBL_MANT_DIG | Number of digits in mantissa | |
| DBL_MAX | Max double number | (1.8E308) |
| DBL_MAX_EXP | Max Exponent | |
| DBL_MIN | Min double number | (2.2E-308) |
| DBL_MIN_EXP | Minimum exponent |
