C Programming Week 1

Introduction to C Programming

• CST8234 - C Programming course, Week 1
• Course offered at Algonquin College

About C Programming

• Developed in 1972 at Bell Labs
• One of the most established programming languages
• Initially known as the development language for UNIX
• One of the world's most senior computer programming languages
• Used to develop high-performance systems, like operating systems (OS), real-time operating systems (RTOS), embedded systems, and communication systems (comms systems)
• Key role in major desktop operating systems (partially written in C): Windows, macOS, and Linux
• Used in popular web browsers (Google Chrome, Mozilla Firefox)
• Used in database management systems (Microsoft SQL Server, Oracle, MySQL)

Development Environments

• Microsoft Visual Studio 2019 Community Edition (Windows)
• Clang in Xcode (macOS)
• GCC (GNU Compiler Collection) in a shell (Linux)
• GCC in a Docker Container (running GCC)
• C11 and C18 Standards (bug fixes in 2018)
• Doesn't support object-oriented programming (OOP) features

Key Characteristics

• Procedural language: Focuses on procedures or functions
• Low-level access: Provides direct access to memory and hardware
• Portability: Code can run on different machines with minimal modifications
• Standards-based: Adheres to ANSI standards for consistency across platforms
• Predictable behavior: No unexpected garbage collection, memory management under programmer's control
• Rich library support: Includes a standard library with built-in functions for I/O and memory allocation
• Structured language: Supports structured programming with control flow constructs
• Static typing: Requires explicit declaration of variable types, improving type safety and performance
• Modularity: Encourages code reuse through functions and modular programming
• Pointer arithmetic: Allows direct manipulation of memory through pointers, providing fine-grained control

Computer Organization

• Logical Units
  • Input Unit: Captures and makes data/programs accessible
  • Output Unit: Sends processed data to output devices
  • Memory Unit (Fast-access): Stores data for immediate processing
  • Data in memory is volatile and typically lost when power is off
  • Primary Memory (RAM): 8 to 16 GB (commonly), up to 128 GB
  • Byte: 8 bits; bit is 0 or 1; GB = gigabytes
• Arithmetic and Logic Unit (ALU): Performs arithmetic and logical comparisons
• Central Processing Unit (CPU): Manages and coordinates other units
  • Directs input unit to load data into memory
  • Instructs ALU to perform calculations
  • Commands output unit to send data to output devices
• Multicore Processors: Modern CPUs often have multiple cores for simultaneous operations
• Secondary Storage Unit: Provides persistent and long-term storage of programs/data
  • Access time is slower to access, but more cost-effective
  • Modern storage sizes are measured in terabytes (TB), and storage includes SSD, USB drives, hard drives, read/write Blu-ray drives

Data Hierarchy in C

• Bit: Smallest unit (binary state: 0 or 1)
• Field: Group of bits (e.g., name, age)
• Character: Digits, letters, and other symbols (ASCII or Unicode)
• Records: Grouping of related data (e.g., employee record)
• Files: Group of related records
• Database: Organized collection of data for easy access/manipulation

Programming Languages Overview

• Machine Languages: Binary code directly understood by hardware
• Assembly Languages Uses abbreviated English-like instructions
• High-Level Languages: Designed to resemble natural language for easier programming

When Programming in C...

• Standard library functions
• Open-source C library functions
• Functions users create
• Functions created by others

The C Standard Library

• Collection of Pre-written Functions and Macros
• Purpose: Input/output, memory management, string manipulation, and computations
• Header Files: <stdio.h>, <stdlib.h>, <string.h>, <math.h>
• Standard Functions: printf(), scanf(), malloc(), free(), strlen(), sqrt()

Open-Source Libraries

• Libraries developed and maintained by the open-source community
• Purpose: Extend C functionality with additional tools/utilities/features
• Examples: GNU C Library (glibc), libcurl, SQLite

Combining Libraries

• C programs typically use both standard and open-source libraries
• Open-source library installation and linking often requires package managers or manual installation

Other Programming Languages

• C++: Object-Oriented programming language built on C
• Python: Object-oriented language used for data science, analysis (1991)
• Java: Object-oriented programming language (1991), widely used in enterprise apps, web servers,and consumer devices, supports "Write once, run anywhere" slogan
• R: Open source Language for statistical computing and data visualization

Typical C Program-Development Environment

• Program Development Environment: Full setup for writing, managing, debugging, and testing C programs (text editors, IDEs, etc.)
• C Language: Programming language
• C Standard Library: Collection of pre-written functions/macros for common tasks

Integrated Development Environments (IDEs)

• Visual Studio Code (VSC): Open source code editor
• Vim: Open source text editor, suitable for CMake integration

Running C Code in a Linux Environment

• Write the C code
• Compile using a compiler (gcc or clang)
• Run the executable program

Common gcc Command-Line Arguments

• -g: Debugging information
• -c: Compiles to object file without linking
• -wall: Generates all standard warnings to identify potential issues
• -wextra: Provides additional warnings beyond -wall
• -pedantic: Enforces strict adherence to the C standard
• -ansi: Disables GCC-specific features, enabling ANSI C compliance

Important Information

• For practical assessments, compile code with "ANSI" option
• Failure will result in mark loss

Debugging Run-Time Errors

• Understand error messages
• Use debugging tools (e.g., gdb)
• Test thoroughly with various inputs/conditions
• Consult documentation and the programming community

Compilation Process

• Edit source code
• Preprocess directives
• Compile code into assembly/machine code
• Link object files/libraries into executable
• Load executable into memory
• Run by CPU executing instructions

Pre-processor

• Straightforward substitution/modification of source code
• Value definitions (e.g., #define MAX_STUDENTS 500)
• Macros (object-like and function-like)

Pre-processor Directives

• Preprocessor directives start with "#".
• They are handled before the compilation process begins.
• The preprocessed output can be viewed using the -E option within gcc.
• Command-line definitions can also be used with macros within the command line directly.

Compiler

• Converts human-readable C code into machine instructions

Object Files

• Temporary files produced during compilation containing machine code
• Intermediate representations of source files which are not yet executable, but can be compiled independently from each other.
• Used for modularity in compilation.
• Used with the gcc -o ice file1.o file2.o command.

Linker

• Combines object files into a single executable
• Resolves addresses of functions/variables in different files
• Handles external references (placeholders for functions from other files)

Linker Process

• Combines compiled object files into a single executable
• Updates function/variable addresses based on their positions in the final executable

Static Linking

• Combines library code into a single executable file at compile time
• Disadvantages: Larger resulting file size and difficulties updating library
• Requires recompilation of the entire program when updates occur

Dynamic Linking

• References shared libraries at runtime
• Advantages: Smaller executable size, easier library updates

Understanding Errors (@RUNTIME)

• Fatal Errors: Cause program termination (e.g., invalid memory access)
• Nonfatal Errors: Allow completion but produce incorrect results (e.g., logical errors)

Errors from Preprocessor, Compiler, and Linker

• Preprocessor errors: Issues with preprocessor directives (#include, #define, etc.)
• Compiler errors: Syntax errors, type mismatches, undeclared variables, etc.
• Linker errors: Unresolved symbols, missing libraries, conflicts in definitions

Debugging Runtime Errors

• Understand error messages
• Utilize debugging tools (like gdb)
• Conduct thorough testing with various inputs and conditions
• Consult documentation and relevant online communities

Example Scenarios

• Segmentation Fault (invalid memory access); Debugging tools/memory access
• Compiler errors (syntax problems); Specific error code/position within the code
• Linker errors(unresolved reference); Library/function issues

Example Debugging Techniques

• Examine error messages to pinpoint error locations in the code (file, line, position)

This quiz covers the basics of C Programming, including its history, development environments, and applications. It is designed for students enrolled in CST8234 at Algonquin College. Test your understanding of C's role in modern computing systems and its relevance in various programming scenarios.