Introduction to C Programming

• C is a high-level, general-purpose programming language widely used for system programming and application development
• It emphasizes efficiency and control over hardware resources
• C balances low-level access with high-level abstractions

Basic Structure of a C Program

• A C program consists of one or more functions, with main being the entry point
• It includes preprocessor directives, declarations, definitions, and statements
• The basic structure is:

#include <stdio.h>

int main() {
  // statements
  return 0;
}

• #include <stdio.h> is a preprocessor directive that includes standard input/output library
• int main() is the main function where program execution begins
• return 0; indicates successful program termination

Header Files

• Header files contain declarations of functions, variables, and macros
• They are included using the #include preprocessor directive
• Examples include stdio.h for standard I/O, stdlib.h for general utilities, and math.h for mathematical functions
• The syntax is #include <header_file.h> for standard library headers and #include "header_file.h" for user-defined headers

Variables and Data Types

• Variables are used to store data
• Each variable has a specific data type, such as int, float, char, and double
• int stores integers
• float stores single-precision floating-point numbers
• double stores double-precision floating-point numbers
• char stores characters
• Variables must be declared before use, specifying their type and name, e.g., int age;
• Variables can be initialized during declaration, e.g., int age = 25;

Operators

• C provides various operators for performing operations on variables and values
• Arithmetic operators: + (addition), - (subtraction), * (multiplication), / (division), % (modulus)
• Relational operators: == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), <= (less than or equal to)
• Logical operators: && (logical AND), || (logical OR), ! (logical NOT)
• Assignment operators: =, +=, -=, *=, /=, %=
• Increment/decrement operators: ++ (increment), -- (decrement)

Control Flow Statements

• Control flow statements determine the order in which statements are executed
• if statement: executes a block of code if a condition is true

if (condition) {
  // code to execute if condition is true
} else {
  // optional code to execute if condition is false
}

• switch statement: selects one of several code blocks based on the value of a variable

switch (variable) {
  case value1:
    // code to execute if variable == value1
    break;
  case value2:
    // code to execute if variable == value2
    break;
  default:
    // optional code to execute if variable doesn't match any case
}

• for loop: executes a block of code repeatedly for a specified number of iterations

for (initialization; condition; increment/decrement) {
  // code to execute in each iteration
}

• while loop: executes a block of code repeatedly as long as a condition is true

while (condition) {
  // code to execute as long as condition is true
}

• do-while loop: similar to while loop, but the code block is executed at least once

do {
  // code to execute
} while (condition);

Functions

• Functions are self-contained blocks of code that perform a specific task
• They can accept arguments and return values
• Function definition:

return_type function_name(parameter_list) {
  // function body
  return value; // if return_type is not void
}

• Function declaration (prototype): return_type function_name(parameter_list);
• Calling a function: function_name(arguments);
• Example:

int add(int a, int b) {
  return a + b;
}

int main() {
  int sum = add(5, 3);
  return 0;
}

• void return type indicates that the function does not return a value

Arrays

• Arrays are collections of elements of the same data type
• Elements are stored in contiguous memory locations
• Array declaration: data_type array_name[array_size];
• Array access: array_name[index], where index starts from 0
• Example:

int numbers[5]; // declares an integer array of size 5
numbers[0] = 10; // assigns 10 to the first element

• Multidimensional arrays can be declared as data_type array_name[size1][size2];

Pointers

• Pointers are variables that store memory addresses
• They are used to indirectly access and manipulate data
• Pointer declaration: data_type *pointer_name;
• Address-of operator: & (returns the memory address of a variable)
• Dereference operator: * (accesses the value stored at the memory address pointed to by the pointer)
• Example:

int age = 25;
int *age_ptr = &age; // age_ptr stores the address of age
int value = *age_ptr; // value is now 25 (the value at the address stored in age_ptr)

• Pointers are commonly used for dynamic memory allocation and passing arguments to functions by reference

Strings

• Strings in C are arrays of characters terminated by a null character \0
• String declaration: char string_name[string_size];
• String manipulation functions are available in the string.h header file
• Common functions include strcpy (copy string), strlen (string length), strcat (concatenate strings), strcmp (compare strings)
• Example:

char name[20] = "John";
int length = strlen(name); // length is 4

Structures

• Structures are user-defined data types that group together variables of different data types
• Structure definition:

struct structure_name {
  data_type member1;
  data_type member2;
  // ...
};

• Structure variable declaration: struct structure_name variable_name;
• Accessing structure members: variable_name.member_name
• Example:

struct Person {
  char name[50];
  int age;
};

int main() {
  struct Person person1;
  strcpy(person1.name, "Alice");
  person1.age = 30;
  return 0;
}

Input and Output

• Standard input/output functions are defined in stdio.h
• printf: prints formatted output to the console
• scanf: reads formatted input from the console
• Example:

int age;
printf("Enter your age: ");
scanf("%d", &age);
printf("You are %d years old.\n", age);

• %d format specifier is used for integers, %f for floats, %c for characters, and %s for strings

Memory Management

• C allows dynamic memory allocation using functions from stdlib.h
• malloc: allocates a block of memory
• calloc: allocates and initializes a block of memory
• realloc: reallocates a block of memory
• free: releases allocated memory
• Example:

int *numbers = (int *)malloc(5 * sizeof(int)); // allocates memory for 5 integers
if (numbers == NULL) {
  // handle allocation failure
}
numbers[0] = 1;
free(numbers); // releases the allocated memory

• It is crucial to free dynamically allocated memory to prevent memory leaks

Preprocessor Directives

• Preprocessor directives are commands that are processed before compilation
• #include: includes header files
• #define: defines macros (symbolic constants or inline functions)
• #ifdef, #ifndef, #endif: conditional compilation directives
• Example:

#define PI 3.14159
#define SQUARE(x) ((x) * (x))

int main() {
  float radius = 5.0;
  float area = PI * SQUARE(radius);
  return 0;
}

Common Errors and Debugging

• Syntax errors: violations of the C language rules (e.g., missing semicolon)
• Semantic errors: errors in the meaning of the code (e.g., using a variable before it's initialized)
• Logical errors: errors in the program's logic (e.g., incorrect algorithm)
• Debugging tools: compilers (for syntax errors), debuggers (for runtime errors), print statements (for tracing program execution)

Compilation and Linking

• Compilation: translates C source code into object code
• Linking: combines object code with library code to create an executable file
• Compilers like GCC are used for compiling C code
• Example:

gcc -o program program.c // compiles program.c and creates an executable named program

Importance of Syntax and Semantics

• Correct syntax is essential for the compiler to understand the code
• Proper semantics ensure that the code performs the intended operations
• Understanding both syntax and semantics is crucial for writing error-free and efficient C programs