Course Code: MCS-011
Course Title: Problem Solving and Programming Language
Assignment Number: BCA(II)/011/Assignment/2024-25
maximum Marks: 100
Weightage: 25%
Last Dates for Submission: 30st october, 2024 9 For july Session || 30th April, 2025 (For january Session)
There are eight questions in this assignment. Each question carries 10 marks. rest 20 marks are for viva-voice. Answer all the questions. you may use illustrations and diagrams to enhance the explanations. Please go through the guidelines regarding assignments given in the Programme Guide for the Format of Presentation.
Q1: Discuss the differences between iterative and recursive approaches in solving problems. Write C programs to compute the factorial of a number using both iterative and recursive methods. Compare their performance and memory usage.
Answer: Iterative vs. Recursive Approaches
When solving problems, two common approaches are iteration and recursion. Both methods achieve the same goal but differ in their execution and efficiency.
1. Iterative Approach
- Uses loops (
for,while,do-while) to repeatedly execute a set of instructions. - More memory-efficient as it does not require extra function calls.
- Generally faster due to lower overhead (no function call stack operations).
- Easier to debug and understand for problems requiring repeated calculations.
2. Recursive Approach
- A function calls itself to break a problem into smaller subproblems.
- Requires extra memory for function call stack frames.
- Easier to express certain problems (e.g., tree traversal, divide-and-conquer).
- Can lead to stack overflow if the recursion depth is too deep.
C Programs for Factorial Calculation
1. Iterative Implementation
#include <stdio.h>
// Function to calculate factorial iteratively
unsigned long long factorial_iterative(int n) {
unsigned long long result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
int main() {
int num;
printf("Enter a number: ");
scanf("%d", &num);
if (num < 0) {
printf("Factorial is not defined for negative numbers.\n");
} else {
printf("Factorial of %d (Iterative) = %llu\n", num, factorial_iterative(num));
}
return 0;
}
2. Recursive Implementation
#include <stdio.h>
// Function to calculate factorial recursively
unsigned long long factorial_recursive(int n) {
if (n == 0 || n == 1)
return 1;
return n * factorial_recursive(n - 1);
}
int main() {
int num;
printf("Enter a number: ");
scanf("%d", &num);
if (num < 0) {
printf("Factorial is not defined for negative numbers.\n");
} else {
printf("Factorial of %d (Recursive) = %llu\n", num, factorial_recursive(num));
}
return 0;
}
Performance and Memory Usage Comparison
| Approach | Time Complexity | Space Complexity | Function Calls | Memory Usage |
|---|---|---|---|---|
| Iterative | O(n) | O(1) (constant) | 1 function call | Low (only loop variables) |
| Recursive | O(n) | O(n) (stack frames) | n function calls | High (stack memory) |
Key Observations:
- Execution Speed:
- The iterative approach runs faster because there is no overhead of multiple function calls.
- The recursive approach has extra overhead due to repeated function calls and return statements.
- Memory Usage:
- The iterative method uses a single variable and requires constant space
O(1). - The recursive method uses
O(n)space due to function call stack frames.
- The iterative method uses a single variable and requires constant space
- Stack Overflow Risk:
- The recursive approach can cause stack overflow for large values of
n(e.g.,n > 10,000in some systems). - The iterative method avoids this issue.
- The recursive approach can cause stack overflow for large values of
Q 2: Write a C Program to find the sum of all elements in an array.
Answer: C Program : Sum of Array Elements:
#include <stdio.h>
// Function to calculate the sum of array elements
int sum_of_array(int arr[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += arr[i];
}
return sum;
}
int main() {
int n;
// Input: Size of the array
printf("Enter the number of elements in the array: ");
scanf("%d", &n);
int arr[n]; // Declare array
// Input: Array elements
printf("Enter %d elements:\n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Compute and display the sum
int sum = sum_of_array(arr, n);
printf("Sum of array elements = %d\n", sum);
return 0;
}
Q 3: Write a C program to perform division on 2 matrices A and B of size NXN and store the result in matrix C.
Answer: Matrix Division in C
Matrix division is not as straightforward as element-wise division because matrix division is not a directly defined operation in linear algebra. Instead, matrix division is typically performed by multiplying matrix A by the inverse of matrix B:C=A×B−1C = A \times B^{-1}C=A×B−1
where B−1B^{-1}B−1 is the inverse of BBB, provided BBB is invertible.
Thus, the solution involves:
Multiplying matrix A with B⁻¹ to get C.
Computing the inverse of matrix B.
#include <stdio.h>
#define N 3 // Define matrix size (N x N)
// Function to compute the determinant of a matrix
float determinant(float matrix[N][N], int n) {
float det = 0;
float submatrix[N][N];
if (n == 1)
return matrix[0][0];
int sign = 1;
for (int x = 0; x < n; x++) {
int subi = 0;
for (int i = 1; i < n; i++) {
int subj = 0;
for (int j = 0; j < n; j++) {
if (j == x)
continue;
submatrix[subi][subj] = matrix[i][j];
subj++;
}
subi++;
}
det += sign * matrix[0][x] * determinant(submatrix, n - 1);
sign = -sign;
}
return det;
}
// Function to calculate the cofactor matrix
void cofactorMatrix(float matrix[N][N], float cofactor[N][N]) {
float submatrix[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
int subi = 0, subj = 0;
for (int row = 0; row < N; row++) {
for (int col = 0; col < N; col++) {
if (row != i && col != j) {
submatrix[subi][subj] = matrix[row][col];
subj++;
if (subj == N - 1) {
subj = 0;
subi++;
}
}
}
}
cofactor[i][j] = determinant(submatrix, N - 1) * ((i + j) % 2 == 0 ? 1 : -1);
}
}
}
// Function to compute the transpose of a matrix
void transpose(float matrix[N][N], float transposed[N][N]) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
transposed[j][i] = matrix[i][j];
}
}
}
// Function to compute the inverse of a matrix
int inverseMatrix(float matrix[N][N], float inverse[N][N]) {
float det = determinant(matrix, N);
if (det == 0) {
printf("Matrix B is singular and cannot be inverted.\n");
return 0;
}
float cofactor[N][N], adjoint[N][N];
cofactorMatrix(matrix, cofactor);
transpose(cofactor, adjoint);
// Divide by determinant to get inverse
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
inverse[i][j] = adjoint[i][j] / det;
}
}
return 1;
}
// Function to multiply two matrices
void multiplyMatrices(float A[N][N], float B[N][N], float C[N][N]) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
C[i][j] = 0;
for (int k = 0; k < N; k++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}
}
// Function to display a matrix
void displayMatrix(float matrix[N][N]) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
printf("%8.3f ", matrix[i][j]);
}
printf("\n");
}
}
int main() {
float A[N][N], B[N][N], B_inv[N][N], C[N][N];
printf("Enter elements of matrix A (%dx%d):\n", N, N);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
scanf("%f", &A[i][j]);
printf("Enter elements of matrix B (%dx%d):\n", N, N);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
scanf("%f", &B[i][j]);
if (!inverseMatrix(B, B_inv)) {
printf("Matrix division is not possible.\n");
return 1;
}
multiplyMatrices(A, B_inv, C);
printf("Matrix A:\n");
displayMatrix(A);
printf("\nMatrix B:\n");
displayMatrix(B);
printf("\nInverse of Matrix B:\n");
displayMatrix(B_inv);
printf("\nResult of Matrix Division (C = A × B⁻¹):\n");
displayMatrix(C);
return 0;
}
Q 4: Without using the built-in string functions, write a C program to take a choice from the user (use a SWITCH statement) (i) to find the string length (ii) for string concatenation , (iii) string copy and (iv) string comparison.
Answer: C Program: Manual String Operations using Switch Case
#include <stdio.h>
// Function to find the length of a string
int string_length(char str[]) {
int length = 0;
while (str[length] != '\0') {
length++;
}
return length;
}
// Function to concatenate two strings
void string_concatenation(char str1[], char str2[], char result[]) {
int i = 0, j = 0;
// Copy str1 into result
while (str1[i] != '\0') {
result[i] = str1[i];
i++;
}
// Append str2 to result
while (str2[j] != '\0') {
result[i] = str2[j];
i++;
j++;
}
result[i] = '\0'; // Null-terminate the result
}
// Function to copy one string to another
void string_copy(char source[], char destination[]) {
int i = 0;
while (source[i] != '\0') {
destination[i] = source[i];
i++;
}
destination[i] = '\0'; // Null-terminate the destination string
}
// Function to compare two strings
int string_compare(char str1[], char str2[]) {
int i = 0;
while (str1[i] != '\0' && str2[i] != '\0') {
if (str1[i] != str2[i]) {
return (str1[i] - str2[i]); // Returns difference in ASCII values
}
i++;
}
return (str1[i] - str2[i]); // Handles cases where one string is longer
}
int main() {
int choice;
char str1[100], str2[100], result[200];
printf("Choose an operation:\n");
printf("1. Find String Length\n");
printf("2. String Concatenation\n");
printf("3. String Copy\n");
printf("4. String Comparison\n");
printf("Enter your choice: ");
scanf("%d", &choice);
getchar(); // Consume newline left by scanf
switch (choice) {
case 1:
printf("Enter a string: ");
gets(str1);
printf("Length of the string: %d\n", string_length(str1));
break;
case 2:
printf("Enter first string: ");
gets(str1);
printf("Enter second string: ");
gets(str2);
string_concatenation(str1, str2, result);
printf("Concatenated string: %s\n", result);
break;
case 3:
printf("Enter the source string: ");
gets(str1);
string_copy(str1, str2);
printf("Copied string: %s\n", str2);
break;
case 4:
printf("Enter first string: ");
gets(str1);
printf("Enter second string: ");
gets(str2);
int cmp_result = string_compare(str1, str2);
if (cmp_result == 0)
printf("Strings are equal.\n");
else if (cmp_result > 0)
printf("First string is greater.\n");
else
printf("Second string is greater.\n");
break;
default:
printf("Invalid choice!\n");
}
return 0;
}
Example Runs
Run1: Finding String Length
Choose an operation:
1. Find String Length
2. String Concatenation
3. String Copy
4. String Comparison
Enter your choice: 1
Enter a string: Hello World
Length of the string: 11
Run2: String Concatenation
Enter first string: Hello
Enter second string: World
Concatenated string: HelloWorld
Run 3: String Copy
Enter the source string: OpenAI
Copied string: OpenAI
Run 4: String Comparison
Enter first string: Apple
Enter second string: Banana
Second string is greater.
Q 5: Explain the concept of pointers in C and their various uses. Write a c program that uses pointers to perform operations on arrays, including finding the maximum and minimum values, and reversing the array. Discuss the advantages and potential pitfalls of using pointer.
Answer: Concept of Pointers in C
A pointer in C is a variable that stores the memory address of another variable. Instead of holding a value directly, it holds the location where the value is stored.
Pointer Syntax
int a = 10; // Normal variable
int *p = &a; // Pointer storing the address of 'a'
Here, p is a pointer that stores the address of a, and *p (dereferencing p) gives the value of a.
Uses of Pointers in C
Pointers are extremely powerful and have many uses:
- Dynamic Memory Allocation (
malloc,calloc,free). - Efficient Array Manipulation (Pointers can traverse arrays faster than indexing).
- Passing Large Data to Functions (Passing by reference instead of value saves memory).
- Building Data Structures (Linked lists, trees, graphs, etc.).
- Function Pointers (Used in callback functions and event-driven programming).
C Program: Using Pointers for Array Operations
This program performs:
- Finding Maximum and Minimum values in an array using pointers.
- Reversing an array using pointer swapping.
C Code
#include <stdio.h>
// Function to find the maximum and minimum in an array using pointers
void find_max_min(int *arr, int size, int *max, int *min) {
*max = *arr; // Initialize max with first element
*min = *arr; // Initialize min with first element
for (int i = 1; i < size; i++) {
if (*(arr + i) > *max) {
*max = *(arr + i);
}
if (*(arr + i) < *min) {
*min = *(arr + i);
}
}
}
// Function to reverse an array using pointers
void reverse_array(int *arr, int size) {
int *start = arr;
int *end = arr + size - 1;
while (start < end) {
int temp = *start;
*start = *end;
*end = temp;
start++; // Move forward
end--; // Move backward
}
}
// Function to display an array
void display_array(int *arr, int size) {
for (int i = 0; i < size; i++) {
printf("%d ", *(arr + i));
}
printf("\n");
}
int main() {
int n;
printf("Enter the size of the array: ");
scanf("%d", &n);
int arr[n]; // Declare array
printf("Enter %d elements:\n", n);
for (int i = 0; i < n; i++) {
scanf("%d", arr + i); // Using pointer notation
}
int max, min;
find_max_min(arr, n, &max, &min);
printf("Maximum value: %d\n", max);
printf("Minimum value: %d\n", min);
printf("Original Array: ");
display_array(arr, n);
reverse_array(arr, n);
printf("Reversed Array: ");
display_array(arr, n);
return 0;
}
Explanation
find_max_minfunction:- Iterates through the array using pointer arithmetic.
- Compares values to determine the maximum and minimum.
reverse_arrayfunction:- Uses two pointers (
startandend). - Swaps values until they meet in the middle.
- Uses two pointers (
- Pointer Arithmetic:
- Instead of
arr[i], we use*(arr + i)to access elements.
- Instead of
Example Run
Input:
Enter the size of the array: 5
Enter 5 elements:
10 25 5 30 15
Output:
Maximum value: 30
Minimum value: 5
Original Array: 10 25 5 30 15
Reversed Array: 15 30 5 25 10
Advantages of Using Pointers
✅ Efficient Memory Access – Faster access to array elements.
✅ Less Memory Usage – Passing pointers avoids copying large data structures.
✅ Supports Dynamic Data Structures – Essential for linked lists, stacks, queues.
✅ Allows Low-Level Memory Manipulation – Useful in embedded systems.
Pitfalls of Using Pointers
❌ Dangling Pointers – Using freed memory can cause segmentation faults.
❌ Memory Leaks – Forgetting to free() dynamically allocated memory.
❌ Buffer Overflow – Accessing memory outside array bounds leads to crashes.
❌ Difficult Debugging – Errors with pointers can be tricky to identify.
Q6: What are structure in C, and how are they used? Write a C program that defines a structure to store student information (name , roll number, and marks) and includes functions to input , display, and sort the student records by marks. Explain the advantages of using structures for complex data.
Answer: Structures in C
A structure in C is a user-defined data type that groups different types of variables under one name. Unlike arrays (which store multiple values of the same type), structures can store multiple values of different types.
Declaring a Structure
struct Student {
char name[50];
int roll_number;
float marks;
};
Here, the Student structure stores:
name(character array)roll_number(integer)marks(float)
Why Use Structures?
- Group Related Data – Useful for handling real-world entities like students, employees, books, etc.
- Better Code Organization – Instead of managing multiple parallel arrays, we store all related data in one structure.
- Easy Data Manipulation – Functions can pass structures efficiently, allowing modularity.
- Scalability – Structures allow expansion (e.g., adding more student attributes).
C Program: Student Record System
This program:
- Defines a structure to store student details.
- Uses functions to:
- Input student records.
- Display student records.
- Sort students based on marks using Bubble Sort.
- Demonstrates efficient data handling using structures.
C Code
#include <stdio.h>
#include <string.h>
#define MAX_STUDENTS 100
// Define Student Structure
struct Student {
char name[50];
int roll_number;
float marks;
};
// Function to input student details
void input_students(struct Student students[], int n) {
for (int i = 0; i < n; i++) {
printf("Enter details for student %d:\n", i + 1);
printf("Name: ");
getchar(); // To clear the newline from buffer
fgets(students[i].name, 50, stdin);
students[i].name[strcspn(students[i].name, "\n")] = 0; // Remove newline
printf("Roll Number: ");
scanf("%d", &students[i].roll_number);
printf("Marks: ");
scanf("%f", &students[i].marks);
}
}
// Function to display student details
void display_students(struct Student students[], int n) {
printf("\n%-20s %-10s %-5s\n", "Name", "Roll No.", "Marks");
printf("-------------------------------------\n");
for (int i = 0; i < n; i++) {
printf("%-20s %-10d %-5.2f\n", students[i].name, students[i].roll_number, students[i].marks);
}
}
// Function to sort students by marks (Bubble Sort)
void sort_students_by_marks(struct Student students[], int n) {
struct Student temp;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (students[j].marks < students[j + 1].marks) { // Sort in descending order
temp = students[j];
students[j] = students[j + 1];
students[j + 1] = temp;
}
}
}
}
int main() {
int n;
printf("Enter the number of students: ");
scanf("%d", &n);
struct Student students[MAX_STUDENTS]; // Array of structures
// Input student records
input_students(students, n);
// Display unsorted list
printf("\nStudent Records (Unsorted):\n");
display_students(students, n);
// Sort students by marks
sort_students_by_marks(students, n);
// Display sorted list
printf("\nStudent Records (Sorted by Marks - Descending):\n");
display_students(students, n);
return 0;
}
Explanation
struct Student: Defines a student withname,roll_number, andmarks.input_students():- Uses
fgets()to handle spaces in names. - Removes trailing newline characters using
strcspn().
- Uses
display_students():- Displays students in a formatted table.
sort_students_by_marks():- Uses Bubble Sort to sort students by marks in descending order.
- Main Function (
main()):- Takes the number of students as input.
- Calls functions to handle input, sorting, and displaying data.
Example Run
Input:
Enter the number of students: 3
Enter details for student 1:
Name: Alice Johnson
Roll Number: 101
Marks: 89.5
Enter details for student 2:
Name: Bob Smith
Roll Number: 102
Marks: 76.0
Enter details for student 3:
Name: Charlie Brown
Roll Number: 103
Marks: 92.3
Output:
Student Records (Unsorted):
Name Roll No. Marks
-------------------------------------
Alice Johnson 101 89.50
Bob Smith 102 76.00
Charlie Brown 103 92.30
Student Records (Sorted by Marks - Descending):
Name Roll No. Marks
-------------------------------------
Charlie Brown 103 92.30
Alice Johnson 101 89.50
Bob Smith 102 76.00
Advantages of Using Structures for Complex Data
✅ Data Organization
- Structures store related data together, reducing the need for multiple arrays.
✅ Code Readability & Maintainability
- Easier to understand
student.roll_numberthanroll_numbers[i].
✅ Modularity
- Functions can pass entire structures, keeping the code clean.
✅ Scalability
- Additional fields (e.g.,
age,grade) can be easily added.
- IGNOU जून 2025 टर्म-एंड परीक्षा डेट शीट (पूर्ण विवरण)
- IGNOU June 2025 Term-End Exam Date Sheet – पूरी जानकारी हिंदी में
- MCS-011 Problem Solving and Programming language 2024-2025
- Title: How to Apply Online for B.Ed and BScN (PB) Entrance Test: A Complete Guide
- MCS-011 DEC-2023 Solve Question Paper FOR BCA/MCA
Q7: Explain the Concept of the file handling in C. Write a c program to read data from a file, process the data (such as calculating the sum and average of numbers), and write the results to another file. Discuss the various of file opening and the importance of closing files.
Answer:
Concept of File Handling in C
File handling in C allows us to create, read, write, and manipulate files. Instead of using standard input/output (keyboard/screen), we can store and retrieve data from files, making programs more practical for data storage and persistence.
File Handling Operations
- Creating a File
- Opening a File
- Reading from a File
- Writing to a File
- Closing a File
File Opening Modes in C
Files in C are accessed using FILE * pointers with different modes:
| Mode | Description |
|---|---|
"r" | Open for reading (file must exist) |
"w" | Open for writing (overwrites if file exists, creates new if not) |
"a" | Open for appending (adds data at the end of an existing file) |
"r+" | Open for both reading and writing (file must exist) |
"w+" | Open for both reading and writing (deletes existing content) |
"a+" | Open for reading and appending (file must exist) |
C Program: File Handling (Reading, Processing, Writing)
This program:
- Reads numbers from a file (
input.txt) - Calculates the sum and average
- Writes the results to another file (
output.txt)
C Code
#include <stdio.h>
int main() {
FILE *inputFile, *outputFile;
int num, count = 0;
float sum = 0, average;
// Open input file in read mode
inputFile = fopen("input.txt", "r");
if (inputFile == NULL) {
printf("Error opening input file!\n");
return 1;
}
// Read numbers from the file and compute sum
while (fscanf(inputFile, "%d", &num) != EOF) {
sum += num;
count++;
}
// Close the input file
fclose(inputFile);
// Compute the average
if (count == 0) {
printf("No numbers found in the file.\n");
return 1;
}
average = sum / count;
// Open output file in write mode
outputFile = fopen("output.txt", "w");
if (outputFile == NULL) {
printf("Error opening output file!\n");
return 1;
}
// Write results to the output file
fprintf(outputFile, "Total Numbers: %d\n", count);
fprintf(outputFile, "Sum: %.2f\n", sum);
fprintf(outputFile, "Average: %.2f\n", average);
// Close the output file
fclose(outputFile);
printf("Processing complete. Results saved in output.txt.\n");
return 0;
}
Explanation
- Opening the Input File (
input.txt)fopen("input.txt", "r")opens the file in read mode.- If the file doesn’t exist, it returns
NULL, and an error message is displayed.
- Reading Data from File
fscanf(inputFile, "%d", &num)reads integers from the file until EOF (End of File).- The sum and count of numbers are updated.
- Computing Sum & Average
- The average is calculated as
sum / count.
- The average is calculated as
- Opening the Output File (
output.txt)fopen("output.txt", "w")opens the file in write mode.- If the file doesn’t exist, it creates a new file.
- Writing Data to File
fprintf(outputFile, "...")writes the results (sum, average) into the output file.
- Closing Files
fclose(inputFile);andfclose(outputFile);close the files to prevent data corruption.
Example Run
Contents of input.txt:
10
20
30
40
50
Generated output.txt:
Total Numbers: 5
Sum: 150.00
Average: 30.00
Importance of Closing Files (fclose)
Closing files is crucial for:
- Flushing the Output Buffer – Ensures data is saved properly.
- Releasing Resources – Frees system resources locked by the file.
- Preventing Corruption – Avoids issues like partial writes or unreadable files.
Advantages of File Handling
✅ Persistent Storage – Data is saved even after the program exits.
✅ Large Data Handling – Files manage large datasets efficiently.
✅ Data Sharing – Files can be read by multiple programs or users.
✅ Logging and Debugging – Useful for storing logs and program output.
Q8: Explain the role of preprocessor directive in C. Write a C program that uses macros to define constants and perform inline calculations. Discuss the use of conditional compilation directives to create a program that behaves differently based on defined macros. Analyze the benefits and limitations of using preprocessor directive in C programming.
Answer:Preprocessor Directives in C
Preprocessor directives in C begin with # and are processed before compilation. They are not part of the C language itself, but they instruct the compiler on how to handle the code.
Common Preprocessor Directives
| Directive | Description |
|---|---|
#define | Defines macros (constants or inline functions). |
#include | Includes header files. |
#ifdef, #ifndef, #endif | Conditional compilation based on macros. |
#if, #elif, #else | More complex conditional compilation. |
#undef | Undefines a macro. |
C Program: Using Macros for Constants and Inline Calculations
This program:
- Uses
#definemacros to define constants. - Defines inline calculations for area, perimeter, and volume.
- Implements conditional compilation to modify behavior based on a macro.
C Code
#include <stdio.h>
// Define Constants using Macros
#define PI 3.14159
#define LENGTH 10
#define WIDTH 5
#define HEIGHT 6
// Define Inline Calculation Macros
#define AREA_RECTANGLE(l, w) ((l) * (w))
#define PERIMETER_RECTANGLE(l, w) (2 * ((l) + (w)))
#define VOLUME_CUBOID(l, w, h) ((l) * (w) * (h))
// Conditional Compilation
#define ADVANCED_MODE // Uncomment this to enable advanced calculations
int main() {
printf("Rectangle Area: %d\n", AREA_RECTANGLE(LENGTH, WIDTH));
printf("Rectangle Perimeter: %d\n", PERIMETER_RECTANGLE(LENGTH, WIDTH));
printf("Cuboid Volume: %d\n", VOLUME_CUBOID(LENGTH, WIDTH, HEIGHT));
#ifdef ADVANCED_MODE
// Additional calculations only available in ADVANCED_MODE
printf("\nAdvanced Mode Enabled:\n");
printf("Circle Area (radius %d): %.2f\n", LENGTH, PI * LENGTH * LENGTH);
printf("Circle Circumference (radius %d): %.2f\n", LENGTH, 2 * PI * LENGTH);
#endif
return 0;
}
Explanation
- Defining Constants Using Macros (
#define)#define PI 3.14159makesPIa constant, avoidingconstkeyword.#define LENGTH 10,WIDTH 5, andHEIGHT 6define dimensions.
- Using Macros for Inline Calculations
AREA_RECTANGLE(l, w) ((l) * (w))– Computes area without a function.PERIMETER_RECTANGLE(l, w) (2 * ((l) + (w)))– Computes perimeter.VOLUME_CUBOID(l, w, h) ((l) * (w) * (h))– Computes volume.
- Conditional Compilation (
#ifdef ADVANCED_MODE)- If
ADVANCED_MODEis defined, extra calculations (circle area & circumference) are included. - Otherwise, the advanced section is ignored by the compiler.
- If
Example Run
Default Output (Without Advanced Mode)
Rectangle Area: 50
Rectangle Perimeter: 30
Cuboid Volume: 300
With #define ADVANCED_MODE
Rectangle Area: 50
Rectangle Perimeter: 30
Cuboid Volume: 300
Advanced Mode Enabled:
Circle Area (radius 10): 314.16
Circle Circumference (radius 10): 62.83
Benefits of Preprocessor Directives
✅ Improves Readability & Maintainability
- Constants make the code more understandable (
PIvs3.14159everywhere).
✅ Performance Optimization
- Macros are inline, avoiding function call overhead.
✅ Conditional Compilation
- Different versions of a program can be compiled without modifying the source code.
✅ Code Reusability
- Header files (
#include "myfile.h") allow modular programming.
Limitations of Preprocessor Directives
❌ No Type Checking
- Macros don’t check data types, which can lead to unintended behaviors.
- Example:
SQUARE(x) (x * x)→SQUARE(5+2)expands to5+2 * 5+2 = 5+10+2 = 17instead of49. - Solution: Use parentheses →
#define SQUARE(x) ((x) * (x)).
❌ Difficult Debugging
- Errors inside macros are not shown clearly in compilation.
❌ Code Bloat
- Large macros get expanded everywhere, increasing executable size.
- Solution: Use
inlinefunctions instead of macros for complex calculations.
- IGNOU जून 2025 टर्म-एंड परीक्षा डेट शीट (पूर्ण विवरण)
- IGNOU June 2025 Term-End Exam Date Sheet – पूरी जानकारी हिंदी में
- MCS-011 Problem Solving and Programming language 2024-2025
- Title: How to Apply Online for B.Ed and BScN (PB) Entrance Test: A Complete Guide
- MCS-011 DEC-2023 Solve Question Paper FOR BCA/MCA