C Programming: Structured Approach & Applications

Procedural Programming: C

• C Programming: A middle-level, general-purpose programming language developed in 1972 by Dennis Ritchie at Bell Telephone company.
• Structured Programming: Facilitates program understanding and modification through a top-down approach, dividing systems into smaller, logical modules.
• C is a Structured Programming Language: It promotes modularity by dividing code into functions and structures.

Applications of C Programming

• Operating Systems
• System Programming
• Network Programming
• Game Development
• IoT (Internet of Things)
• Telecommunications

C Programming Features

• Simple and Clear: Relatively easy to understand and use.
• Small in Size: The compiler is compact, making it suitable for smaller systems.
• Structured Language (Top-Down Approach): Focuses on dividing code into logical blocks.
• Middle-Level Language: Offers control over hardware while maintaining a high level of abstraction.
• Portable: Code can be compiled and run on different platforms with minimal modifications.
• Modularity: Code is broken down into smaller, reusable functions, improving maintainability.
• Case Sensitive: Uppercase and lowercase letters are treated differently.
• Easy Error Detection: The compiler effectively identifies and reports errors.
• Building Block for Other Languages: Concepts and syntax of C have influenced many other programming languages.
• Powerful and Efficient Language (Robustness): Supports low-level operations and provides efficient memory management.
• Built-in Functions and Keywords: Provides standard functions and keywords for common programming tasks.

Basic Structure of a C Program

• Documentation Section: Comments that explain the program's purpose.
• Link Section: Directives (#include) to connect the program with external libraries.
• Definition Section: Defines symbolic constants using #define.
• Global Declaration Section: Declares variables and functions that are accessible throughout the program.
• main() Function: The primary function of the program, it contains the executable statements.
  • Declaration Part: Declares variables used within the main() function.
  • Executable Part: Contains the instructions to be executed by the program.
• Subprogram Section: Defines user-defined functions that are called within the main function.

Standard Directories in C

• C Standard Directories/Libraries: Provide a collection of pre-defined functions, macros, and utility functions for various tasks.
• stdio.h: Mandatory header file for input/output operations, containing functions like printf(), scanf(), etc.
• conio.h: Optional header file used for console input/output operations, like getch(), clrscr(), etc.
• string.h: Header file containing functions for string manipulation, like strlen(), strcpy(), strcat(), etc.

Character Set in C

• Letters/Alphabets: Uppercase (A-Z) and lowercase (a-z).
• Digits: Numbers (0-9).
• Special Characters: Symbols like ;, {}, ' ', " ", +, -, *, /, %, =, etc.
• White spaces: Used for separation, including tabs (\t) and newlines (\n).

Tokens in C

• Tokens: The smallest meaningful units of a C program understood by the compiler.
• Examples of Tokens:
  • Keywords: Data types (int, float, etc.).
  • Operators: Arithmetic operators (+, -, *, /, %).
  • Punctuation Marks: Semicolon (;), Braces {}, etc.
  • Constants: Fixed values within the program.

Keywords in C

• Keywords (Reserved Words): Special words with predefined meanings that cannot be redefined.
• There are 32 keywords in C.

Identifiers in C

• Identifiers: User-defined names for variables, functions, arrays, etc.
• Rules for Identifiers:
  • Composed of letters, digits, and underscore (_).
  • Must start with a letter or underscore.
  • Only the first 32 characters are significant.
  • Cannot be the same as keywords.
  • Case-sensitive ( count and Count are different).

Variables in C

• Variables: Placeholders in memory that store data temporarily.
• Characteristics of Variables:
  • Each variable has a unique identifier.
  • Their values can be modified during program execution.
  • Belong to a specific data type (e.g., int, float, char).

Rules for Variable Names

• Must start with a letter or underscore (_).
• Can include uppercase and lowercase letters, digits, and underscore (_).
• The first 32 characters are significant.
• Cannot be keywords.
• Case-sensitive.
• White spaces are not allowed.
• Special characters are not allowed.

Data Types in C

• Data Types: Define the type of data a variable can hold, determining its size, range, and operations.

Declaration of Variables

• Syntax: data_type variable_name1, variable_name2, ..., variable_nameN;
• data_type is a valid C data type.
• variable_name1, variable_name2, etc. are the variable names.
• Example: int a; float num1; char c1, c2, c3;

Initialization of Variables

• Assigning Values: Variables are given values using the assignment operator (=).
• Syntax: variable_name = value;
• Example: max = 10; a = 2.5;
• Initialization at Declaration:
  • data_type variable_name = value;
  • Example: int length = 5;

Examples of Data Types in C

#include <stdio.h>

int main() {
  char c = 'N';
  int i = 123;
  float f = 10.23;
  double d = 345.6789;

  printf("%c", c);
  printf("%d", i);
  printf("%f", f);
  printf("%lf", d);

  return 0;
}

Addition of Two Numbers

#include <stdio.h>

int main() {
  int a, b, sum;

  a = 10;
  b = 20;
  sum = a + b;

  printf("Addition of a and b is %d", sum);

  return 0;
}

Dynamic Initialization

• Dynamic Initialization: Assigning values to variables at runtime, rather than during compilation.
• User Input: The scanf() function is used to get input from the user.
• Syntax: scanf("format_specifier", &variable_name);
• Example: scanf("%d",&a);

Addition with Dynamic Initialization

#include <stdio.h>

int main() {
    int a, b, sum;

    scanf("%d %d", &a, &b); 
    sum = a + b;

    printf("Addition of a and b is: %d\n", sum);

    return 0;
}

Constants in C

• Constants: Variables whose values cannot be changed during program execution.
• Types of Constants:
  • Symbolic Constants
  • Constants with the const keyword

Symbolic Constants

• Symbolic Constants (Macros): Defined using the #define directive.
• Syntax: #define variable_name constant_value
• Example: #define PI 3.14
• Advantages:
  • Improve code readability.
  • Reduce redundancy by defining values in one place and using them throughout the program.

Example of Symbolic Constants

#include <stdio.h>
#define PI 3.14

int main() {
  float r = 7.5;
  float area = PI * r * r; 

  printf("Area of circle is: %f", area);

  return 0;
}

const Keyword

• const Keyword: Creates constant variables by attaching the const keyword in the declaration.
• Syntax: const data_type constant_variable_name = constant_value;
• Example: const int max = 5;
const float pie = 3.14;

enum in C

• enum (Enumeration): A user-defined data type in C that assigns names to integral constants.
• Purpose: Improves code readability and maintainability.
• Syntax: enum enum_name {constant1, constant2, constant3, ... };
• Example: enum color {red, green, blue}; enum week {mon, tue, wed, thu, fri, sat, sun}; enum month {jan, feb, mar, apr, ... dec};

Example of enum

#include <stdio.h>

enum week {Mon, Tue, Wed, Thur, Fri, Sat, Sun};

int main() {
  enum week day;
  day = Wed;
  printf("%d", day); // Output: 2 (assuming enum values are assigned sequentially)

  return 0;
}

enum Example (2)

#include <stdio.h>

enum year {Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec};

int main() {
  int i;

  for (i = Jan; i <= Dec; i++) {
    printf("%d\n",i); // Output: 0, 1, 2 ... 11 (assuming enum values assigned sequentially)
  }

  return 0;
}