awesome-lists/c-cheatsheet.md

C Programming Language Cheatsheet

Program Structure

#include <stdio.h>  // Include standard I/O library

// Function prototype declaration
void myFunction(int param);

// Global variables
int globalVar = 10;

// Main function - program entry point
int main() {
    // Code statements
    printf("Hello, World!\n");
    
    return 0; // Return value to OS (0 = success)
}

// Function definition
void myFunction(int param) {
    // Function body
}

Data Types

Type	Description	Format Specifier	Example
int	Integer	%d or %i	int x = 10;
float	Single-precision floating point	%f	float y = 10.5f;
double	Double-precision floating point	%lf	double z = 10.5;
char	Single character	%c	char c = 'A';
char[]	String (character array)	%s	char str[] = "hello";
short	Short integer	%hd	short s = 10;
long	Long integer	%ld	long l = 10L;
long long	Long long integer	%lld	long long ll = 10LL;
unsigned int	Unsigned integer	%u	unsigned int ui = 10u;
unsigned char	Unsigned character	%c	unsigned char uc = 255;
size_t	Size type (for sizes)	%zu	size_t size = sizeof(int);

Variable Declaration

// Basic declaration
int a;           // Declaration
int b = 10;      // Declaration with initialization
const int MAX = 100;  // Constant (cannot be modified)

// Multiple variables
int x, y, z;
int p = 1, q = 2, r = 3;

// Type modifiers
unsigned int positive;  // Only non-negative values
signed int withSign;    // Can be positive or negative
long int bigNumber;     // Larger range of values
short int smallNumber;  // Smaller range of values

Operators

Arithmetic Operators

Operator	Description	Example	Result
+	Addition	a + b	13
-	Subtraction	a - b	7
*	Multiplication	a * b	30
/	Division	a / b	3 (integer division)
%	Modulus (remainder)	a % b	1
-	Negation	-a	-10
++	Increment	a++	a becomes 11
--	Decrement	b--	b becomes 2

Comparison Operators

Operator	Description	Example
==	Equal to	a == b
!=	Not equal to	a != b
>	Greater than	a > b
<	Less than	a < b
>=	Greater than or equal to	a >= b
<=	Less than or equal to	a <= b

Logical Operators

Operator	Description	Example
&&	Logical AND	a && b
||	Logical OR	a || b
!	Logical NOT	!a

Bitwise Operators

Operator	Description	Example	Notes
&	Bitwise AND	a & b
|	Bitwise OR	a | b
^	Bitwise XOR	a ^ b
~	Bitwise NOT	~a
<<	Left shift	a << 2	Multiply by 2²
>>	Right shift	a >> 2	Divide by 2²

Assignment Operators

Operator	Description	Equivalent
=	Simple assignment	a = b
+=	Add and assign	a = a + b
-=	Subtract and assign	a = a - b
*=	Multiply and assign	a = a * b
/=	Divide and assign	a = a / b
%=	Modulus and assign	a = a % b
&=	Bitwise AND and assign	a = a & b
|=	Bitwise OR and assign	a = a | b
^=	Bitwise XOR and assign	a = a ^ b
<<=	Left shift and assign	a = a << b
>>=	Right shift and assign	a = a >> b

Control Structures

Conditional Statements

Statement	Syntax	Description
If	if (condition) { statements }	Executes statements if condition is true
If-else	if (condition) { statements1 } else { statements2 }	Executes statements1 if condition is true, otherwise statements2
If-else if-else	if (condition1) { statementsA } else if (condition2) { statementsB } else { statementsC }	Tests multiple conditions in sequence
Ternary operator	result = (condition) ? valueIfTrue : valueIfFalse;	Shorthand for simple if-else assignment
Switch	switch (expression) { case value1: statements1; break; case value2: statements2; break; default: statementsDefault; }	Multi-way branch based on expression value

Switch Statement Example

switch (grade) {
    case 'A':
        printf("Excellent!\n");
        break;
    case 'B':
        printf("Good job!\n");
        break;
    case 'C':
        printf("Average performance.\n");
        break;
    default:
        printf("Need improvement.\n");
}

Loops

Loop Type	Syntax	Description
For	for (initialization; condition; update) { statements }	Repeats statements while condition is true, with initialization before first iteration and update after each iteration
While	while (condition) { statements }	Repeats statements while condition is true
Do-while	do { statements } while (condition);	Executes statements at least once, then repeats while condition is true

Loop Control

Statement	Description
break;	Exits the innermost loop or switch
continue;	Skips to the next iteration of the loop

Arrays

// Declaration and initialization
int numbers[5];              // Uninitialized array of 5 integers
int scores[5] = {90, 85, 88, 92, 76};  // Initialized array
int partial[5] = {90, 85};   // Remaining elements initialized to 0
int auto_size[] = {1, 2, 3}; // Size determined automatically (3)

// Accessing elements (0-indexed)
int first = scores[0];       // 90
scores[4] = 95;              // Modify element

// Multidimensional arrays
int matrix[3][4];            // 3×4 matrix (3 rows, 4 columns)
int grid[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};
int value = grid[1][0];      // 4 (row 1, column 0)

Strings

// String declaration and initialization
char greeting[] = "Hello";  // Includes null terminator '\0' automatically
char name[10] = "John";     // Array size should be at least string length + 1
char empty[10] = "";        // Empty string

// Accessing characters
char first = name[0];       // 'J'
name[0] = 'j';              // Modify character

// Common string functions (include <string.h>)
strlen(str);       // String length (excludes null terminator)
strcpy(dest, src); // Copy string src to dest
strcat(dest, src); // Concatenate src to the end of dest
strcmp(s1, s2);    // Compare strings (0 if equal, <0 if s1<s2, >0 if s1>s2)
strchr(str, ch);   // Find first occurrence of character ch in str
strstr(str, sub);  // Find first occurrence of substring sub in str

Pointers

// Declaration and initialization
int x = 10;
int *ptr = &x;  // ptr contains the memory address of x

// Dereferencing (accessing the value at the address)
int value = *ptr;  // value = 10

// Pointer arithmetic
int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;      // p points to the first element of arr
int second = *(p + 1);  // 20 (second element)

// Null pointer
int *nullPtr = NULL;  // Points to nothing (always check before dereferencing)

// Pointers and arrays
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;  // Points to first element
// These are equivalent:
int val1 = arr[2];
int val2 = *(arr + 2);
int val3 = ptr[2];
int val4 = *(ptr + 2);

Functions

Function Syntax

Component	Syntax	Description
Declaration	return_type function_name(parameter_type param1, ...);	Function prototype (declares the function)
Definition	return_type function_name(parameter_type param1, ...) { statements }	Actual function code
Call	function_name(argument1, argument2, ...);	Invoking the function
Return	return value;	Exit function and return a value (if not void)

Function Types and Examples

Function Type	Example	Description
With return value	int add(int a, int b) { return a + b; }	Returns calculated result
Without return value	void printMessage(const char *msg) { printf("%s\n", msg); }	Performs action, returns nothing
Pass by value	void increment(int x) { x++; }	Changes only affect local copy
Pass by reference	void increment(int *x) { (*x)++; }	Changes affect original variable
Recursive	int factorial(int n) { if (n <= 1) return 1; return n * factorial(n-1); }	Function calls itself

Parameter Passing

Method	Example Call	Effect on Original
By value	increment(num);	No change to original
By reference	increment(&num);	Original can be modified
Array	process(array);	Original array can be modified
Const reference	display(const int *arr, int size);	Prevents modification of original

// Example of function usage
int num = 5;
incrementByValue(num);      // num remains 5
incrementByReference(&num); // num becomes 6

Structures

// Structure definition
struct Person {
    char name[50];
    int age;
    float height;
};

// Declaration and initialization
struct Person person1;
struct Person person2 = {"John", 25, 1.75};

// Accessing members
strcpy(person1.name, "Jane");
person1.age = 22;
person1.height = 1.65;

// Structure pointer
struct Person *ptr = &person1;
printf("%s\n", ptr->name);  // Arrow operator for pointer access
// Equivalent to: printf("%s\n", (*ptr).name);

// Typedef for simpler naming
typedef struct {
    char title[100];
    char author[50];
    int year;
} Book;

Book novel = {"The Great Gatsby", "F. Scott Fitzgerald", 1925};

Memory Management

// Dynamic memory allocation (include <stdlib.h>)
int *ptr = malloc(5 * sizeof(int));  // Allocate memory for 5 integers
if (ptr == NULL) {
    // Allocation failed
}

// Initialize allocated memory
memset(ptr, 0, 5 * sizeof(int));  // Set all bytes to 0 (include <string.h>)

// Reallocation
ptr = realloc(ptr, 10 * sizeof(int));  // Resize to 10 integers

// Free allocated memory (prevent memory leaks)
free(ptr);
ptr = NULL;  // Good practice to avoid dangling pointers

File I/O

File Operations

Operation	Function	Description
Open	FILE *file = fopen(filename, mode);	Open a file with specified mode
Close	fclose(file);	Close a file and flush buffers
Check EOF	feof(file)	Check if end-of-file is reached
Get error	ferror(file)	Check if an error occurred
Flush	fflush(file)	Flush output buffer
Reposition	fseek(file, offset, origin)	Move file position indicator
Get position	ftell(file)	Get current file position
Rewind	rewind(file)	Set position to beginning of file

File Open Modes

Mode	Description
"r"	Read (file must exist)
"w"	Write (create new or truncate existing)
"a"	Append (create new or append to existing)
"r+"	Read and write (file must exist)
"w+"	Read and write (create new or truncate existing)
"a+"	Read and append (create new or append to existing)
"b"	Binary mode (add to modes above, e.g., "rb", "wb")

Text File I/O

Operation	Function	Description
Read formatted	fscanf(file, format, ...)	Read formatted data
Write formatted	fprintf(file, format, ...)	Write formatted data
Read line	fgets(buffer, size, file)	Read a line of text
Write string	fputs(string, file)	Write a string
Read character	fgetc(file) or getc(file)	Read a character
Write character	fputc(c, file) or putc(c, file)	Write a character

Binary File I/O

Operation	Function	Description
Read	fread(buffer, size, count, file)	Read binary data
Write	fwrite(buffer, size, count, file)	Write binary data

Example

// Writing to a text file
FILE *file = fopen("data.txt", "w");
if (file == NULL) {
    perror("Error opening file");
    return 1;
}
fprintf(file, "Name: %s, Age: %d\n", "John", 25);
fclose(file);

// Reading from a text file
char name[50];
int age;
file = fopen("data.txt", "r");
if (file != NULL) {
    fscanf(file, "Name: %s, Age: %d", name, &age);
    fclose(file);
}

Preprocessor Directives

Basic Preprocessor Directives

Directive	Syntax	Description
Include	#include <filename>	Include system header file
Include	#include "filename"	Include local header file
Define	#define NAME value	Define a macro constant
Define function	#define NAME(params) expression	Define a function-like macro
Undefine	#undef NAME	Remove a macro definition
Error	#error message	Force compilation error with message
Pragma	#pragma token	Implementation-specific instructions

Conditional Compilation

Directive	Syntax	Description
If defined	#ifdef SYMBOL	True if SYMBOL is defined
If not defined	#ifndef SYMBOL	True if SYMBOL is not defined
If expression	#if EXPRESSION	True if EXPRESSION is non-zero
Else if	#elif EXPRESSION	Alternative condition
Else	#else	Default condition
End if	#endif	End conditional block

Predefined Macros

Macro	Description
__FILE__	Current source filename (string)
__LINE__	Current line number (integer)
__DATE__	Compilation date (string)
__TIME__	Compilation time (string)
__STDC__	1 if compiler conforms to ANSI C
__cplusplus	Defined when compiled with C++ compiler
__func__	Current function name (string)

Macro Examples

// Simple constant macro
#define PI 3.14159

// Function-like macro with arguments
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// Stringification operator (#)
#define STRINGIFY(x) #x
// Usage: STRINGIFY(hello) becomes "hello"

// Token concatenation operator (##)
#define CONCAT(a, b) a##b
// Usage: CONCAT(num, 123) becomes num123

Error Handling

// Error handling with return values
if (function() == -1) {
    // Handle error
}

// Using errno (include <errno.h>)
#include <errno.h>
if (func() == -1) {
    printf("Error: %d\n", errno);
    perror("Error message");  // Print error message based on errno
}

// Exit program (include <stdlib.h>)
exit(EXIT_SUCCESS);  // Normal termination
exit(EXIT_FAILURE);  // Error termination

Command Line Arguments

int main(int argc, char *argv[]) {
    // argc: Number of arguments (including program name)
    // argv: Array of argument strings
    
    printf("Program name: %s\n", argv[0]);
    
    for (int i = 1; i < argc; i++) {
        printf("Argument %d: %s\n", i, argv[i]);
    }
    
    return 0;
}

Common Library Functions

Standard I/O (stdio.h)

Function	Syntax	Description
printf	printf("Format", args...);	Formatted output to stdout
scanf	scanf("%d", &variable);	Formatted input from stdin
puts	puts("string");	Output string with newline
gets	gets(string);	Input string (unsafe, avoid using)
putchar	putchar('c');	Output character
getchar	getchar();	Input character
fprintf	fprintf(file, "Format", args);	Formatted output to file
fscanf	fscanf(file, "%d", &var);	Formatted input from file
fgets	fgets(str, size, file);	Input line from file (safe)
sprintf	sprintf(str, "Format", args);	Formatted output to string

String Handling (string.h)

Function	Syntax	Description
strlen	strlen(str);	String length
strcpy	strcpy(dest, src);	String copy
strncpy	strncpy(dest, src, n);	Copy up to n characters
strcat	strcat(dest, src);	String concatenation
strncat	strncat(dest, src, n);	Concatenate up to n characters
strcmp	strcmp(s1, s2);	String comparison
strncmp	strncmp(s1, s2, n);	Compare up to n characters
strchr	strchr(str, c);	Find character in string
strstr	strstr(str, substr);	Find substring in string
strtok	strtok(str, delim);	Tokenize string

Memory Functions (string.h)

Function	Syntax	Description
memcpy	memcpy(dest, src, n);	Memory copy
memmove	memmove(dest, src, n);	Safe memory copy (handles overlap)
memset	memset(ptr, value, n);	Fill memory with value
memcmp	memcmp(ptr1, ptr2, n);	Compare memory blocks

Math Functions (math.h)

Function	Syntax	Description
sqrt	sqrt(x);	Square root
pow	pow(x, y);	x raised to power y
ceil	ceil(x);	Round up to integer
floor	floor(x);	Round down to integer
round	round(x);	Round to nearest integer
fabs	fabs(x);	Absolute value (float)
sin, cos, tan	sin(x);	Trigonometric functions
asin, acos, atan	asin(x);	Inverse trigonometric functions
log, log10	log(x);	Natural and base-10 logarithms
exp	exp(x);	e raised to power x

Character Functions (ctype.h)

Function	Syntax	Returns true if character is...
isalpha	isalpha(c);	Alphabetic (a-z, A-Z)
isdigit	isdigit(c);	Decimal digit (0-9)
isalnum	isalnum(c);	Alphanumeric (a-z, A-Z, 0-9)
isspace	isspace(c);	Whitespace (space, tab, newline, etc.)
islower	islower(c);	Lowercase (a-z)
isupper	isupper(c);	Uppercase (A-Z)
tolower	tolower(c);	Convert to lowercase
toupper	toupper(c);	Convert to uppercase

Memory Management (stdlib.h)

Function	Syntax	Description
malloc	malloc(size);	Allocate memory
calloc	calloc(n, size);	Allocate and zero memory
realloc	realloc(ptr, size);	Resize memory allocation
free	free(ptr);	Free allocated memory

Other Utility Functions (stdlib.h)

Function	Syntax	Description
atoi	atoi(str);	Convert string to int
atof	atof(str);	Convert string to double
rand	rand();	Generate random number
srand	srand(seed);	Seed random number generator
qsort	qsort(arr, n, size, cmp);	Sort array
bsearch	bsearch(key, arr, n, size, cmp);	Binary search
exit	exit(status);	Terminate program
abs	abs(n);	Integer absolute value

Time Functions (time.h)

Function	Syntax	Description
time	time(NULL);	Current time (seconds since epoch)
clock	clock();	Processor time used
difftime	difftime(time2, time1);	Time difference in seconds
localtime	localtime(&time_t);	Convert to local time struct
strftime	strftime(str, size, format, tm);	Format time as string