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 |