Basics of C Programming

Introduction to C
- Developed by Dennis Ritchie in the early 1970s.
- General-purpose programming language.
- Foundation for many modern programming languages (e.g., C++, C#).
Structure of a C Program
- Preprocessor Directives: Start with #, e.g., #include <stdio.h>.
- Main Function: Entry point of the program, int main() { ... }.
- Statements and Expressions: Instructions executed sequentially.
- Return Statement: return 0; indicates successful execution.
Basic Data Types
- int: Integer type.
- float: Floating point type for single-precision floating point numbers.
- double: Double-precision floating point numbers.
- char: Character type, stores a single character.
Variables and Constants
- Declaration: Define a variable type and name, e.g., int age;.
- Initialization: Assign value to a variable, e.g., age = 25;.
- Constants: Fixed values, use #define or const.
Input and Output
- Use printf() for output; format specifiers include %d, %f, %c.
- Use scanf() for input; specify the format for the input variables.
Operators
- Arithmetic Operators: +, -, *, /, %.
- Relational Operators: ==, !=, >, <, >=, <=.
- Logical Operators: &&, ||, !.
- Assignment Operators: =, +=, -=, etc.
Control Structures
- Conditional Statements: if, else if, else, switch.
- Loops: for, while, do while.
Functions
- Definition: A block of code that performs a specific task.
- Declaration: Specify return type and parameters int sum(int a, int b);.
- Calling Functions: Use the function name followed by arguments, e.g., sum(2, 3);.
Arrays
- Definition: Collection of elements of the same type.
- Declaration: int numbers[5]; defines an array of five integers.
- Accessing Elements: Use index notation, e.g., numbers[0].
Pointers
- Definition: Variable that stores the address of another variable.
- Declaration: int *ptr;.
- Dereferencing: Access value at the address using *ptr.
Standard Libraries
- Include pre-written code for common tasks.
- Examples include stdio.h for input/output and stdlib.h for memory allocation.
Compilation Process
- Preprocessing: Processes preprocessor directives.
- Compilation: Translates source code to machine code.
- Linking: Combines object files and libraries to create executable.
Error Handling
- Compile-time errors: Syntax issues detected by the compiler.
- Runtime errors: Errors that occur during program execution (e.g., division by zero).

These fundamentals lay the groundwork for further exploration of C programming, including advanced concepts like structures, file handling, and dynamic memory allocation.

Introduction to C

Developed by Dennis Ritchie in the early 1970s
General-purpose programming language
Serves as the foundation for many modern programming languages, including C++, C#

C Program Structure

Preprocessor Directives
- Start with #, for example #include <stdio.h>
Main Function
- The entry point of the program
- Defined as int main() { ... }
Statements and Expressions
- Instructions executed in sequential order
Return Statement
- return 0; indicates the program has executed successfully

Basic Data Types

int: Stores integer values
float: Single-precision floating point numbers
double: Double-precision floating point numbers
char: Stores a single character

Variables and Constants

Declaration: Define a variable type and name, for example int age;
Initialization: Assign a value to a variable, for example age = 25;
Constants: Fixed values
- Use #define or const keyword

Input and Output

Use printf() to output information
- Includes format specifiers like %d, %f, %c
Use scanf() to take input from the user
- Specify the format for the input variables

Operators

Arithmetic Operators: Include +, -, *, /, %
Relational Operators: ==, !=, >, =, <=, >=

Data Types

Basic Data Types:
- int: Stores whole numbers (e.g., 5, -10), typically using 4 bytes of memory.
- float: Represents single-precision floating-point numbers (e.g., 3.14, -2.5), usually using 4 bytes.
- double: Represents double-precision floating-point numbers (more precise than float), typically using 8 bytes.
- char: Stores a single character (e.g., 'A', '!', '$'), usually using 1 byte.
Derived Data Types:
- Arrays: Used to store collections of similar data (e.g., an array of integers, an array of characters).
- Structures: Allow you to combine variables of different data types into a single unit (e.g., a structure to store student information: name, roll number, age).
- Unions: Similar to structures, but all members share the same memory location, allowing for memory optimization.
- Enums: Provide a way to give meaningful names to integral constants (e.g., defining enum Days { Monday, Tuesday, Wednesday... }).
- Void Type:
- Represents the absence of data; functions returning void don't return a value.

Functions

Function Definition:
- Defines how a function works.
- Syntax: return_type function_name(parameter_list) { // function body }
- Example: int add(int a, int b) { return a + b; } (defines a function named 'add' that takes two integers as input, adds them, and returns the result)
Function Declaration:
- Prototype that informs the compiler about a function's name, return type, and parameters.
- Example: int add(int, int); (declares a function named 'add' that takes two integers and returns an integer)
- Function declarations are necessary before the function is called.
Function Call:
- Executes the function.
- Example: result = add(5, 3); (calls the 'add' function with arguments 5 and 3, storing the returned result in the variable 'result')
Scope of Variables:
- Local Variables: Declared within a function, visible and accessible only within that function.
- Global Variables: Declared outside of any function, visible and accessible throughout the entire program (including all functions).
Recursion:
- A function calling itself.
- Must have a base case to avoid infinite recursion.
- Useful for solving problems that can be broken down into smaller, similar subproblems.

Basics of C Programming

Structure of a C Program:
- Usually consists of preprocessor directives, function prototypes, the main() function, and other function definitions.
Preprocessor Directives:
- Lines that start with # that are processed before compilation.
- #include <stdio.h>: Includes the standard input/output library, providing functions like printf() and scanf().
- #define: Defines macros, which are text substitutions that are performed during preprocessing.
Main Function:
- The starting point of execution for a C program.
- Syntax: int main() { // code }
- Code inside the curly braces of the main() function is executed when the program runs.
Input/Output Functions:
- printf(): Sends formatted output to the console (e.g., printf("Hello, world!\n");).
- scanf(): Reads formatted input from the console (e.g., scanf("%d", &number);).
Control Structures:
- Conditional Statements:
  - if: Executes a block of code only if a condition is true.
  - else: Executes a block of code if the if condition is false.
  - switch: Allows for multiple comparisons based on a single variable.
- Loops:
  - for: Executes a block of code a specific number of times.
  - while: Executes a block of code repeatedly as long as a condition is true.
  - do-while: Executes a block of code at least once, then repeatedly as long as a condition is true.
Comments:
- Used to explain code without affecting its execution.
- Single-line Comment: // this is a single-line comment
- Multi-line Comment: /* This is a multi-line comment. It can span multiple lines. */
Compilation Process:
- Preprocessing:
  - Macros are expanded, included header files are processed, and comments are removed.
- Compilation:
  - The preprocessed code is translated into assembly language.
- Assembling:
  - Assembly language is converted into machine code (binary instructions that the computer can understand).
- Linking:
  - The compiled code is linked with necessary libraries (like the standard input/output library) to create an executable file.
Compilation Command:
- Typically, gcc filename.c -o outputname compiles the C code in filename.c and creates an executable file named outputname.