Data Types and Control Structures

Data Types

• Integer Types: int, short, long, long long. Each has a different size and range (e.g., short typically smaller than int). Unsigned integers are possible (unsigned int).
• Floating-Point Types: float, double, long double. Represent real numbers; double generally provides sufficient precision.
• Character Type: char. Stores single characters; often used as an integer representing a character's ASCII value.
• Boolean Type: NOT a built-in type. int (0 or 1) is typically used as a substitute
• Sizeof Operator: sizeof() returns the size (in bytes) of a type or variable. Useful to understand memory allocation. E.g., sizeof(int), sizeof(myVariable).
• Declaration Examples:
  • int age = 30;
  • float price = 9.99;
  • char initial = 'J';

Control Structures

• if-else Statements: Conditional execution based on boolean expressions.
• switch Statements: Multi-way branching based on integer values.
• for Loops: Iterative execution with initialization, condition, and increment/decrement.
• while Loops: Iterative execution as long as a condition is true.
• do-while Loops: Iterates at least once. The condition is checked after each execution.
• break Statement: Jumps out of a loop or switch.
• continue Statement: Skips to the next iteration of a loop.
• Nested Loops: Loops inside of other loops.
• Logical Operators: && (AND), || (OR), ! (NOT) – used to combine conditions in control structures.

Functions

• Function Definition: Declares a function's parameters and return type. Contains code to perform a specific task.
• Function Prototype: Declaration outside the main function, telling the compiler about the function's parameters and return type before use.
• Function Calling: Invoking a function to execute its code block.
• Return Values: Functions can return a value to the calling part of the program.
• Parameter Passing: Values can be passed to a function as arguments. Note call by value (copies values) and call by reference (modifies original values, not common).
• Void Functions: Functions that do not return a value. Typically use void as the return type.
• Example Function:

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

Arrays and Pointers

• Arrays: Ordered collections of elements of the same data type. Access elements using an index (starting at 0).
  • Declaration example: int numbers[5] = {1, 2, 3, 4, 5};
    • Accessing: numbers[0]
• Pointers: Variables that hold memory addresses. Used to access and manipulate data in memory.
  • Declaration Example: int *ptr; (declares a pointer named ptr that can hold addresses of integers).
  • Pointer dereferencing: *ptr (accesses the value at the address stored in ptr) Used to access and modify data.
    • Example: int num = 10; int *ptr = # *ptr = 20; (changes num to 20).
• Array Indexing vs. Pointer Arithmetic: numbers[i] is equivalent to *(numbers + i). You can use pointer arithmetic (e.g., ptr++) to traverse an array and make changes to members. - Important Considerations: Array bounds checking. C does not automatically check if you're accessing an array element outside its valid range. This can lead to program crashes or unexpected behavior.
• Pointers and Memory Allocation: malloc(), calloc(), realloc(), are essential for dynamic memory allocation (allocating memory at runtime). free() frees memory when no longer needed. These are crucial for handling potentially large amounts of data.
• Null Pointers: NULL, a special pointer value representing 'no address.'

Input and Output

• Standard Input/Output: stdin (standard input), stdout (standard output), stderr (standard error).
• printf(): Used for formatted output to the console using specific format specifiers for different data types (e.g., %d for integers, %f for floats). - Example: printf("The value is: %d", 10);
• scanf(): Reads formatted input from the console. Requires format specifiers (e.g., %d, %f) to correctly interpret the input.
• Example: scanf("%d", &num);
• File I/O: Handling data from and to files using functions like fopen(), fclose(), fscanf(), fprintf(), fread(), fwrite(). Requires file pointers. It's how programs interact with external data.
• Error Handling: It is necessary to check for errors from these input/output functions (e.g., file open issues, invalid input format). Using perror() and checking return values is typical.

Test your knowledge on data types and control structures in programming. This quiz covers integer types, floating-point types, character type, and the usage of control statements. Enhance your understanding of how data types affect memory allocation and decision-making in code.