Just enough C to have fun

Main ideas / concepts covered

• Purpose of the video

  • The video is meant to help viewers play with C and learn basics, not to make them professional C programmers.
  • It also emphasizes that viewers should not use this knowledge for critical/dangerous purposes.

• How C code becomes a running program (compilation)

  • C is a compiled language:
    • Interpreter example (Python): you run code via a Python interpreter on the command line.
    • Compiler example (C): you use a compiler (e.g., Clang/GCC) to convert source code into machine code, producing a binary executable that runs on its own.
  • Examples mentioned:
    • Compile hello.c with clang into an executable (name arbitrary, e.g., executable)
    • Run the resulting executable.

• Common compiler flags (Clang/GCC)

  • -O0 / -O3: controls optimization level
    • -O0: least optimization (used in the demo so output is easier to inspect)
    • -O3: more aggressive optimization (faster/leaner)
  • -g: includes debugging symbols so you can map machine code back to source for debugging.
  • -Wall: enables all common warnings.
  • -o <name>: sets the output executable filename (default is typically a.out if omitted).
  • Notes:
    • Compilers may produce object files (not directly executable) which can later be linked into an executable.

---

Project template (structure and testing approach)

• The creator provides a toy-project template that:
  • Gives basic folder/code organization.
  • Automates common build/test commands.
  • Includes a small unit testing system.

Template structure (3 main C files)

• main.c

  • Entry point for running the program (intended to handle:
    • printing
    • user input)
  • Should mostly not contain implementation logic.

• lib.c (implementation file)

  • Where the actual functions for “the library” go.
  • Typically the functions you would unit test.

• test/lib.c (unit test file)

  • Designed for testing implementation functions, not main.c.
  • Uses:
    • assert-style checks
    • macros that behave like C compile-time find/replace
  • Includes a way to compare strings (since C lacks a direct == for strings) using strcmp-like behavior.
  • A main function runs all test cases.

Extra development tool mentioned

• Uses watch (installed via Homebrew on macOS) to refresh command output while editing, reducing manual reruns during the video.

---

C syntax walkthrough (fast overview)

Includes

• Standard libraries are not automatically included:
  • Use angle brackets for system headers:
    • #include <stdio.h> (input/output)
    • #include <string.h> (string functions)
• Include local project headers/source files with quotes:
  • #include "somefile.h" (or .c, though the video warns this is not best practice)
• Best practice note:
  • In professional projects, you typically include header files and link against compiled .c files, rather than #includeing .c directly.

Functions

• General form:
  • return_type function_name(parameters...) { ... }
• Example discussed:
  • int main(int a, int B) { ... }
• Notes:
  • Statements end with semicolons.
  • return <value>; exits the function immediately.
  • Recursion is possible in C.

Key limitation: returning arrays/strings

• C generally cannot return arrays directly.
• This includes strings (since strings are arrays of char).
• Usual workarounds appear later in the video (memory handling).

Printing

• puts(string):
  • prints a string with a newline
  • no string interpolation exists in C
• printf(format_string, ...):
  • uses format specifiers (placeholders) and extra arguments
  • format specifiers influence how values are printed.

Loops and conditionals

• while loop:
  • condition checked; loop runs until condition becomes false.
• for loop:
  • initialization; condition; increment step.
• break and continue:
  • behave like in other languages (break exits loop, continue jumps to next iteration).
• if / else if / else:
  • standard conditional branching.
• Logical operators:
  • && (and), || (or)
• Comparison operators:
  • ==, !=, <, > etc.
• Note:
  • C has no power operator; use functions (e.g., from math.h) if needed.

Data types

• C has fewer built-in types, but more variants by size/signedness:
  • signed/unsigned integers, different integer widths (e.g., long long)
  • floating point numbers
  • characters (treated like “letter” values)
  • size_t:
    • represents sizes/lengths and can hold sizes/addresses relevant to memory on the machine.

Arrays

• Arrays in C:
  • are fixed-size blocks of memory (not growable automatically)
  • do not have built-in “list” helpers like reverse/length functions.
• Declaration syntax:
  • element type first, variable name second, size in brackets:
    • int numbers[10];
• Uninitialized arrays contain “junk” values; initialization is typically needed.

Strings

• In C, strings are null-terminated arrays of char:
  • must end with a null byte ('\0' / zero byte).
• Risk:
  • if you forget the null terminator, string functions can read past the buffer (security issues).

Structs (instead of classes/objects)

• C uses struct:
  • define a record-like type (e.g., person with name and height)
  • access fields via dot syntax: person.name, etc.
• Order of operations for execution:
  • When compiling an executable, main runs.

main function behavior

• int main(void)-style:
  • can also take command-line args:
    • argument count (argc)
    • array of strings (argv)
• Return value:
  • 0 indicates success; non-zero indicates failure chosen by the programmer.

---

Memory and “how to return strings/arrays” (core methodology)

The video presents three approaches to the problem “return a concatenated string from a C function”.

Definitions used in the examples

• my_strcat / “string concatenate” conceptually:
  • takes two strings A and B
  • produces A + B

---

Approach 1 (does NOT work): return an array/local buffer directly

• Strategy:
  • Create a local character array buffer inside the function.
  • Use something like sprintf(buffer, "%s%s", A, B) to fill it.
  • Return it (or a pointer to it).
• Why it fails:
  • Local memory (e.g., stack variables) is invalidated after the function returns.
  • Subsequent calls (e.g., printf) can reuse that memory, causing garbage output.

---

Approach 2 (partially works but fails later): return a pointer to a local buffer

• Strategy:
  • Similar to Approach 1, but the function returns a pointer.
• Outcome described:
  • It might appear to work briefly.
  • It still breaks after another function call because the pointed memory was on the stack and gets overwritten.

---

Approach 3 (works): caller-provided buffer (buffer output parameter)

• Strategy (common C pattern):
  • The caller allocates/provides the output buffer.
  • The function receives a pointer to that buffer and writes into it.
  • The function returns void (or otherwise returns only status), but the actual string result lives in caller-owned memory.
• Key concept:
  • C “array pointer decay”:
    • when passing strings to functions, array parameters are treated as pointers.

Method steps (detailed)

• In the caller:
  • Create result as a character array (on stack) of a fixed size (e.g., 5 chars including end terminator in examples).
  • Call concatenate function with:
    • result buffer
    • string A
    • string B
• In the callee:
  • Use snprintf/sprintf-like functionality to write concatenation into the provided buffer.
  • Do not return the string pointer (since caller already has it).

---

Buffer overflow and the safer printing function

Problem

• If the caller’s buffer is too small and you use sprintf, it can write past the end of the buffer.
• This causes buffer overflow, potentially overwriting other variables and creating security vulnerabilities.

Defense methodology: snprintf

• Use:
  • snprintf(dest, buffer_length, format, ...)
• Required extra argument:
  • the maximum number of bytes/characters to write (buffer length), typically sizeof(result) or a known constant.
• Video notes:
  • snprintf stops before overflow.
  • It also provides useful return information (including how many bytes it would have written).

---

Heap allocation approach (alternative methodology)

When it’s used

• Allocate a new string on the heap and return a pointer to it.

Method steps (detailed)

• In the caller:
  • Declare char* result (pointer, initially empty).
  • Call concatenate function that returns char*.
• In the callee:
  • Compute needed allocation size:
    • length(A) + length(B) + 1 for null terminator
  • Allocate using malloc:
    • malloc(bytes_needed)
  • Fill memory using sprintf/similar into the allocated heap buffer.
  • Return the heap pointer to the caller.

Catch: manual memory management

• Heap allocations persist until freed.
• Must call free(result) in the caller when done.
• If you forget, you get memory leaks (memory grows over time, especially bad in long-running programs like servers).

Recommendation made in the video

• Prefer the “caller-provided buffer” approach when possible because:
  • it avoids leaks and clarifies ownership (caller owns the buffer and its lifetime).

---

Exercises assigned at the end

1. FizzBuzz (string/buffer version)

   • Build the FizzBuzz sequence as a string instead of just printing directly.
   • Focus is on practicing buffers and string operations.

2. Prime generator (“prime sieve” style)

   • Generate primes by eliminating non-primes from a list/array.

3. Number-to-words converter

   • Convert numbers like 74 into the word form (“seventy four” style).
   • Challenge scales to very large numbers.

4. “Final exercise for members”

   • Mentioned as available for supporting members (details not included in the subtitles).

---

Speakers / sources featured

• Video narrator / instructor (unnamed in subtitles; the person explaining compilation, syntax, memory, and exercises).
• YouTube channel/project: “o” (mentioned as a project/channels ecosystem; exact full name not provided in subtitles).
• Compilers/tools mentioned as sources of functionality:
  • clang
  • GCC (noted as linking to clang on macOS)
  • CC (generic compiler command mentioned)
  • makefile / make
  • watch tool
• System/library names referenced:
  • C standard libraries: stdio.h, string.h, stdlib.h, and math library (via mention of math.h).