C Programming: Syntax and Program Structure

• C is a foundational and important programming language.

C Syntax

• C syntax refers to the set of rules that govern how C programs are written and interpreted.
• A C program is a collection of statements, which are instructions to the computer.
• Statements are terminated by a semicolon (;).
• Blocks of code are enclosed in curly braces {}.
• Comments are added using // for single-line comments and /* ... */ for multi-line comments.
• C is case-sensitive, meaning that uppercase and lowercase letters are treated differently.
• Keywords are reserved words that have special meanings in C and cannot be used as identifiers.
• Identifiers are names given to variables, functions, and other program entities.
• Variables must be declared with a specific data type before they can be used.

Basic Program Structure

• A basic C program consists of a main function where the program execution begins.
• The basic structure:

#include <stdio.h>

int main() {
  // Program code goes here
  return 0;
}

• #include <stdio.h> is a preprocessor directive that includes the standard input/output library.
• int main() is the main function definition, which returns an integer value.
• return 0; indicates that the program executed successfully.

Variables and Data Types

• A variable is a named storage location that can hold a value.
• Variables must be declared with a data type, which specifies the type of value that can be stored in the variable.
• Common data types include:
  • int: Integer values (e.g., -1, 0, 1).
  • float: Floating-point values (e.g., 3.14, -2.5).
  • double: Double-precision floating-point values.
  • char: Single characters (e.g., 'a', 'B').
• Example variable declarations:

int age;
float price;
char initial;

Operators

• Operators are symbols that perform operations on variables and values.
• Common operators include:
  • Arithmetic operators: + (addition), - (subtraction), * (multiplication), / (division), % (modulus).
  • Assignment operator: = (assigns a value to a variable).
  • Comparison 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).

Control Flow Statements

• Control flow statements allow you to control 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 the condition is true
  }
  

• else statement: Executes a block of code if the condition in the if statement is false.

  if (condition) {
    // Code to execute if the condition is true
  } else {
    // Code to execute if the condition is false
  }
  

• else if statement: Chains multiple conditions together.

  if (condition1) {
    // Code to execute if condition1 is true
  } else if (condition2) {
    // Code to execute if condition2 is true
  } else {
    // Code to execute if all conditions are false
  }
  

• for loop: Executes a block of code a specific number of times.

  for (initialization; condition; increment) {
    // Code to execute repeatedly
  }
  

• while loop: Executes a block of code as long as a condition is true.

  while (condition) {
    // Code to execute repeatedly
  }
  

• do-while loop: Executes a block of code at least once, and then repeatedly as long as a condition is true.

  do {
    // Code to execute repeatedly
  } while (condition);
  

• switch statement: Selects one of several code blocks to execute based on the value of an expression.

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

Functions

• A function is a block of code that performs a specific task.
• Functions can accept input values (arguments) and return a value.
• Function definition:

return_type function_name(parameter_list) {
  // Function code
  return value;
}

• return_type is the data type of the value returned by the function.
• function_name is the name of the function.
• parameter_list is a comma-separated list of parameters (input values).
• return value; returns a value from the function.
• Example function:

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

• Function call:

int sum = add(5, 3); // sum will be 8

Pointers

• A pointer is a variable that stores the memory address of another variable.
• Pointers are declared using the * operator.
• Example pointer declaration:

int *ptr; // ptr is a pointer to an integer

• The & operator is used to get the address of a variable.

int num = 10;
ptr = # // ptr now stores the address of num

• The * operator is also used to dereference a pointer (access the value at the address stored in the pointer).

int value = *ptr; // value will be 10 (the value of num)

Arrays

• An array is a collection of elements of the same data type, stored in contiguous memory locations.
• Arrays are declared with a data type and a size.
• Example array declaration:

int numbers[5]; // An array of 5 integers

• Array elements are accessed using an index (starting from 0).

numbers[0] = 10; // Assigns 10 to the first element of the array
int first_number = numbers[0]; // Accesses the first element of the array

Strings

• In C, a string is an array of characters terminated by a null character ('\0').
• Example string declaration:

char message[] = "Hello";

• The string.h library provides functions for working with strings, such as strcpy (copy string), strlen (string length), strcat (concatenate strings), and strcmp (compare strings).

Structures

• A structure is a user-defined data type that groups together variables of different data types under a single name.
• Structure definition:

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

• Creating a structure variable:

struct Person person1;

• Accessing structure members using the . operator:

strcpy(person1.name, "John Doe");
person1.age = 30;
person1.salary = 50000.0;

File I/O

• C provides functions for reading from and writing to files using the stdio.h library.
• fopen: Opens a file.
• fclose: Closes a file.
• fprintf: Writes formatted output to a file.
• fscanf: Reads formatted input from a file.
• fgetc: Reads a single character from a file.
• fputc: Writes a single character to a file.

Memory Management

• C allows dynamic memory allocation using the malloc, calloc, realloc, and free functions from the stdlib.h library.
• malloc: Allocates a block of memory.
• calloc: Allocates a block of memory and initializes it to zero.
• realloc: Resizes a previously allocated block of memory.
• free: Deallocates a block of memory.
• It is important to free dynamically allocated memory to prevent memory leaks.