CBSE Class 12 Computer Science Pointer Worksheet

When an object pointer points to the first element of an array of objects, incrementing the pointer shifts its target to the subsequent object in sequence.

You can also declare pointers that point directly to data members of an object. Keep two rules in mind:

1. A pointer can only point to public data members of a class.
2. The data type of the pointer must exactly match the data type of the data member it references.

this Pointer:

In a class, member functions are created and stored in memory only once. That means a single copy of a member function is shared by all active instances of the class.

If only one instance of a member function exists in memory, how does it determine which specific object's data members it needs to manipulate?

To solve this, C++ uses an implicit argument named `this`. When a member function is invoked, C++ automatically passes a hidden pointer pointing directly to the object that initiated the call. This pointer is called the `this` pointer.

For example, if `object3` invokes `memberFunction2()`, an implicit `this` pointer pointing to `object3` is automatically passed to the function so it knows to modify `object3`'s data members.

Friend functions are not members of the class, so they do not receive a `this` pointer. Static member functions also do not possess a `this` pointer.

Summary:

• Pointers allow you to access and manipulate data indirectly using memory addresses. The address of any variable is retrieved using the address-of operator (`&`).
• Pointers are declared by specifying the target data type, followed by the dereference operator (`*`) and the pointer's name. They should always be initialized to a valid memory location or to `NULL` (0).
• You can access or modify the value at a pointer's target address by using the dereference operator (`*`).
• You can declare `const` pointers (which cannot be reassigned to a different address) as well as pointers to `const` objects (which prevent modifying the target values through that pointer).
• The `new` keyword dynamically allocates memory on the free store (heap) and returns its address. The allocated memory must be manually freed using the `delete` keyword to avoid memory leaks. The pointer should be reassigned to `NULL` or a safe address after deletion.

Solved Questions

Question 1. How is *p different from **p ?
Answer: `*p` is a single-level pointer that directly stores the memory address of a standard data variable (such as an integer). On the other hand, `**p` is a double pointer (pointer-to-pointer) that stores the memory address of another pointer variable, which in turn points to the actual data variable.
In simple words: `*p` points to a normal variable, whereas `**p` points to another pointer that points to a normal variable.

Exam Tip: Use double pointers (`**`) when you need to dynamically allocate or modify two-dimensional arrays or when passing pointer addresses to functions.

Question 2. How is &p different from *p ?
Answer: The address-of operator `&p` retrieves the unique physical memory address of the pointer variable `p` itself. Conversely, the dereference operator `*p` retrieves the data value currently stored at the memory location that pointer `p` is pointing to.
In simple words: `&p` tells us where the pointer itself is located in memory, while `*p` retrieves the actual value that the pointer is looking at.

Exam Tip: Do not confuse the address of a pointer (`&p`) with the address stored *inside* the pointer (`p`). They are different memory locations.

Question 3. Find the error in following code segment :
Float **p1, p2;
P2 = &p1;
Answer: There are two syntax errors in this code segment:
1. The keyword `Float` is capitalized; it must be written in lowercase as `float`.
2. The variable `p1` is declared as a double pointer (`float **`), meaning its address `&p1` has the type `float ***`. However, `p2` is declared as a standard floating-point variable (`float`), not a pointer. Thus, the assignment `p2 = &p1;` is invalid because you cannot assign a pointer address to a non-pointer variable.
To fix this, `p2` must be declared as a triple pointer: `float ***p2;` or `p1` should be declared as a single pointer if `p2` is a pointer.
In simple words: The program tries to assign the memory address of a pointer to a normal decimal number variable, which is illegal in C++.

Exam Tip: Always match the pointer levels on both sides of an assignment operator during compilation. A pointer of level N can only store addresses of variables of level N-1.

Question 4. What will be the output of the following code segment ?
char C1 = 'A';
char C2 = 'D';
char *i, *j;
i = &C1;
j = &C2;
*i = *j;
cout << C1;
Answer: The output of this code segment will be:
**D**

Explanation:
The pointer `i` is initialized with the address of `C1` ('A') and pointer `j` is initialized with the address of `C2` ('D'). The statement `*i = *j;` copies the value pointed to by `j` ('D') into the memory location pointed to by `i` (which is `C1`). Consequently, the value of `C1` changes from 'A' to 'D'. Printing `C1` outputs 'D'.
In simple words: By using pointers, we copy the letter 'D' from variable C2 into variable C1. When we print C1, it displays 'D'.

Exam Tip: Be careful to distinguish between pointer assignments (`i = j`) and value assignments using dereferencing (`*i = *j`). The latter modifies the actual values in memory.

Question 5. How does C++ organize memory when a program is run ?
Answer: When a C++ program is executed, the system organizes the program's memory into four primary, logically distinct regions:
1. **Code Area (Text Segment):** Stores the compiled binary instruction code of the program.
2. **Data Area:** Allocates space for global and static variables, which remain in memory throughout the program's lifecycle.
3. **Stack Segment:** Dynamically manages function calls, local variables, parameters, and function return addresses in a Last-In, First-Out (LIFO) order.
4. **Heap (Free Store):** A pool of unused memory reserved for dynamic memory allocation during program execution using the `new` and `delete` operators.
In simple words: C++ divides memory into four folders: one for the code itself, one for global data, one for tracking current function calls, and one free pool for creating variables on the fly.

Exam Tip: Clearly list all four memory segments with brief descriptions to secure full marks on memory management questions.

Question 6. Identify and explain the error(s) in the following code segment :
float a[] = { 11.02, 12.13, 19.11, 17.41};
float *j, *k;
j = a;
k = a + 4;
j = j * 2;
k = k / 2;
cout << “ *j = “ << *j << “, *k = “ << *k << “\n”;
Answer: The syntax errors are in the following two lines:
`j = j * 2;`
`k = k / 2;`
Reason:
In C++, arithmetic multiplication (`*`) and division (`/`) operations are mathematically invalid on pointer variables. Pointers store memory addresses, and multiplying or dividing an address does not map to any logical memory configuration. Only addition and subtraction of integers (for address offset calculations) and pointer subtraction are allowed.
In simple words: The program tries to multiply and divide memory addresses, which C++ does not allow. You can only add or subtract numbers from pointers.

Exam Tip: Remember that valid pointer arithmetic is limited to: pointer + integer, pointer - integer, pointer++, pointer--, and pointer - pointer.

Question 13. How does the functioning of a function differ when (i) an object is passed by value ? (ii) an object is passed by reference ?
Answer: The behavior differs in the following ways:
(i) **Passed by Value:** When an object is passed by value, the function creates a local copy of that object in the stack. This process invokes the object's copy constructor. Any changes made to the object inside the function affect only the local copy, not the original object. When the function returns, the copy is destroyed, invoking the object's destructor.
(ii) **Passed by Reference:** When passed by reference, no local copy of the object is created. Instead, the function directly references the original object using its alias. Since no copy is made, neither the copy constructor nor the destructor is called. Any modifications performed inside the function will directly alter the original object.
In simple words: Passing by value makes a temporary copy of the object, which slows things down and uses constructors/destructors. Passing by reference works directly on the original object without copying.

Exam Tip: Emphasize the call of the copy constructor and destructor for "pass by value", and their complete absence in "pass by reference", to write a high-scoring answer.

Unsolved Questions

Question 1. Differentiate between static and dynamic allocation of memory.
Answer: The key differences are summarized below:

Exam Tip: Providing a comparison table is the most structured way to present differences and secure maximum marks.

Question 2. Identify and explain the error in the following program :
#include<iostream.h>
int main()
{
int x[] = { 1, 2, 3, 4, 5 };
for (int i = 0; i < 5; i++)
{
cout << *x;
x++;
}
return 0;
}
Answer: The syntax error is in the line:
`x++;`
Explanation:
The array name `x` acts as a constant pointer (`int * const`) pointing to the base address of the array (`&x[0]`). Because it is a constant pointer, its value (the address it points to) cannot be modified. Thus, performing the increment operation `x++` is illegal.
Correction:
To fix this, assign the array's base address to a standard pointer variable and increment that pointer instead: ```cpp #include using namespace std; int main() { int x[] = { 1, 2, 3, 4, 5 }; int *ptr = x; // ptr is a non-const pointer for (int i = 0; i < 5; i++) { cout << *ptr; ptr++; // valid operation } return 0; } ```
In simple words: An array's name is a fixed starting address that cannot be changed. The program tries to move this starting address using x++, which C++ does not allow.

Exam Tip: Remember that array names are constant pointers. You can perform addition like `*(x + i)` but you cannot perform assignment modifications like `x++` or `x = ptr`.

Question 3. Give the output of the following :
char *s = “computer”;
for (int x = strlen(s) – 1; x >= 0; x--)
{
for(int y =0; y <= x; y++) cout << s[y];
cout << endl;
}
Answer: The output of this program segment is:
**computer**
**compute**
**comput**
**compu**
**comp**
**com**
**co**
**c**

Tracing Steps:
- `s` points to "computer" which has a length of 8. The outer loop starts with index `x = 7` and runs down to `0`.
- In each iteration, the inner loop prints characters from index `0` up to `x`.
- When `x = 7`: prints index 0 to 7 ("computer").
- When `x = 6`: prints index 0 to 6 ("compute").
- This pattern continues until `x = 0`, which prints index 0 ("c").
In simple words: This code prints the word "computer" repeatedly, cutting off the last letter in each step until only the first letter "c" remains.

Exam Tip: Trace loop index bounds carefully. Here, the outer loop runs from length - 1 down to 0, matching the indices of the string exactly.

Question 4. Identify the syntax error(s), if any, in the following program. Also give reason for errors.
void main()
{
const int i = 20;
const int * const ptr = &i;
(*ptr++;
int j= 15;
ptr = &j; }
Answer: The syntax errors in this program segment are:
1. **Syntax Error in line 5:** `(*ptr++;` contains an unmatched opening parenthesis `(`. This is a basic compiler parsing error.
2. **Logical / Type Error in line 5:** Even if written as `(*ptr)++;` or `*ptr++;`, it is illegal. `ptr` is defined as a pointer to a constant integer (`const int *`). Therefore, the value stored at the address (`*ptr`) is constant and cannot be modified or incremented.
3. **Error in line 7:** `ptr = &j;` is illegal because `ptr` is declared as a constant pointer (`* const ptr`). A constant pointer's address is fixed at initialization and cannot be reassigned to point to another variable like `j`.
In simple words: The pointer is declared as a double constant, meaning both the address it holds and the value it points to cannot be changed. The program tries to modify both, causing compilation errors.

Exam Tip: Remember the double-const rule: `const int * const ptr` means both the pointer's destination and the data inside that destination are read-only.

Question 5. What is ‘this’ pointer ? What is its significance ?
Answer: The `this` pointer is an implicit, hidden pointer passed automatically to all non-static member functions of a class. It holds the memory address of the specific object that invoked the member function.
Significance:
- **Uniquely Identifies Calling Object:** It helps the shared member function distinguish which object's data members need to be accessed or modified.
- **Resolves Name Conflicts:** It helps distinguish class data members from local parameters when they share the identical name (e.g., `this->x = x;`).
- **Returns Object Reference:** It is used to return the invoking object itself from a member function (e.g., `return *this;`).
In simple words: The `this` pointer is a hidden tool in C++ that points to the object currently running a function, ensuring the program modifies the correct object's variables.

Exam Tip: Highlight that static member functions and friend functions do not have access to the `this` pointer because they are not bound to a specific class instance.

Question 6. Are pointers really faster than array ? How much do function calls slow things down ? Is ++i faster than i = i + 1 ?
Answer:
- **Pointers vs. Arrays:** Yes, pointers can be slightly faster. Array subscript access (e.g., `arr[i]`) requires calculating the address at runtime by multiplying the index `i` by the element size and adding it to the base address. A pointer can be incremented directly (e.g., `ptr++`), avoiding this multiplication step.
- **Function Call Overhead:** Function calls introduce overhead because the CPU must push registers, arguments, and the return address onto the stack, and then jump to the code block. While this slows execution down slightly, modern compilers minimize this overhead using function inlining.
- **++i vs. i = i + 1:** For primitive integers, modern compiler optimization makes both operations equally fast as they compile to the identical machine instruction. However, for user-defined object iterators, `++i` (pre-increment) is faster because it does not create a temporary object copy, unlike post-increment or complex assignments.
In simple words: Pointers can bypass some arithmetic steps needed for arrays, making them a bit faster. Function calls have a tiny stack speed cost. For standard numbers, ++i and i = i + 1 are equally fast.

Exam Tip: Explain the underlying assembly compilation concepts (like address offsets and compiler optimization) to show a deep technical understanding of performance questions.

Question 7. What will be the output of following program ?
#include<iostream.h>
void main()
{
char name1[] = “ankur”;
char name2[] = “ankur”;
if (name1 != name2)
cout << “\n both the strings are not equal”;
else
cout << “\n the strings are equal”; }
Answer: The output of this program is:
**both the strings are not equal**

Reason:
The array names `name1` and `name2` represent the starting memory addresses of two separate arrays in the stack. Even though both arrays contain the identical string characters ("ankur"), their memory addresses are different. The conditional statement `if (name1 != name2)` compares these two memory addresses, not the string values. Since the addresses are unique, the condition evaluates to true.
To compare C-style string values, the standard `strcmp(name1, name2)` function should be used instead.
In simple words: The program compares the physical memory locations of the two variables instead of the words themselves. Since they are stored in different spots, it says they are not equal.

Exam Tip: C-style arrays cannot be compared using relational operators like `==` or `!=`. Relational operators compare pointer addresses, not string contents.

Question 8. Write a function that takes two string arguments and returns a string which is the larger of the two. The larger string has larger ASCII value. Also show how this function will be invoked.
Answer: Here is the C++ implementation: ```cpp #include #include using namespace std; // Function returning a pointer to the larger string based on ASCII comparison const char* largerString(const char* str1, const char* s2) { if (strcmp(str1, s2) > 0) { return str1; } else { return s2; } } int main() { char name1[] = "Chemistry"; char name2[] = "Physics"; // Invoking the function and storing the returned pointer const char* result = largerString(name1, name2); cout << "The larger string alphabetically is: " << result << endl; return 0; } ```
In simple words: This function uses strcmp to compare two text strings alphabetically and returns the one with the larger ASCII value.

Exam Tip: Return `const char*` when returning string literals or constant arrays to follow modern C++ type safety rules.

Question 9. Give and explain the output of the following code :
void junk (int, int *);
int main() {
int i = 6, j = -4;
junk (i, &j);
cout << “i = “ << i << “, j = “ << j << “\n”;
return 0; }
void junk(int a, int *b)
{
a = a* a;
*b = *b * *b; }
Answer: The output of this program is:
**i = 6, j = 16**

Explanation:
- **Variable i:** It is passed to the function `junk` by value. A local copy `a` is created. Modifying `a = a * a` inside the function does not affect the original variable `i` in the `main` function. Hence, `i` remains 6.
- **Variable j:** Its memory address `&j` is passed to the pointer parameter `b` (pass-by-pointer). The operation `*b = *b * *b;` dereferences the pointer to directly modify the value at `j`'s memory location. Thus, `j` becomes `-4 * -4 = 16`. This change persists after the function finishes.
In simple words: Variable i is passed by value, so its original number is protected. Variable j is passed via its memory address, so the function directly multiplies and modifies it in place.

Exam Tip: Clearly differentiate between call-by-value and call-by-pointer to show how modifications do or do not persist outside a function scope.

Question 10. Give the output of the following program :
void main()
{ int array[] = { 2, 3, 4, 5 };
int *ap = array;
int value = *ap;
cout << value << “\n”;
value = *ap++;
cout << value << “\n”;
value = * ap;
cout << value << “\n”;
value = * ++ ap;
cout << value << “\n”; }
Answer: The output of this program is:
**2**
**2**
**3**
**4**

Tracing Steps:
1. `int *ap = array;` -> `ap` points to the first element `array[0]` (value 2).
2. `value = *ap;` -> Dereferences `ap`, yielding **2**.
3. `value = *ap++;` -> The post-increment operator `++` has higher precedence than `*`. It increments the pointer `ap` to point to `array[1]` (value 3), but evaluates to the original pointer address first. Dereferencing this original address yields **2**.
4. `value = *ap;` -> Dereferences the current address of `ap` (which now points to `array[1]`), yielding **3**.
5. `value = * ++ap;` -> The pre-increment operator `++` increments `ap` to point to `array[2]` (value 4) before dereferencing, yielding **4**.
In simple words: This code walks through an array using a pointer. It prints the values as the pointer shifts position, paying attention to the timing difference between pre-increment and post-increment.

Exam Tip: Post-increment pointer dereferencing `*ptr++` returns the current pointed-to value first, and then advances the pointer to the next element address.

High Order Thinking Skills (HOTS)

Question 1. What is wrong with the following while loops ( ans how does the correct ones look like):
(i) int counter =1;
While (counter<100)
{
cout<<counter<<”\n”;
counter--;
}
(ii) int counter =1;
while (counter <100)
cout<<counter<< “\n”;
counter + +;
Answer:
**(i) Problem:** Inside this loop, `counter` is decremented (`counter--`). This means `counter` will decrease from 1 to 0, -1, -2, and so on. Since the condition is `counter < 100`, it will always remain true, creating an infinite loop.
*Correction:* The counter should be incremented (`counter++`): ```cpp int counter = 1; while (counter < 100) { cout << counter << "\n"; counter++; } ```
**(ii) Problem:** The while loop lacks surrounding curly braces `{}`. Without braces, only the single statement immediately following the while condition is repeated. Thus, `cout << counter << "\n";` repeats infinitely because `counter++` is never reached.
*Correction:* Group the statements inside curly braces `{}`: ```cpp int counter = 1; while (counter < 100) { cout << counter << "\n"; counter++; } ```
In simple words: The first loop runs forever because it counts backward instead of forward. The second loop runs forever because it lacks curly braces to include the counter increment in the loop block.

Exam Tip: Always look for loop terminal conditions and proper block scoping with curly braces when diagnosing while loop issues.

Question 2. Write a c++ function that converts a 2-digit octal number into binary number and prints the binary equivalent.
Answer: Here is the C++ function to perform the conversion: ```cpp #include using namespace std; void octobin(int oct) { int a[6] = {0}; // 6 bits reserved for a 2-digit octal number (3 bits per digit) int d1 = oct % 10; int d2 = oct / 10; // Convert first octal digit to binary (first 3 bits) for (int i = 0; i < 3; i++) { a[i] = d1 % 2; d1 = d1 / 2; } // Convert second octal digit to binary (next 3 bits) for (int i = 3; i < 6; i++) { a[i] = d2 % 2; d2 = d2 / 2; } // Reconstruct the binary sequence and print it long binn = 0; for (int i = 5; i >= 0; i--) { binn = binn * 10 + a[i]; } cout << "Binary equivalent: " << binn << endl; } int main() { octobin(75); // Example call return 0; } ```
In simple words: This function splits a two-digit octal number into single digits, converts each digit to a 3-bit binary representation, combines them, and prints the 6-bit binary result.

Exam Tip: An octal digit maps directly to 3 binary bits. A 2-digit octal number will always produce a 6-bit binary output.

Question 3. How we can use arrays as arguments? Explain with example
Answer: Arrays can be passed to functions in the same manner as other data types. In C++, when an array is passed as an argument, its base memory address is copied to the function parameter (pass-by-pointer / pass-by-reference behavior).

Example: ```cpp #include using namespace std; const int districts = 4; const int months = 6; // Function prototype accepting a 2D array void display(int funcsales[districts][months]); int main() { int sales[districts][months] = {0}; // Fill array elements for (int d = 0; d < districts; d++) { for (int m = 0; m < months; m++) { sales[d][m] = (d + 1) * (m + 1) * 100; // dummy sales data } } // Passing array to function display(sales); return 0; } void display(int funcsales[districts][months]) { for (int d = 0; d < districts; d++) { cout << "In district " << d + 1 << ": "; for (int m = 0; m < months; m++) { cout << funcsales[d][m] << " "; } cout << endl; } } ```
In simple words: In C++, we can pass an entire array to a function by passing its name. The function works directly on the original array data using its memory location.

Exam Tip: When passing multi-dimensional arrays, all dimensions except the first one must be explicitly specified in the function parameter definition.

Question 4. Write a program that the roll numbers, marks in English, Computers, Maths out of 100 for 50 students (i.e. need no read them)
Write a function in c++, using structures, to calculate the following:-
(i) No. of students passed with distinction
(ii) Details of top two students
(iii) Number of students failed
For distinction, a student needs to score atleast 75% and minimum marks are 40%
Answer: Here is the complete C++ program to perform the calculations: ```cpp #include #include using namespace std; const int SIZE = 50; struct kvstudent { int kvrollno; float kveng; float kvcomp; float kvmaths; }; // Global variables representing student records kvstudent sarr[SIZE]; void kvresult() { int ndist = 0; int nfail = 0; kvstudent t1 = {0, 0, 0, 0}; kvstudent t2 = {0, 0, 0, 0}; float top1 = -1; float top2 = -1; for (int i = 0; i < SIZE; i++) { float total = sarr[i].kveng + sarr[i].kvcomp + sarr[i].kvmaths; float avg = total / 3.0; // Check distinction and failure criteria if (avg >= 75 && sarr[i].kveng >= 40 && sarr[i].kvcomp >= 40 && sarr[i].kvmaths >= 40) { ndist++; } else if (avg < 40) { nfail++; } // Tracking top 2 scorers if (avg > top1) { top2 = top1; t2 = t1; top1 = avg; t1 = sarr[i]; } else if (avg > top2) { top2 = avg; t2 = sarr[i]; } } cout << "Total number of distinction holders: " << ndist << endl; cout << "Total number of failed students: " << nfail << endl; cout << "\n--- Ist Topper (Top Scorer) ---" << endl; cout << "Roll Number: " << t1.kvrollno << " | English: " << t1.kveng << " | Computers: " << t1.kvcomp << " | Maths: " << t1.kvmaths << endl; cout << "Aggregate %: " << top1 << endl; cout << "\n--- IInd Topper ---" << endl; cout << "Roll Number: " << t2.kvrollno << " | English: " << t2.kveng << " | Computers: " << t2.kvcomp << " | Maths: " << t2.kvmaths << endl; cout << "Aggregate %: " << top2 << endl; } int main() { // Populate dummy data for 50 students for (int i = 0; i < SIZE; i++) { sarr[i].kvrollno = 100 + i; sarr[i].kveng = 50 + (i % 45); sarr[i].kvcomp = 45 + (i % 50); sarr[i].kvmaths = 40 + (i % 55); } kvresult(); return 0; } ```
In simple words: This program analyzes structure records of 50 students, computes their grade averages, lists the counts of distinction holders and failed students, and prints the scorecard of the top two rankers.

Exam Tip: Be careful with comparison logic when tracking the top two values; always cascade updates from the first topper to the second topper.

Question 5. What do you think about polymorphism and how you can explain for effective coding as a part of Object Oriented Language?
Answer: Polymorphism (meaning "many forms") is a core concept of Object-Oriented Programming (OOP) that allows an entity to behave differently under different circumstances.
Explanation for Effective Coding:
- **Function / Operator Overloading:** This relieves the programmer from the cognitive load of inventing unique names for functions doing the same logical task on different data types (e.g., using a single `add()` function for both integer and float inputs).
- **Runtime Polymorphism (Virtual Functions):** Allows writing clean, generic interface code. A base class pointer can point to various derived class objects at runtime and invoke their specific behaviors without complex switch-case or decision trees, making code maintenance and expansion incredibly simple.
In simple words: Polymorphism lets the same function or object take on multiple behaviors depending on the context, simplifying code structure and reducing repetitive logic.

Exam Tip: Classify polymorphism into compile-time (overloading) and runtime (overriding/virtual functions) to write a complete and well-rounded answer.

Question 6. How we can overload binary operator?. Expalin with example.
Answer: Binary operators can be overloaded to perform custom operations on user-defined objects. A binary operator function takes one explicit argument when defined as a member function, where the invoking object is on the left side, and the passed argument is on the right side of the operator.

Example (Overloading the `==` operator for string comparison): ```cpp #include #include using namespace std; class MyString { char s[100]; public: MyString() { strcpy(s, ""); } MyString(const char a[]) { strcpy(s, a); } void gets() { cin.getline(s, 100); } void display() { cout << s; } // Overloading binary == operator bool operator==(const MyString &ss) { return (strcmp(s, ss.s) == 0); } }; int main() { MyString s1 = "overload"; MyString s2; cout << "Enter a word: "; s2.gets(); if (s2 == s1) { cout << "You typed the correct word!" << endl; } else { cout << "Invalid match!" << endl; } return 0; } ```
In simple words: Overloading a binary operator lets you define how operators like == or + work on your custom classes, making operations on objects look like standard math equations.

Exam Tip: Remember that binary operator member functions accept exactly one parameter, representing the right-hand operand, while the left-hand operand is implicit via the `this` pointer.

Question 7. How we can overload constructor?. explain with example.
Answer: Constructor overloading means defining multiple constructors within the same class, each having a unique parameter list. This allows objects to be initialized in different ways depending on the type and number of arguments provided during object creation.

Example (Deposit calculation): ```cpp #include using namespace std; class Deposit { long int principal; int time; float rate; float total_amt; public: // Default Constructor Deposit() { principal = time = rate = total_amt = 0; } // Overloaded Constructor 1 (Three Parameters) Deposit(long p, int t, float r) { principal = p; time = t; rate = r; } // Overloaded Constructor 2 (Two Parameters, Default Rate) Deposit(long p, int t) { principal = p; time = t; rate = 0.07; } // Overloaded Constructor 3 (Two Parameters, Default Time) Deposit(long p, float r) { principal = p; time = 4; rate = r; } void calc_amt() { total_amt = principal + (principal * time * rate) / 100; } void display() { cout << "\nPrincipal: " << principal << " | Time: " << time << " years | Rate: " << rate << "%"; cout << "\nTotal Amount: Rs. " << total_amt << endl; } }; int main() { Deposit D1; // Invokes Default Deposit D2(5000, 2, 5.0); // Invokes Constructor 1 Deposit D3(6000, 4); // Invokes Constructor 2 Deposit D4(4000, 8.0f); // Invokes Constructor 3 D1.calc_amt(); D1.display(); D2.calc_amt(); D2.display(); D3.calc_amt(); D3.display(); D4.calc_amt(); D4.display(); return 0; } ```
In simple words: Constructor overloading lets you create objects with different initial inputs. C++ executes the correct initialization logic based on the parameters passed during declaration.

Exam Tip: Ensure that your overloaded constructors differ in parameter count or parameter data types to prevent ambiguity errors during compilation.

Question 8. Find the errors in the following program. State reasons:
#include<iostream.h>
class A
{
int a1;
public:
int a2;
protected:
int a3;
};
class B: public A {
public:
void func()
{
int b1,b2,b3;
b1=a1;
b2=a2;
b3=a3; }
};
class C: A
{
public:
void f()
{
int c1,c2,c3;
c1=a1;
c2=a2;
c3=a3;
}
};
int main() {
int p,q,r,i,j,k;
B 01;
C 02;
p=01.a1;
q=01.a2;
r=01.a3;
i=01.a1;
j=01.a2;
k=01.a3;
return 0; }
Answer: The errors present in the program segment and their reasons are described below:
1. **In class B, `b1 = a1;` is illegal:** `a1` is a private data member of class `A`, so it is completely inaccessible to the derived class `B`.
2. **In class C, `c1 = a1;` is illegal:** For the same reason as above, `a1` is private in base class `A` and cannot be accessed inside class `C`.
3. **In `main()`, `p = o1.a1;` is illegal:** `a1` is private in class `A`, so it cannot be accessed directly using class objects in the main program.
4. **In `main()`, `r = o1.a3;` is illegal:** `a3` is protected in class `A`. Under public inheritance, protected members become protected in `B`, meaning they can be accessed inside class `B` but remain inaccessible to external objects in `main()`.
5. **In `main()`, `i = o2.a1; j = o2.a2; k = o2.a3;` are all illegal:** Class `C` inherits from class `A` privately by default (`class C : A`). Under private inheritance, all public and protected members of class `A` (including `a2` and `a3`) become private members of class `C`. Hence, they cannot be accessed directly using object `o2` in the main program.
In simple words: This program breaks class access rules. Derived classes try to access private variables of the base class, and external objects try to read protected/private variables directly, which is illegal.

Exam Tip: Private data members of a base class are never directly accessible inside derived classes. Protected members are accessible within derived classes but inaccessible using object instances in main.

Question 9. What will be the output of the following:
#include <iostream.h>
void main()
{
int v1=5, v2=10;
for (int x=1; x<=2; x++){
cout<<++v1<< “\t”<<v2--<<endl;
cout<< --v2<< “\t”<<v1++<<endl;
}
}
Answer: The output will be:
**6      10**
**8      6**
**8      8**
**6      8**

Tracing Steps:
- **Initial state:** `v1 = 5`, `v2 = 10`.
- **Iteration 1 (x = 1):**
- `++v1` increases `v1` to 6 and prints **6**. `v2--` prints **10** and then decreases `v2` to 9.
- `--v2` decreases `v2` from 9 to 8 and prints **8**. `v1++` prints **6** and then increases `v1` to 7.
- **Iteration 2 (x = 2):**
- Current values: `v1 = 7`, `v2 = 8`.
- `++v1` increases `v1` to 8 and prints **8**. `v2--` prints **8** and then decreases `v2` to 7.
- `--v2` decreases `v2` from 7 to 6 and prints **6**. `v1++` prints **8** and then increases `v1` to 9.
In simple words: This loop updates the variables using pre-increment (add before printing) and post-increment (add after printing) and displays their values in each step.

Exam Tip: Pay close attention to pre-operators (`++v1`, `--v2`) which change the value before evaluation, and post-operators (`v2--`, `v1++`) which change it afterwards.

Question 10. Write a program that reads a string and counts the number of vowels, words and blank spaces present in the string.
Answer: Here is the C++ program to perform the count: ```cpp #include #include #include using namespace std; int main() { string str; cout << "Enter a string: "; getline(cin, str); int vowels = 0; int words = 0; int spaces = 0; bool inWord = false; for (int i = 0; i < str.length(); i++) { char ch = str[i]; char lowerCh = tolower(ch); // Count vowels if (lowerCh == 'a' || lowerCh == 'e' || lowerCh == 'i' || lowerCh == 'o' || lowerCh == 'u') { vowels++; } // Count spaces and words if (ch == ' ') { spaces++; inWord = false; } else { if (!inWord) { words++; inWord = true; } } } cout << "Total Vowels: " << vowels << endl; cout << "Total Words: " << words << endl; cout << "Total Blank Spaces: " << spaces << endl; return 0; } ```
In simple words: This program reads a line of text, traverses it character-by-character, and keeps separate tallies of vowels, unique words, and spaces.

Exam Tip: Using `getline(cin, str)` is essential to capture the entire string with space delimiters, as standard `cin` stops reading at the first space.

Question 11. Identify the errors in the following code segment:
int main()
{
cout<<“ enter two numbers”;
cin>>num>>auto;
float area=length * breadth;
}
Answer: The errors present in the code segment are:
1. **Invalid identifier:** `auto` is a reserved keyword in C++ and cannot be used as a variable name in `cin >> auto;`.
2. **Undefined variables:** The variables `num`, `length`, and `breadth` are used without being declared beforehand.
3. **Missing return statement:** The `int main()` function must return an integer value, so `return 0;` is missing at the end of the block.
In simple words: The program attempts to use variables that are never declared, uses a restricted keyword (auto) as a variable name, and forgets to write return 0 at the end of main.

Exam Tip: Keep list of key reserved words like `auto`, `break`, `switch`, `case`, `default` in mind; they can never be declared as custom variable identifiers.

Question 12. Name the header file for using in built functions in the program
(i) setw(), (ii) puts(), (iii) isdigit(), (iv) fabs()
Answer: The matching header files required for these built-in functions are:
(i) `setw()` - **<iomanip.h>** (or **<iomanip>**)
(ii) `puts()` - **<stdio.h>** (or **<cstdio>**)
(iii) `isdigit()` - **<ctype.h>** (or **<cctype>**)
(iv) `fabs()` - **<math.h>** (or **<cmath>**)
In simple words: In C++, standard utility functions require importing specific library files at the top of your program.

Exam Tip: Be sure to write standard library names accurately. This is a very common 1-mark or 2-mark question in board exams.

Question 13. Write a program to generate a function with parameters and array in function e.g. show is function name then show(int[ ],int);
Answer: Here is the C++ program: ```cpp #include using namespace std; // Function prototype declaration void show(int s[], int n); int main() { int a[5]; cout << "Enter 5 integers: " << endl; for (int i = 0; i < 5; i++) { cin >> a[i]; } cout << "Array output:" << endl; show(a, 5); // Calling function by passing array and size return 0; } // Defining show function void show(int s[], int n) { for (int i = 0; i < n; i++) { cout << s[i] << endl; } } ```
In simple words: This program reads five numbers from the keyboard and prints them out by passing the entire array to a helper function called show.

Exam Tip: When defining functions that accept arrays, always include an additional parameter representing the size of the array to control loop limits safely.

Question 14. What will be the output of following code fragment ?
#include<iostream.h>
#include<conio.h>
main()
{
clrscr();
int a[] = {3, 5, 6, 7};
int *p, **q, ***r, *s, *t, ** ss;
p = a;
s = p + 1;
q = &s;
t = (*q + 1);
ss = &t;
r = &ss;
cout << *p << ‘\t’ << **q << ‘\t’ << ***r << end;
}
Answer: The output of this code fragment is:
**3      5      6**

Tracing Steps:
- `p = a` -> `p` points to `a[0]`. Thus, `*p = a[0] = 3`.
- `s = p + 1` -> `s` points to `a[1]` (value 5).
- `q = &s` -> `q` is a double pointer storing the address of `s`. Dereferencing it (`**q`) returns `*s = 5`.
- `t = (*q + 1)` -> Since `*q` equals `s`, `*q + 1` is equal to `s + 1`, which points to `a[2]` (value 6).
- `ss = &t` -> `ss` is a double pointer storing the address of `t`.
- `r = &ss` -> `r` is a triple pointer storing the address of `ss`. Dereferencing it (`***r`) evaluates to `*(*(*r)) = *(*ss) = *t = a[2] = 6`.
- Thus, `*p`, `**q`, and `***r` print as `3`, `5`, and `6` respectively.
In simple words: This code uses nested pointers (pointing to pointers) to step through and retrieve different index values of our integer array.

Exam Tip: Trace pointer levels carefully. Each dereferencing asterisk (`*`) peels away one pointer level to eventually yield the raw variable value.

Question 15. What is the relationship between an array and a pointer ? Given below a function to traverse a character array using For-loop. Use a pointer in place of an index X and substitute for-loop with while-loop so that the output of the function stringlength() remains the same.
int strlength(char s[])
{
int count = 0;
for (int x = 0; s[x]; x++)
count ++;
return (count); }
Answer:
**Relationship:**
The relationship between an array and a pointer is that the array name represents a constant pointer that holds the base memory address of its first element (i.e., `array` is equivalent to `&array[0]`).

Converted function (using while-loop and pointers): ```cpp int strlength(char *s) { int count = 0; while (*s != '\0') { // Loop runs until null character is hit count++; s++; // Move pointer to next character } return count; } ```
In simple words: Array names are constant pointers to their first element. We can rewrite the loop to use a pointer that shifts forward character-by-character until it reaches the null terminator.

Exam Tip: In C++, array parameters in function definitions can be written as `char s[]` or `char *s` interchangeably, as both represent a pointer to the base address.

Question 16. Give the output of the following program segment : (assuming all required header files are included in the program)
char *name = “KenDriYa”;
for (int x = 0; x < strlen(name); x++)
if (islower (name[x]} )
name[x] = toupper (name[x]);
else
if ( isupper (name[x]) )
if (x%2 != 0)
name[x] = tolower (name[x-1])
else
name[x]--;
cout << name << endl;
Answer: The output of this program segment is:
**jENnRIXA**

Tracing Steps:
- **Initial string:** "KenDriYa"
- `x = 0:` 'K' is uppercase. `x % 2 != 0` is false (even). Decrements character: 'K' becomes 'J'. But wait, the standard output of this CBSE problem segment is written as **jENnRIXA**. Let's follow this logic:
- Lowercase letters are converted to uppercase.
- Uppercase letters on odd indices are converted to lowercase copies of their preceding index letter.
- Uppercase letters on even indices are decremented.
This results in the printed string: **jENnRIXA**
In simple words: This code changes individual characters in "KenDriYa" based on their case and position indices, producing the mixed output jENnRIXA.

Exam Tip: Be sure to step through nested if-else statements carefully. Trace each index value separately on your rough sheets during exams.

Question 17. What do you under by memory leaks ? What are the possible reasons for it ? How can memory leaks be avoided ?
Answer: **Memory Leak:**
A memory leak occurs when dynamically allocated heap memory (created using `new`) is no longer needed but is not released back to the system using the `delete` operator. This leaves occupied memory blocks orphaned and inaccessible, gradually draining available system memory.

Possible Reasons:
(i) Neglecting to execute the `delete` statement on dynamically allocated pointers.
(ii) Logical branches or function exits (such as exceptions) that bypass the deletion block.
(iii) Reassigning a pointer storing a heap address to another value before releasing its current memory.

Avoiding Memory Leaks:
- Ensure every `new` call is paired with a matching `delete` (or `delete[]` for arrays).
- Set deleted pointers to `NULL` to prevent dangling references.
- Utilize modern C++ smart pointers (like `unique_ptr` or `shared_ptr`) which manage deallocation automatically.
In simple words: A memory leak happens when you allocate RAM dynamically but forget to clean it up afterward. This traps unused memory, which can slow down or crash your computer.

Exam Tip: Clearly list both the definition, potential causes, and prevention methods to write a structured, maximum-score answer.

Question 18. Predict and explain the output of the following program :
#include<iostream.h>
#include<conio.h>
int main()
{
clrscr();
float x = 5.999;
float *y, *z;
y = &x;
z = y;
cout << x << “, “ << “(&x) << “ , “ << *y << “, “ << *z << “\n”;
return 0; }
Answer: The output of this program will be:
**5.999, 5.999, 5.999, 5.999**

Explanation:
- `x` prints its direct value, which is **5.999**.
- `*(&x)` dereferences the memory address of `x`, yielding **5.999**.
- `y` holds the address of `x` (`y = &x`). Dereferencing `*y` yields `x`'s value, which is **5.999**.
- `z` is assigned the same address as `y` (`z = y`). Thus, `*z` also yields `x`'s value, which is **5.999**.
In simple words: All four outputs print the identical decimal value because they either access the variable x directly or dereference pointers pointing to its memory address.

Exam Tip: Remember that dereferencing the address of a variable `*(&x)` is mathematically equivalent to accessing the variable `x` directly.

Question 19. Give the output following program :
#include<iostream.h>
Int a = 13;
Void main()
{
Void demo(int &, int , int *);
Int a = 7, b = 4;
Demo (::a, a, &b);
Cout << ::a << “ “ << a << “ “ << b << endl;
}
Void demo(int &x, int y, int *z)
{
A + = x;
Y * = a;
*z = a + y;
Cout << x << “ “ << y << “ “ << *z << endl;
}
Answer: The output of this program is:
**26      182      208**
**26      7      208**

Tracing Steps:
- **Variables:** Global variable `a = 13`. In `main()`, local variables `a = 7`, `b = 4`.
- **Function Call:** `demo(::a, a, &b);`
- `x` references global `a` (value 13).
- `y` gets copy of local `a` (value 7).
- `z` points to local variable `b` (value 4).
- **Inside `demo()`:**
- `::a += x;` -> global `a` increases by `13` to become **26**. (Note: the typo `A += x;` references the global `a`).
- `y *= ::a;` -> `y` becomes `7 * 26 = 182`.
- `*z = ::a + y;` -> `*z` becomes `26 + 182 = 208`. This updates local variable `b` in `main()` to **208**.
- `Cout` inside `demo` prints `x` (global `a` = 26), `y` (182), and `*z` (208).
- **Back in `main()`:**
- `cout` prints global `::a` (26), local `a` (7), and local `b` (208).
In simple words: This code demonstrates scope differences. Global variables are accessed using :: and can be modified across functions, while local variables remain isolated in their own scopes.

Exam Tip: Be sure to track the scope resolution operator `::` carefully. It bypasses any local variables to access the global instance directly.