C/C++ Programming Fundamentals and History

History & Importance of C/C++

C/C++ developed to provide flexibility and efficiency in software development
C/C++ has become the foundation for various software applications, including operating systems, game engines, and embedded systems.
Its versatility makes it a highly sought-after skill for programmers and developers.

C/C++ Programming Fundamentals

Components: Language includes keywords, identifiers, operators, constants, and variables
Basic Structure: Programs are organized into functions.
Character Set: Includes letters, digits, special symbols, and whitespace characters.
Tokens: Smallest units of a program, like keywords, identifiers, operators, constants, and variables.
Keywords: Reserved words with predefined meanings, like int, float, char, if, else, while, etc.
Identifiers: Names given to program elements, like variables, functions, etc. Must follow specific rules.

Data Types

Basic Data Types: Built-in types for storing different types of data, like int, float, char, double.
Enumerated Data Types: Users can define their own data types with a set of named integer constants, like enum Days = {Mon, Tue, Wed, Thu, Fri, Sat, Sun};
Derived Data Types: Created from basic data types, including arrays, pointers, structures, and unions

Constants & Variables

Constants: Values that cannot be changed during program execution, often denoted by const keyword.
Variables: Hold data that can be changed during program execution, and are declared with specific data types.
Symbolic Constants: Named constants defined using #define preprocessor directive for better readability and maintainability.
Overflow and Underflow: Occurs if a variable's value exceeds the maximum or falls below the minimum possible limit for its data type.

Operators & Expressions

Arithmetic Operators: Perform mathematical operations like addition, subtraction, multiplication, division, and modulo.
Relational Operators: Compare values and return a boolean (true or false) result, such as greater than ( > ), less than ( < ), equal to ( == ), not equal to ( != ), etc.
Logical Operators: Combine boolean expressions using AND (&&), OR (||), and NOT (!) operators.
Assignment Operators: Assign values to variables, using '=' for simple assignment or +=, -=, *=, /= for combined assignment and operation.
Increment/Decrement Operators: Increase or decrease the value of a variable by 1, using ++ for increment and -- for decrement.
Operator Precedence: Determines the order in which operators are evaluated in an expression.
Type Conversions: Implicit conversion happens automatically between compatible data types, while explicit conversions are performed using type cast operators.

Input & Output Operations

Formatted I/O: Uses printf for outputting text and scanf for inputting data, allowing formatting options to control the appearance of data.
Unformatted I/O: Uses functions like gets and puts for simpler input and output, but with limited formatting options.

Decision Making & Branching

if...else Statement: Executes different blocks of code based on a condition.
Nested if...else: One if...else statement within another to create more complex decision-making structures.
else if Ladder: Allows multiple conditions to be tested sequentially, executing the first block that evaluates to true.
switch Statement: More efficient for multi-way branching based on the value of a single expression.
Conditional (?) Operator: A concise way to express an if...else condition in a single line.

Looping in C

for Loop: Ideal for iterating a certain number of times, with clear initialization, condition, and increment steps.
Nested for Loop: Allows iterating through multiple variables and creating nested loops.
while Loop: Repeats a block of code while a condition remains true, checking the condition before each iteration.
do...while Loop: Executes a block of code at least once, and then checks the condition at the end of each iteration.
Jumps: break statement to exit a loop immediately, and continue statement to skip the remaining code within the current iteration and proceed to the next iteration.

Arrays

Arrays: Data structures that store a fixed-size collection of elements of the same data type.
One-Dimensional Arrays: Linear storage of elements, accessed with a single index.
Two-Dimensional Arrays: Matrix-like storage, accessed with two indices (row and column).

Character Arrays & Strings

Character Arrays: Arrays specifically designed to store characters.
Strings: Sequences of characters that are treated as one unit. They are typically implemented using character arrays.
scanf and printf can be used for reading and writing strings from the terminal.

User-Defined Functions

Functions: Reusable blocks of code that perform specific tasks.
Definition: Includes the function name, return type, parameters, and body of code.
Return Value: The value that a function returns to the calling program.
Function Prototypes: Declare the function's name, return type, and parameters before its definition.
Function Calls: Invoking a function to execute its code block.

Function Categories

No Arguments & No Return Value: Takes no input and doesn't return any output.
Arguments but No Return Value: Takes input but doesn't return any output.
Arguments with Return Value: Takes input and returns a value to the calling program.
No Arguments but Returns a Value: Takes no input but returns a value to the calling program.
Functions that Return Multiple Values: Can return multiple values using pointers or structures.

Recursion

Recursive Function: Function that calls itself, enabling solutions for problems that can be divided into smaller, similar subproblems.

Passing Arrays to Functions

Arrays cannot be directly passed to functions, but their address is passed, using functions to modify original arrays.

Storage Class of Variables

Storage Class: Determines the scope, lifetime, and storage location of a variable.
Auto: Variables declared within a function, exist only within that function.
Static: Variables declared with static keyword, retain their value throughout the program's lifetime.
Extern: Variables declared with extern keyword, are accessible from multiple files.
Register: Variables declared with register keyword, reside in CPU registers for faster access.

Pointers

Pointers: Variables that store the memory address of other variables.
Declaration: Specifies the data type of the variable being pointed to, using * (asterisk) before the pointer variable name.
Initialization: Assigns the memory address of a variable to a pointer.
Dereferencing: Using * (asterisk) to access the value stored at the memory location pointed to by a pointer variable.
Pointer Operations: Arithmetic operations on pointers.
Increment/Decrement: Increases or decreases a pointer's address value by the size of the data type it points to.
Scale Factor: Multiplies a pointer's address value by a constant factor.

Pointers & Arrays

Relationship: Arrays and pointers are closely related. The name of an array automatically represents the address of its first element.
Arrays of Pointers: Arrays that store pointers of a specific type, pointing to different variables or memory locations.
Pointers as Function Arguments: Allow functions to modify the values of variables passed to it, as the function directly operates on the variable's memory address.
Function Returning Pointers: Functions that return pointers to specific memory locations.

Structures

Structures: User-defined data types that group variables of different data types under a single structure name.
Definition: Declares the structure type and its member variables.
Declaration: Creates structure variables of the defined type.
Initialization: Assigns values to member variables.
Accessing Members: Using the dot operator (.) to access individual members within a structure variable.
Copying & Comparison: Can be copied and compared, member by member.
Array of Structures: Collections of structure variables, each holding a specific set of data.
Structure Pointers: Point to the starting address of a structure variable.

Dynamic Memory Allocation

Dynamic Memory Allocation: Dynamic allocation functions like malloc, calloc, and free allocate and deallocate memory during program execution, enabling flexible memory management.
malloc: Allocates a block of memory of specified size and returns a pointer to the starting address.
calloc: Allocates a block of memory, initializes it to 0, and returns a pointer.
free: Deallocates a block of memory previously allocated using malloc or calloc to avoid memory leaks.

Preprocessors

Preprocessing: Operations performed before compilation, including macro substitution and file inclusion.
Macro Substitution: Replaces a macro name with its definition throughout the program.
Macro with Arguments: Take input parameters and perform operations based on the arguments provided.

File Inclusion

File Inclusion: Enables a program to use code defined in separate files by using the #include preprocessor directive.
File Handling: Includes opening a file, reading and writing data to it, and closing the file.
fopen: Opens a file for reading, writing, or appending.
fclose: Closes an open file.
fscanf & fprintf: Read and write formatted data to/from a file.