Complete C Reference Course

int myNum = 15;           // declare and assign immediately

int myNum2;               // declare without assigning
myNum2 = 15;             // then assign later

int myNum3 = 15;          // myNum3 is 15
myNum3 = 10;             // myNum3 is now 10 (reassigned)

float myFloat  = 5.99;    // floating point number
char  myLetter = 'D';    // character (single quotes)

int x = 5;
int y = 6;
int sum = x + y;         // add variables together

// Declare multiple variables on one line
int a = 5, b = 6, c = 50;

const int   minutesPerHour = 60;
const float PI             = 3.14;

// Best practice: UPPER_CASE naming for constants
const int BIRTHYEAR = 1980;

// This is a single-line comment

printf("Hello World!"); // inline comment — appears after code

/* Multi-line comment,
   can span multiple lines,
   compiler ignores all of this */

int time = 20;
if (time < 18) {
  printf("Goodbye!");
} else {
  printf("Good evening!");  // runs — 20 is not < 18
}

// Multi-branch else-if chain
int hour = 22;
if (hour < 10) {
  printf("Good morning!");
} else if (hour < 20) {
  printf("Goodbye!");
} else {
  printf("Good evening!");   // => "Good evening!"
}

// Declare and initialize (compiler counts size)
int myNumbers[] = {25, 50, 75, 100};

printf("%d", myNumbers[0]);   // => 25 (index starts at 0)

// Modify an element
myNumbers[0] = 33;
printf("%d", myNumbers[0]);   // => 33

// Loop through the array
int i;
for (i = 0; i < 4; i++) {
  printf("%d\n", myNumbers[i]);
}

// Declare size explicitly, then fill element by element
int arr[4];
arr[0] = 25;
arr[1] = 50;
arr[2] = 75;
arr[3] = 100;

// Read an integer from the user
int myNum;
printf("Please enter a number: \n");
scanf("%d", &myNum);       // & gives scanf the address of myNum
printf("You entered: %d", myNum);

// Read a string (stops at whitespace)
char firstName[30];
printf("Enter your name: \n");
scanf("%s", &firstName);
printf("Hello %s.", firstName);

int myAge = 43;

printf("%p", &myAge);
// Output: 0x7ffe5367e044  (the actual address — varies per run)

// %p is the format specifier for printing pointer/address values

int myAge = 43;             // a normal int variable
printf("%d", myAge);        // => 43 (the value)
printf("%p", &myAge);       // => 0x7ffe... (the address)

// Declare a pointer — it holds the ADDRESS of myAge
int *ptr = &myAge;

printf("%p\n", ptr);        // => same address as &myAge
printf("%p\n", &myAge);     // => same address

int myAge = 43;
int *ptr  = &myAge;   // ptr holds the address of myAge

// Reference: print the address stored in ptr
printf("%p\n", ptr);   // => 0x7ffe5367e044

// Dereference: follow the pointer to get the VALUE at that address
printf("%d\n", *ptr);  // => 43  (*ptr is the value myAge holds)

int myAge = 43;

// DECLARATION: int*ptr declares ptr as a pointer-to-int
int *ptr = &myAge;

printf("%d\n",  myAge);   // => 43        (value of myAge directly)
printf("%p\n", &myAge);   // => 0x7ffe..  (address of myAge)
printf("%p\n",  ptr);     // => 0x7ffe..  (ptr stores same address)
printf("%d\n", *ptr);     // => 43        (dereference: value at address)

int myNum = 100 + 50;            // 150
int sum1  = 100 + 50;            // 150
int sum2  = sum1 + 250;          // 400
int sum3  = sum2 + sum2;         // 800

int x = 5;
x < 5 && x < 10    // false && true  = 0 (false)
x < 5 || x < 10    // false || true  = 1 (true)
!(x < 5 && x < 10) // !(false)        = 1 (true)

unsigned int a = 60; /* 60  = 0011 1100 */
unsigned int b = 13; /* 13  = 0000 1101 */
int c = 0;

c = a & b;   /* 12  = 0000 1100 — AND */
c = a | b;   /* 61  = 0011 1101 — OR  */
c = a ^ b;   /* 49  = 0011 0001 — XOR */
c = ~a;      /* -61 = 1100 0011 — NOT (one's complement) */
c = a << 2; /* 240 = 1111 0000 — left shift (×4) */
c = a >> 2; /* 15  = 0000 1111 — right shift (÷4) */

int    myNum       = 5;         // integer
float  myFloatNum  = 5.99;      // floating point number
char   myLetter    = 'D';       // single character
double myDouble    = 3.2325467; // high precision floating point

printf("%d\n",  myNum);        // %d for int
printf("%f\n",  myFloatNum);   // %f for float
printf("%c\n",  myLetter);     // %c for char
printf("%lf\n", myDouble);     // %lf for double

// Replace all MAX_ARRAY_LENGTH occurrences with 20
#define MAX_ARRAY_LENGTH 20

// Include standard library header (angle brackets = system path)
#include <stdio.h>

// Include your own header (quotes = current directory)
#include "myheader.h"

#undef FILE_SIZE
#define FILE_SIZE 42   // undefine then redefine

#include <stdio.h>

int main() {
  printf("File :%s\n", __FILE__);
  printf("Date :%s\n", __DATE__);
  printf("Time :%s\n", __TIME__);
  printf("Line :%d\n", __LINE__);
  printf("ANSI :%d\n", __STDC__);
}

// Backslash \ continues the macro to the next line
#define message_for(a, b) \
    printf(#a " and " #b ": We love you!\n")

#include <stdio.h>

#define message_for(a, b) \
  printf(#a " and " #b ": We love you!\n")

int main(void) {
  message_for(Carole, Debra);

  return 0;
}
// Output: Carole and Debra: We love you!

#include <stdio.h>

// token34 is built by pasting "token" and the argument "34"
#define tokenpaster(n) printf("token" #n " = %d", token##n)

int main(void) {
  int token34 = 40;
  tokenpaster(34);   // expands to: printf("token34 = %d", token34)

  return 0;
}

#include <stdio.h>

// If MESSAGE is not yet defined, define it with a default value
#if !defined (MESSAGE)
   #define MESSAGE "You wish!"
#endif

int main(void) {
  printf("Here is the message: %s\n", MESSAGE);
  return 0;
}

// Regular function version
int square(int x) {
  return x * x;
}

// Macro version — no type, no call overhead, but no type checking
// Wrap args in () to prevent precedence bugs
#define square(x) ( (x) * (x) )

// No space between macro name and ( — space would break it!

#include <stdio.h>

// MAX returns the larger of x and y — works for any type
#define MAX(x,y) ( (x) > (y) ? (x) : (y) )

int main(void) {
  printf("Max between 20 and 10 is %d\n", MAX(10, 20));
  // => Max between 20 and 10 is 20

  return 0;
}

// DECLARATION (prototype) — tell compiler this function exists
void myFunction();

// main — calls myFunction before it is defined below
int main() {
  myFunction();   // CALL the function
  return 0;
}

// DEFINITION — actual code for the function
void myFunction() {
  printf("Good evening!");
}

void myFunction() {
  printf("Good evening!\n");
}

int main() {
  myFunction();   // first call
  myFunction();   // second call — same output again

  return 0;
}
// Output:
// Good evening!
// Good evening!

// One parameter, returns int
int myFunction(int x) {
  return 5 + x;
}
int main() {
  printf("Result: %d", myFunction(3));  // => 8
  return 0;
}

// Two parameters
int add(int x, int y) {
  return x + y;
}
int main() {
  printf("Result: %d", add(5, 3));   // => 8
  int result = add(5, 3);
  printf("Result = %d", result);         // => 8
  return 0;
}

int sum(int k);

int main() {
  int result = sum(10);
  printf("%d", result);   // => 55  (1+2+...+10)
  return 0;
}

int sum(int k) {
  if (k > 0) {
    return k + sum(k - 1);  // recursive call with k-1
  } else {
    return 0;               // base case — stops recursion
  }
}

#include <math.h>

void main(void) {
  printf("%f", sqrt(16));   // => 4.000000  (square root)
  printf("%f", ceil(1.4));  // => 2.000000  (round up)
  printf("%f", floor(1.4)); // => 1.000000  (round down)
  printf("%f", pow(4, 3));   // => 64.000000 (4 to the power 3)
}

// Declaration (prototype) — return_type name(param_types);
void myFunction();

// Definition — same signature + body in { }
void myFunction() {
  // code to execute (definition)
}

// Declare a struct type called MyStructure
struct MyStructure {
  int  myNum;     // member: integer
  char myLetter;  // member: character
};                // MUST end with semicolon

struct myStructure {
  int  myNum;
  char myLetter;
};

int main() {
  // Create variable s1, assign members individually
  struct myStructure s1;
  s1.myNum    = 13;
  s1.myLetter = 'B';

  // Create variable s2, initialize with brace initializer
  struct myStructure s2 = {13, 'B'};

  printf("My number: %d\n", s1.myNum);    // => 13
  printf("My letter: %c\n", s1.myLetter);  // => B
  return 0;
}

#include <string.h>

struct myStructure {
  int  myNum;
  char myLetter;
  char myString[30];   // string member (char array)
};

int main() {
  struct myStructure s1;

  // Must use strcpy() to assign a string after declaration
  strcpy(s1.myString, "Some text");

  printf("my string: %s", s1.myString);
  return 0;
}

struct myStructure s1;
struct myStructure s2;

s1.myNum    = 13;
s1.myLetter = 'B';

s2.myNum    = 20;   // completely independent data
s2.myLetter = 'C';

struct myStructure s1 = {
  13, 'B', "Some text"
};

struct myStructure s2;
s2 = s1;   // s2 now has an exact copy of all s1 values

struct myStructure s1 = {13, 'B'};

// Modify individual members
s1.myNum    = 30;    // changed from 13 to 30
s1.myLetter = 'C';  // changed from B to C

printf("%d %c", s1.myNum, s1.myLetter);
// => 30 C

#include <stdio.h>

void main() {
  FILE *fp;
  char ch;

  fp = fopen("file_handle.c", "r");  // open for reading

  while (1) {
    ch = fgetc(fp);       // read one character
    if (ch == EOF) break; // stop at end of file
    printf("%c", ch);
  }
  fclose(fp);   // always close after done
}

#include <stdio.h>

void main() {
  FILE *fp;
  fp = fopen("file.txt", "w");    // open for writing

  fprintf(fp, "Hello file for fprintf..\n");

  fclose(fp);
}

#include <stdio.h>

void main() {
  FILE *fp;
  char buff[255];   // buffer to store each word

  fp = fopen("file.txt", "r");

  while(fscanf(fp, "%s", buff) != EOF) {
    printf("%s ", buff);  // print each word
  }
  fclose(fp);
}

#include <stdio.h>

void main(void) {
  FILE *fp;

  fp = fopen("myfile.txt", "w+");
  fputs("This is Book", fp);

  // Move pointer to 7 bytes from the start
  fseek(fp, 7, SEEK_SET);

  // Write starting from position 7 (overwrites " Book")
  fputs("Kenny Wong", fp);

  fclose(fp);
}

#include <stdio.h>

void main() {
  FILE *fp;
  char c;

  fp = fopen("file.txt", "r");

  // First pass — read entire file
  while( (c = fgetc(fp)) != EOF) { printf("%c", c); }

  rewind(fp);  // move pointer back to start

  // Second pass — read it again
  while( (c = fgetc(fp)) != EOF) { printf("%c", c); }

  fclose(fp);
}
// Output: Hello World! Hello World!

#include <stdio.h>

void main() {
  FILE *fp;
  int length;

  fp = fopen("file.txt", "r");

  fseek(fp, 0, SEEK_END);   // seek to end of file
  length = ftell(fp);         // position at end = file size

  fclose(fp);

  printf("File size: %d bytes", length);
}
// => File size: 18 bytes