CBSE Class 12 Computer Science Sure Shot Questions Worksheet Set 04

1. What do you mean by typedef and #define?

2. How many ways you pass the value to function.

3. Explain the use of inline function in C++ with the help of an example.

4. Differentiate between a run time error and syntax error. Also give suitable examples of each in C++.

5. Explain the concept of type-casting in C++ using an example.

6. What is the significance of access specifiers in a class ?

7. What is ‘this’ pointer? What is its significance?

8. What is the difference between a Local and a Global Variable?

Please click the link below to download full pdf file for CBSE Class 12 Computer Science Sure Shot Questions (4). 

Page 1

Question 1. What do you mean by typedef and #define?
Answer: The typedef keyword allows programmers to create an alias or alternative name for an existing data type, which can make complex declarations easier to read.
Example:

typedef char Str80[80];
Str80 str; // str is now a char array of size 80

On the other hand, the #define preprocessor directive is utilized to declare macros or symbolic constants. These definitions are substituted directly into the code by the preprocessor before the actual compilation begins.
Example:

#define PI 3.14159

In simple words: typedef gives a new nickname to an existing data type, while #define acts like a find-and-replace tool for constants or code snippets before the program compiles.

Exam Tip: Always write a clean code example showing how typedef is used with char or int arrays to score full marks in definitions.

Question 2. How many ways you pass the value to function.
Answer: There are two primary methods to pass values to functions in C++:
1. Call by Value: In this mechanism, a copy of the actual argument is passed to the formal parameters of the function. Because separate memory is allocated for the formal arguments, any modifications made inside the function do not affect the original variables in the calling environment.
2. Call by Reference: In this mechanism, the function receives a reference of the actual arguments rather than a copy. Since the formal parameters share the same memory location as the actual parameters, any changes made inside the function are directly reflected in the original variables.
Example:

void sample(int a, int &b) {
    a = a + 100;
    b = b + 200;
    cout << a << " " << b << endl;
}

void main() {
    int a = 50, b = 40;
    cout << a << " " << b << endl; // Prints: 50 40
    sample(a, b);                  // Prints: 150 240
    cout << a << " " << b << endl; // Prints: 50 240
}

In simple words: When passing by value, you send a copy of the variable, so the original stays safe. When passing by reference, you share the original variable, meaning any change inside the function alters the original directly.

Exam Tip: Be sure to draw a small reference trace or output table for the call-by-reference and call-by-value behaviors to demonstrate clarity to the evaluator.

Question 3. Explain the use of inline function in C++ with the help of an example.
Answer: An inline function is a function that is expanded in line when it is called. When the C++ compiler encounters a call to an inline function (declared using the inline keyword), it replaces the function call with the actual code of the function. This avoids the overhead of a normal function call, such as saving registers and pushing arguments onto the stack, making execution faster for small functions.
Example:

#include <iostream.h>

inline int exforsys(int x1) {
    return 5 * x1;
}

void main() {
    int x;
    cout << "\n Enter the Input Value: ";
    cin >> x;
    cout << "\n The Output is: " << exforsys(x);
}

In simple words: An inline function tells the compiler to replace the function call directly with the function's code. This speeds up your program by avoiding the usual slow process of jumping back and forth to a separate function.

Exam Tip: Remember that the compiler can ignore the inline request if the function is too complex or contains loops, which is a common multiple-choice question.

Question 4. Differentiate between a run time error and syntax error. Also give suitable examples of each in C++.
Answer: The differences between a runtime error and a syntax error are as follows:
1. Runtime Error: This occurs while the program is actively running, even if it compiled successfully. These errors typically happen due to unexpected user input or illegal operations, causing the program to terminate abruptly.
Example: Dividing an integer by zero (like C = A / B when B is 0) leads to a division-by-zero runtime crash.
2. Syntax Error: This is a grammatical violation of the programming language's rules, which is detected by the compiler during compilation. The compiler will fail to generate an executable binary until all syntax errors are resolved.
Example: Using the wrong stream insertion operator, such as writing cout >> "Hello"; instead of cout << "Hello";, or forgetting a semicolon at the end of a statement.
In simple words: A syntax error is like a grammar mistake in a sentence that the compiler spots before running. A runtime error is like a sudden crash that happens while the program is running, such as trying to divide a number by zero.

Exam Tip: Underline key phrases like "during compilation" for syntax errors and "during execution" for runtime errors to catch the examiner's eye.

Question 5. Explain the concept of type-casting in C++ using an example.
Answer: Type casting (specifically explicit type conversion) is a programmer-initiated process where a variable of one data type is manually converted into another data type. This is done by placing the target data type inside parentheses before the variable or expression.
Example:

int A = 1, B = 2;
float C = (float)A / B; // Explicit type casting
cout << C; // Outputs: 0.5

In this example, the integer A is explicitly cast to a float before the division occurs, ensuring that the division returns a precise fractional result (0.5) instead of truncated integer division (which would result in 0).
In simple words: Type casting is when you force the computer to change a variable from one type to another, like turning a whole number into a decimal so you can get a more accurate fraction when dividing.

Exam Tip: Always show a fractional calculation (like 1/2) to demonstrate how type-casting prevents integer truncation.

Question 6. What is the significance of access specifiers in a class ?
Answer: In C++, access specifiers (private, protected, and public) define the visibility and accessibility of class members (data variables and functions). Members marked as private are only accessible inside the class itself, protecting sensitive internal state from unauthorized external modification. protected members behave like private members but can also be accessed by derived classes during inheritance. Members marked as public are accessible from anywhere outside the class, defining the class's public interface.
In simple words: Access specifiers act like security guards for a class. 'Private' keeps data hidden inside, 'protected' shares it only with family (derived classes), and 'public' lets anyone outside use it.

Exam Tip: Explicitly mention "encapsulation" and "data hiding" as the primary software engineering benefits of access specifiers.

Question 7. What is ‘this’ pointer? What is its significance?
Answer: In C++, this is an implicit pointer available within all non-static member functions of a class. It points directly to the specific object that called the member function, storing its memory address. This allows a member function to distinguish between the object's member variables and local parameters of the same name (for example, this->value = value). It is also useful for returning the current object by reference (using return *this;) from member functions to enable method chaining.
In simple words: The 'this' pointer is a special variable that tells a function exactly which object is currently calling it, helping the computer avoid confusion when multiple objects use the same function.

Exam Tip: State clearly that static member functions do not have a this pointer, as they are not associated with any specific object.

Question 8. What is the difference between a Local and a Global Variable?
Answer: The differences between a local variable and a global variable are as follows:
1. Local Variable: A local variable is declared inside a function or a block of code and can only be accessed or modified within that specific block. Its lifetime is limited, as it is created when the block is entered and destroyed when the block is exited.
2. Global Variable: A global variable is declared outside all functions, making it accessible from any part of the program throughout the program's entire execution. Its lifetime spans from the start of the program until execution ends.
Example:

#include <iostream.h>

int globalVar = 10; // Global variable - accessible everywhere

void main() {
    int localVar = 5; // Local variable - accessible only within main()
    cout << globalVar << " " << localVar << endl;
}

In simple words: A local variable is only known inside the function where it is created and vanishes when the function ends. A global variable is created outside all functions, is known everywhere, and stays alive as long as the program is running.

Exam Tip: Clearly define both "scope" (where it is visible) and "lifetime" (how long it exists in memory) when comparing these two variable types.

Q 1 (A) 1 MARK HEADER FILES QUESTIONS

Question 1. Name the header file(s) that shall be needed for successful compilation of the following C++ code.

void main ( ) 
 { 
 char string [20]; 
 gets (string); 
 strcat(String, CBSE); 
 puts (string); 
 } 

Answer: The header files required for compiling this C++ code successfully are:
1. <stdio.h> (or <cstdio>) – This is necessary for the gets() and puts() standard input/output functions.
2. <string.h> (or <cstring>) – This is required for the string manipulation function strcat().
In simple words: The gets() and puts() functions need the stdio.h header, while the strcat() function needs string.h to compile and run.

Exam Tip: Always specify the exact purpose or functions (e.g., gets(), puts(), strcat()) that depend on each header file to secure full marks from examiners.

Question 2. Name the header file(s) that shall be needed for successful compilation of the following C++ code.

void main ( ) 
 { 
 int Last=25; 
 for(int C=9;C<=Last;C++) 
 { 
 cout<<C<<”:”<<sqrt(C)<<endl; 
 } 
 } 

Answer: The required header files for compiling this code segment successfully are:
1. <iostream.h> – This is necessary to support cout and endl stream objects.
2. <math.h> – This is required to support the mathematical function sqrt().
In simple words: To use cout and endl, you must include iostream.h, and to use the square root function sqrt(), you need math.h.

Exam Tip: Remember that math functions like sqrt(), pow(), and sin() are defined in the math.h header file, which is a common map point for board exam questions.

Question 3. Name the header files that shall be required for successful compilation of the following C++ program :

intmain( ) 
 { charstr[20]; 
 cout<<fabs(-34.776); 
 cout<<”\n Enter a string : ”; 
 cin.getline(str,20); 
 return 0; 
}

Answer: To successfully compile this C++ program, the following header files must be included:
1. <iostream.h> – This is required for cout and cin.getline() standard stream operations.
2. <math.h> – This is necessary for the absolute value function fabs() which handles floating-point numbers.
In simple words: The cout and cin.getline() tools require iostream.h, while fabs() requires the math.h library.

Exam Tip: Distinct from abs() which handles integers in stdlib.h, fabs() is specifically for floating-point absolute values and resides in math.h.

Question 4. Observe the following C++ code and write the name(s) of the header file(s), which will be essentially required to run it in a C++ compiler:

void main() 
{ charch, str[20]; 
cin>>str; 
ch=tolower(str[0]); 
cout<<str<<”Starts with”<<ch<<endl; 
}

Answer: The essential header files required to run this code in a C++ compiler are:
1. <iostream.h> – This is needed for standard input and output streams like cin, cout, and endl.
2. <ctype.h> – This is required for the character manipulation function tolower().
In simple words: You need ctype.h to use the tolower() function, and iostream.h for reading inputs with cin and printing outputs with cout.

Exam Tip: Character conversion and testing functions (such as tolower, toupper, isalpha, and isdigit) are always declared inside ctype.h.

Question 5. Name the header files that shall be needed for the following code:

void main( ) 
 { 
 char Text[ ] = “Welcome to C++ Prog.”; 
 cout<<setw(20)<<Text; 
 } 

Answer: To successfully compile and execute the given code, the following header files are required:
1. <iostream.h> – This is necessary for the standard stream insertion operator and cout object.
2. <iomanip.h> – This is required for the parameterized stream manipulator setw().
In simple words: You need iostream.h to display the text using cout, and iomanip.h to format the spacing of the output using setw().

Exam Tip: Manipulators that take arguments (like setw, setprecision, and setfill) are defined in iomanip.h, while non-parameterized ones like endl are in iostream.h.

Q 1 (C) 2 MARKS ERROR FINDING QUESTIONS

Question 1. Rewrite the following program after removing all the syntax error(s), if any. Underline each correction.

#include<iostream.h> 
struct Pix 
{ int Color, Style ; 
}
voidShowPoint(Pix P) 
{ cout<<P.Color,P.Style<<endl; 
}
void main() 
{ Pix Point1 = (5,3); 
ShowPoint(Point1); 
Pix Point2 = Point1 
Color.Point1+=2; 
ShowPoint(Point2); 
}

Answer: The corrected and re-written C++ program is shown below, with each syntax correction underlined:

#include<iostream.h> 
struct Pix 
{ int Color, Style ; 
}; 

void ShowPoint(Pix P) 
{ 
    cout<<P.Color<<P.Style<<endl; 
}

void main() 
{ 
    Pix Point1 = {5,3}; 
    ShowPoint(Point1); 
    Pix Point2 = Point1; 
    Point1.Color+=2; 
    ShowPoint(Point2); 
}

In simple words: This question checks for common syntax mistakes in C++ structures. The corrected parts include adding semicolons to terminate declarations, using curly braces for structure initialization, correcting standard output stream operators, and referencing members via the correct 'object.member' syntax.

Exam Tip: Always remember that a struct definition in C++ must be terminated with a semicolon after the closing brace, or the compiler will throw an error on the subsequent line.

Question 2. Re-write the following code segment removing the errors, underlining each correction:

#include<iostrem.h> 
class Student{ 
 intnum =0; 
 char name[ ]; 
 public: 
 voidgetdata() 
{
 cin>>num; 
 cin.getline(name); 
 } 
 }; 
 void main() 
{
 Student obj; 
 getdata(); 
} 

Answer: The corrected and re-written C++ code segment is shown below, with each syntax correction underlined:

#include<iostream.h> 
class Student{ 
    int num; 
    char name[10]; 
 public: 
    void getdata() 
    {
        cin>>num; 
        cin.getline(name, 10); 
    } 
 }; 

 void main() 
{
    Student obj; 
    obj.getdata(); 
} 

In simple words: This code corrects basic class syntax errors in classic C++. We fix the misspelled library name, declare the member variable without illegal inline initialization, specify the array size for the string, add the required size argument to cin.getline(), and call the function using the class object.

Exam Tip: In classic C++ compilers, data members cannot be initialized inside the class declaration. They must be initialized either inside a constructor or through a member function.

Question 3. Rewrite the following program after removing the syntactical error(s),if any.Underline each correction.

#include<iostream.h> 
 constint multiple 3; 
 void main( ) 
 {
 value=15; 
 for(int c=0,c<=5,c++;value-=2) 
 if(value%multiple= = 0) 
 cout<<value*multiple; 
 cout<<endl; 
 else 
 cout>>value+multiple<<endl; 
 }

Answer: The corrected and re-written C++ program is shown below, with each syntax correction underlined:

#include<iostream.h> 
const int multiple = 3; 
void main( ) 
{
    int value=15; 
    for(int c=0; c<=5; c++, value-=2) 
    {
        if(value%multiple == 0) 
        {
            cout<<value*multiple; 
            cout<<endl; 
        }
        else 
            cout<<value+multiple<<endl; 
    }
}

In simple words: This code fixes several grammatical syntax errors in a loop and conditional block. We declare the type of 'value', fix the loop delimiters from commas to semicolons, correct the equality comparison operator, add curly braces to group the if-block statements, and correct the stream operator for cout.

Exam Tip: Whenever an if statement is followed by multiple statements before an else, you must wrap those statements in curly braces {} to avoid a dangling "unmatched else" syntax error during compilation.

Question 1. Find the output of the following program.

#include <iostream.h> 
#include <string.h> 
#include<ctype.h> 
void main() 
{ 
    intchcount = 0,i=0, len; 
    charch[80] = “Programming Language C++”; 
    len = strlen(ch); 
    while(i<= (len-1)) 
    { 
        chcount++; 
        if(islower(ch[i])) 
            ch[i]=toupper(ch[i]); 
        else if (isupper(ch[i])) 
            ch[i] = toupper(ch[i]); 
        cout<<ch[i]; 
        ++i; 
    } 
    cout<<chcount; 
}

Answer: PROGRAMMING LANGUAGE C++24

Explanation: Inside the loop, the program checks each character of the string "Programming Language C++". If a character is lowercase, it is converted to uppercase using toupper(). If it is already uppercase, it remains uppercase. Spaces and special characters (like '+') are unaffected but counted. Each character is displayed immediately. Finally, the total count of characters, which is 24, is printed at the end.
In simple words: The program goes through the string, changes all lowercase letters to capital letters, prints them out one by one, and then prints the total number of characters in the string, which is 24.

Exam Tip: When analyzing string manipulation loops, watch out for where the cout statement is located; since it is inside the loop here, the modified string is printed step-by-step rather than all at the end.

Question 2. Find the output of the following program:

#include<iostream.h> 
#include<ctype.h> 
struct colors 
{
    int x, y, z; 
}; 
void shuffle(colors &col, intpos=1) 
{
    col.x+=pos; col.y-=pos; col.z*=pos; 
}
int main() 
{
    colors me={10,20, 5}; 
    shuffle(me, 2); 
    shuffle(me); 
    cout<<me.x<<':'<<me.y<<':'<<me.z; 
}

Answer: 13:17:10

Explanation: The initial values of me are x=10, y=20, and z=5. First, shuffle(me, 2) is called, which increments x by 2 (12), decrements y by 2 (18), and multiplies z by 2 (10). Next, shuffle(me) is called, which defaults pos to 1. This adds 1 to x (13), subtracts 1 from y (17), and multiplies z by 1 (10). Finally, these values are output separated by colons.
In simple words: The program updates the coordinates step-by-step: first changing them using the number 2, then using the default value of 1, and then prints the final coordinates.

Exam Tip: Pay close attention to default arguments in function declarations; if no argument is provided for that parameter during a function call, the default value is automatically used.

Question 3. Give the output of the following program :

#include<iostream.h> 
int global=10; 
voidfunc(int&x, int y) 
{
    x=x-y;
    y=x*10; 
    cout<<x<<”,“<<y<<”\n”; 
}
void main() 
{
    int global=7; 
    func(::global,global); 
    cout<<global<<”,”<<::global<<”\n”; 
    func(global,::global); 
    cout<<global<<”,”<<::global<<”\n”; 
}

Answer:

3,30
7,3
4,40
4,3

Explanation: The program uses the scope resolution operator :: to access the global variable.
- First call func(::global, global) passes the global variable (10) by reference and the local variable (7) by value. Inside func, global becomes 3 (10 - 7) and local parameter y becomes 30. Prints 3,30.
- Back in main(), the local variable is still 7 and the global is 3, printing 7,3.
- Second call func(global, ::global) passes the local variable (7) by reference and the global (3) by value. Inside func, the local variable becomes 4 (7 - 3) and parameter y becomes 40. Prints 4,40.
- Back in main(), the local variable is now 4 and the global is still 3, printing 4,3.
In simple words: The program changes the global and local variables through reference parameters and prints their progress step-by-step.

Exam Tip: Make sure to differentiate between references (which modify the passed variable) and standard value parameters (which only modify local copies inside the function).

Question 4. Give the output of the following program:

#include<iostream.h> 
struct pixel 
{
    intc,r; 
}; 
void display(pixel p) 
{
    cout<<p.c<<” “<<p.r<<endl; 
}
void main() 
{
    pixel x={40,50},y,z; 
    z=x; 
    x.c+=10; 
    y=z; 
    y.c+=10; 
    y.r+=20; 
    z.c-=15; 
    display(x); 
    display(y); 
    display(z); 
}

Answer:

50 50
50 70
25 50

Explanation: Struct variables in C++ are copied by value. Assigning z = x copies elements of x to z independently. Thus, any changes made to x.c later do not affect z.c. Similarly, modifying y or z does not impact other pixel variables. Working through each instruction: x ends as {50, 50}, y ends as {50, 70}, and z ends as {25, 50}.
In simple words: When you assign one struct variable to another, a completely fresh copy is made, so changing one variable does not mess up the others.

Exam Tip: Always remember that structure assignments are direct copy operations, unlike arrays which pass pointers by default.

Question 5. write the output of the following programme segment:

char *name=”ComPUteR”; 
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]); 
        else 
            name[x]=name[x-1]; 
puts(name); 

Answer: cOMMuTEE

Explanation: The program inspects each letter of "ComPUteR" sequentially:
- Index 0 ('C'): Uppercase, even index -> changed to lowercase 'c'.
- Index 1 ('o'): Lowercase -> changed to uppercase 'O'.
- Index 2 ('m'): Lowercase -> changed to uppercase 'M'.
- Index 3 ('P'): Uppercase, odd index -> takes value of previous char (index 2), which is 'M'.
- Index 4 ('U'): Uppercase, even index -> changed to lowercase 'u'.
- Index 5 ('t'): Lowercase -> changed to uppercase 'T'.
- Index 6 ('e'): Lowercase -> changed to uppercase 'E'.
- Index 7 ('R'): Uppercase, odd index -> takes value of previous char (index 6), which is 'E'.
In simple words: The program scans the word letter by letter, converting lowercase to uppercase, and altering uppercase letters depending on whether they sit on an even or odd position.

Exam Tip: When a character array's current index is updated based on a previous index (like name[x-1]), always use the newly modified value of the previous character.

Question 6. In the following program, find the correct possible output(s) from the options:

#include<stdlib.h> 
#include<iostream.h> 
void main( ) 
{ randomize( ); 
    char City[ ] [10]={“DEL”,”CHN”,”KOL”,”BOM”,”BNG”}; 
    int Fly; 
    for(int I=0;I<3:I++) 
    { 
        Fly=random(2)+1; 
        Cout<<City[Fly]<<”:”; 
    } 
} 

Outputs:
(i) DEL:CHN:KOL:
(ii) CHN:KOL:CHN:
(iii) KOL:BON:BNG:
(iv) KOL:CHN:KOL
Answer: (ii) CHN:KOL:CHN: or (iv) KOL:CHN:KOL

Explanation: The array City contains elements at the following indexes: Index 0 is "DEL", Index 1 is "CHN", Index 2 is "KOL", Index 3 is "BOM", and Index 4 is "BNG". The statement random(2) generates values 0 or 1. Adding 1 yields a value range of 1 or 2 for Fly. This means only indexes 1 ("CHN") and 2 ("KOL") can be selected. Therefore, only options (ii) and (iv), which contain exclusively "CHN" and "KOL", are possible outputs.
In simple words: The random function only generates index numbers 1 and 2, which point to "CHN" and "KOL". This makes options (ii) and (iv) the only possible answers.

Exam Tip: When solving random number questions, first find the range of possible values for the index variable, and then eliminate options containing any elements outside that range.

Question 7. Predict the output of the following program and give justification

#include<iostream.h> 
#include<stdlib.h> 
void main() 
{ 
    int low = 10, p=5; 
    randomize(); 
    for(inti=1;i<=4;++i) 
    { 
        cout<<(random(p)+low); 
        cout<<":"; 
        p--; 
    } 
} 

Outputs:
i) 13:13:14:10:
ii) 14:14:11:11
iii) 14:13:11:11:
iv) 14:13:13:11:
Answer: iii) 14:13:11:11:

Explanation: Let's trace the loop's iterations step-by-step:
- Iteration 1 (i=1): p=5, output is random(5) + 10. Range of values possible: [10 to 14]. After output, p decrements to 4.
- Iteration 2 (i=2): p=4, output is random(4) + 10. Range of values possible: [10 to 13]. After output, p decrements to 3.
- Iteration 3 (i=3): p=3, output is random(3) + 10. Range of values possible: [10 to 12]. After output, p decrements to 2.
- Iteration 4 (i=4): p=2, output is random(2) + 10. Range of values possible: [10 to 11]. After output, p decrements to 1.
Comparing the options, only option (iii) has a sequence (14, 13, 11, 11) where each value falls within these respective decreasing ranges.
In simple words: Because the range of possible numbers gets smaller with each step (first 10-14, then 10-13, then 10-12, and finally 10-11), only 14:13:11:11 fits all the rules perfectly.

Exam Tip: When p decreases inside the loop, the upper limit of the random range decreases by 1 in each iteration. Write out a table of minimum and maximum values for each step to verify the options easily.