C Programming Beginner’s Guide: Structures, Unions, Functions & More

Differentiate Between Structure and Union

Memory Allocation:

  • Structure: Allocates separate memory for each member.
  • Union: Allocates a single shared memory space equal to the size of its largest member.

Member Access:

  • Structure: All members can be accessed independently and simultaneously.
  • Union: Only one member can be accessed at a time as they share the same memory location.


  • Structure: The size of a structure is the sum of the sizes of all its members (plus possible padding for alignment).
  • Union: The size of a union is equal to the size of its largest member.

Use Case:

  • Structure: Used when you need to group different data types and need all values stored.
  • Union: Used when you need to store different data types but only one value at a time.


  • Structure: All members can be initialized independently.
  • Union: Only the first member can be initialized at the time of declaration.

pow() Function in C


Calculates the power of a number.


pow(base, exponent)


#include <stdio.h> #include <math.h>int main() { double result = pow(2, 3); // 2 raised to the power of 3 printf("2^3 = %.2f\n", result); return 0; }

Differentiate Between Call By Value and Call By Reference

Parameter Passing:

  • Call by Value: Copies the actual value of an argument into the formal parameter of the function.
  • Call by Reference: Copies the address of an argument into the formal parameter, allowing direct modification of the actual argument.


  • Call by Value: Changes made to the parameter inside the function have no effect on the actual argument.
  • Call by Reference: Changes made to the parameter inside the function directly affect the actual argument.

Memory Usage:

  • Call by Value: Requires more memory since it involves copying the actual values.
  • Call by Reference: Requires less memory as it only copies addresses (pointers).


  • Call by Value: Generally safer as it prevents unintended side effects on the actual arguments.
  • Call by Reference: Less safe since it can lead to unintended changes to the actual arguments.

Use Cases:

  • Call by Value: Preferred when the function does not need to modify the input arguments.
  • Call by Reference: Preferred when the function needs to modify the input arguments or when passing large data structures to avoid performance overhead.

ceil() Function in C


Rounds a number up to the nearest integer.




#include <stdio.h> #include <math.h>int main() { double num = 3.14; double result = ceil(num); // Rounds 3.14 up to 4 printf("ceil(3.14) = %.2f\n", result); // Output: ceil(3.14) = 4.00 return 0; }

sqrt() Function in C


Calculates the square root of a number.




#include <stdio.h> #include <math.h>int main() { double num = 16; double result = sqrt(num); // Square root of 16 printf("sqrt(16) = %.2f\n", result); // Output: sqrt(16) = 4.00 return 0; }

Data Type Modifiers in C

Data type modifiers in C are keywords that modify the properties of basic data types to alter their range and storage size. The main data type modifiers in C are signed, unsigned, short, and long.


Description: Indicates that a variable can hold both positive and negative values. By default, integer types are signed.
Example: signed int a;


Description: Indicates that a variable can hold only non-negative values (zero and positive). This effectively doubles the upper range limit compared to the signed version.
Example: unsigned int b;


Description: Used to declare a variable with a smaller range than the default int. It typically occupies less memory.
Example: short int c; or simply short c;


Description: Used to declare a variable with a larger range than the default int. It can be combined with int or double to extend their range.
Example: long int d; or simply long d; for integers, long double e; for extended precision floating-point numbers.

Conditional Operator in C

The conditional operator in C, also known as the ternary operator, is used to evaluate a condition and return one of two values depending on whether the condition is true or false.


condition ? expression_if_true : expression_if_false;

Key Points:

  • Condition: An expression that evaluates to true (non-zero) or false (zero).
  • expression_if_true: The value returned if the condition is true.
  • expression_if_false: The value returned if the condition is false.


#include <stdio.h>int main() { int a = 10; int b = 20; int max; max = (a > b) ? a : b; // Evaluates to 20 since a is not greater than b printf("The maximum value is: %d\n", max); // Output: The maximum value is: 20 return 0; }

floor() Function in C


Rounds a number down to the nearest integer.




#include <stdio.h> #include <math.h>int main() { double num = 3.99; double result = floor(num); // Rounds 3.99 down to 3 printf("floor(3.99) = %.2f\n", result); // Output: floor(3.99) = 3.00 return 0; }

Difference Between Break and Continue


  • Break: Exits the nearest enclosing loop or switch statement immediately.
  • Continue: Skips the rest of the current iteration of the nearest enclosing loop and proceeds with the next iteration.

Usage Context:

  • Break: Can be used within for, while, do-while loops, and switch statements.
  • Continue: Can only be used within for, while, and do-while loops.

Effect on Loop Control Flow:

  • Break: Terminates the entire loop or switch statement, transferring control to the statement immediately following the loop or switch.
  • Continue: Skips the remaining code inside the loop for the current iteration and jumps to the next iteration (in for loops, it jumps to the update statement).

Typical Use Case:

  • Break: Used when an immediate exit from a loop or switch is required, often based on a specific condition.
  • Continue: Used to skip certain iterations of a loop, often based on a specific condition.

Impact on Loop Counters:

  • Break: Ends the loop entirely, so subsequent iterations do not occur.
  • Continue: Does not terminate the loop; the loop counter (if any) is updated, and the loop proceeds with the next iteration.

Short Notes on Arrays, Pointers, and Strings in C


An array is a data structure that stores a fixed-size sequential collection of elements of the same type. These elements are accessed using an index or subscript, which represents the position of the element in the array. Arrays are commonly used in programming to store multiple values of the same data type under a single variable name. They offer fast and efficient access to elements, as the position of each element is determined by its index. Arrays can be one-dimensional, multi-dimensional, or even jagged (arrays of arrays).


A pointer is a variable that stores the memory address of another variable. It allows indirect access to the value stored in that memory address. Pointers are extensively used in programming, particularly in languages like C and C++, to manipulate memory and manage data structures efficiently. They can be used to dynamically allocate memory, create data structures like linked lists and trees, and improve performance in certain algorithms. However, incorrect usage of pointers can lead to memory leaks, segmentation faults, and other runtime errors.


A string is a sequence of characters, typically used to represent text in computer programming. Strings are one of the most fundamental data types in programming languages, and most languages provide built-in support for manipulating strings. Operations on strings often include concatenation, substring extraction, searching, and comparison. Depending on the language, strings may be mutable (modifiable) or immutable (unchangeable). In languages like C and C++, strings are represented as arrays of characters terminated by a null character (‘\0’), while in languages like Python and Java, strings are objects with built-in methods for string manipulation.

Recursion in C

Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem. In a recursive solution, the problem is divided into smaller, similar subproblems, which are solved recursively until they reach a base case, where the solution is known without further recursion. Recursion is particularly useful for solving problems that can be broken down into smaller instances of the same problem.

Example: Factorial Program in C Using Recursion

#include <stdio.h>int factorial(int n) { if (n == 0) { return 1; } else { return n * factorial(n - 1); } }int main() { int num = 5; printf("Factorial of %d is %d\n", num, factorial(num)); return 0; }

In this C program, the factorial function calls itself recursively with a smaller value until it reaches the base case (n == 0), where it returns 1. Then, the recursive calls unwind, multiplying the result by successively larger values of n until the original call is completed.