300+ REAL TIME C++ Programming Objective Questions & Answers 2023

10. What will happen when the handler is not found for an exception?
a) calls the standard library function terminate()
b) raise an error
c) executes the remaining block
d) raise an error and executes the remaining block
Answer: a
Clarification: None.

250+ TOP MCQs on Subscripting and Answers

This section on C++ interview questions and answers on “Subscripting”. One shall practice these interview questions to improve their C++ programming skills needed for various interviews (campus interviews, walkin interviews, company interviews), placements, entrance exams and other competitive exams. These questions can be attempted by anyone focusing on learning C++ programming language. They can be a beginner, fresher, engineering graduate or an experienced IT professional. Our C++ interview questions come with detailed explanation of the answers which helps in better understanding of C++ concepts.

Here is a listing of C++ interview questions on “Subscripting” along with answers, explanations and/or solutions:

1. subscript operator is used to access which elements?
a) string
b) char
c) array
d) float
Answer: c
Clarification: To access any element of an array we use following syntax array[i], where i is called subscript representing the ith element of an array, whereas no such cases in char and strings.

2. How many arguments will the subscript operator will take for overloading?
a) 1
b) 2
c) 0
d) as many as possible
Answer: a
Clarification: The subscript operator overload takes only one argument, but it can be of any type.

3. Pick out the correct statement.
a) subscript operator has a higher precedence than the assignment operator
b) subscript operator has a lower precedence than the assignment operator
c) subscript operator is used with string elements
d) subscript operator is used with char elements
Answer: a
Clarification: Subscription operator has more precedence otherwise if that is not the case then the statement var = arr[i] will be meaningless and will have no effect.

4. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    const int SIZE = 10;
```
```
    class safe
```
```
    {
```
```
        private:
```
```
        int arr[SIZE];
```
```
        public:
```
```
        safe()
```
```
        {
```
```
            register int i;
```
```
            for (i = 0; i < SIZE; i++)
```
```
            {
```
```
                arr[i] = i;
```
```
            }
```
```
        }
```
```
        int &operator[](int i)
```
```
        {
```
```
            if (i > SIZE)
```
```
            {
```

                cout << "Index out of bounds" <<endl;

```
                return arr[0];
```
```
            }
```
```
            return arr[i];
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        safe A;
```
```
        cout << A[5];
```
```
        cout  << A[12];
```
```
        return 0;
```
```
    }
```

5Index out of bounds
 0

b) 40
c) 50
d) 51
Answer: a
Clarification: In this program, We are returning the elements in the specified array location and if it is out of bound means it will return the first element.
Output:

$ g++ sub.cpp
$ a.out
5Index out of bounds
0

5. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    class numbers
```
```
    {
```
```
        private:
```
```
        int m_nValues[10];
```
```
        public:
```

        int& operator[] (const int nValue);

```
    };
```

    int& numbers::operator[](const int nValue)

```
    {
```
```
        return m_nValues[nValue];
```
```
    }
```
```
    int main()
```
```
    {
```
```
        numbers N;
```
```
        N[5] = 4;
```
```
        cout <<  N[5];
```
```
        return 0;
```
```
    }
```

a) 5
b) 4
c) 3
d) 6
Answer: b
Clarification: In this program, We are getting the values and returning it by overloading the subscript operator.
Output:

6. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    const int limit = 4;
```
```
    class safearray
```
```
    {
```
```
        private:
```
```
        int arr[limit];
```
```
        public:
```
```
        int& operator [](int n)
```
```
        {
```
```
            if (n == limit - 1)
```
```
            {
```
```
                int temp;
```

                for (int i = 0; i < limit; i++)

```
                {
```

                    if (arr[n + 1] > arr[n])

```
                    {
```
```
                        temp = arr[n];
```

                        arr[n] = arr[n + 1];

                        arr[n + 1] = temp;

```
                    }     
```
```
                }  
```
```
            }
```
```
            return arr[n];
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        safearray sa1;
```
```
        for(int j = 0; j < limit; j++)
```
```
            sa1[j] = j*10;
```
```
        for(int j = 0; j < limit; j++)
```
```
        {
```
```
            int temp = sa1[j];
```

            cout << "Element " << j << " is " << temp;

```
        }
```
```
        return 0;
```
```
    }
```

a) 0102030
b) 1020300
c) 3020100
d) error
Answer: a
Clarification: In this program, we are returning the array element by the multiple of 10.
Output:

$ g++ sub2.cpp
$ a.out
0102030

7. What will be the output of the following C++ code?

```
    #include  
```
```
    using namespace std;
```
```
    class A
```
```
    {
```
```
        public:
```
```
        int x;
```
```
        A(int n = 0) : x(n) {};
```
```
        int& operator[](int n)
```
```
        {
```
```
             cout << "0" ;
```
```
             return x;
```
```
        }
```
```
        int operator[](int n) const
```
```
        {
```
```
             cout << "1" ;
```
```
             return x;
```
```
        }
```
```
     };
```
```
    void foo(const A& a)
```
```
    {
```
```
        int z = a[2];
```
```
    }
```
```
    int main()
```
```
    {
```
```
        A a(7);
```
```
        a[3]  = 8;
```
```
        int z = a[2];
```
```
        foo(a);
```
```
        return 0;
```
```
    }
```

a) 110
b) 111
c) 011
d) 001
Answer: d
Clarification: In this program, we overloading the operator[] by using subscript operator.
Output:

$ g++ sub3.cpp
$ a.out
001

8. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    class sample
```
```
    {
```
```
        private:
```
```
        int* i;
```
```
        int j;
```
```
        public:
```
```
        sample (int j);
```
```
        ~sample ();
```
```
        int& operator [] (int n);
```
```
    };
```
```
    int& sample::operator [] (int n)
```
```
    {
```
```
        return i[n];
```
```
    }
```
```
    sample::sample (int j)
```
```
    {
```
```
        i = new int [j];
```
```
        j = j;
```
```
    }
```
```
    sample::~sample ()
```
```
    {
```
```
        delete [] i;
```
```
    }
```
```
    int main ()
```
```
    {
```
```
        sample m (5);
```
```
        m [0] = 25;
```
```
        m [1] = 20;
```
```
        m [2] = 15;
```
```
        m [3] = 10;
```
```
        m [4] = 5;
```
```
        for (int n = 0; n < 5; ++ n)
```
```
        cout << m [n];
```
```
        return 0;
```
```
    }
```

a) 252015105
b) 510152025
c) 51015
d) 51015210
Answer: a
Clarification: In this program, we are printing the array in the reverse order by using subscript operator.
Output:

$ g++ sub4.cpp
$ a.out
252015105

9. What do we need to do to pointer for overloading the subscript operator?
a) reference pointer
b) dereference pointer
c) store it in heap
d) memory locator
Answer: b
Clarification: If you have a pointer to an object of some class type that overloads the subscript operator, you have to dereference that pointer in order to free the memory.

10. What do we need to use when we have multiple subscripts?
a) operator()
b) operator[]
c) operator
d) operator<>
Answer: a
Clarification: The reason is that operator[] always takes exactly one parameter, but operator() can take any number of parameters.

250+ TOP MCQs on Function Templates – 1 and Answers

C++ programming interview questions on “Function Templates” along with answers, explanations and/or solutions:

1. What is a function template?
a) creating a function without having to specify the exact type
b) creating a function with having an exact type
c) creating a function without having blank spaces
d) creating a function without class

Answer: a
Clarification: Function template is used to create a function without having to specify the exact type.

2. Which is used to describe the function using placeholder types?
a) template parameters
b) template type parameters
c) template type
d) type parameters

Answer: b
Clarification: During runtime, We can choose the appropriate type for the function and it is called as template type parameters.

3. Pick out the correct statement.
a) you only need to write one function, and it will work with many different types
b) it will take a long time to execute
c) duplicate code is increased
d) it will take a long time to execute & duplicate code is increased

Answer: a
Clarification: Because of template type parameters, It will work with many types and saves a lot of time.

4. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    template<typename type>
```
```
    type Max(type Var1, type Var2)
```
```
    {
```
```
        return Var1 > Var2 ? Var1:Var2;
```
```
    }
```
```
    int main()
```
```
    {
```
```
        int p;
```
```
        p = Max(100, 200);
```
```
        cout << p << endl;
```
```
        return 0;
```
```
    }
```

a) 100
b) 200
c) 300
d) 100200

Answer: b
Clarification: In this program, We are returning the maximum value by using function template.
Output:

$ g++ ftemp.cpp
$ a.out
200

5. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    template<typename type>
```
```
    class Test
```
```
    {
```
```
        public:
```
```
        Test()
```
```
        {
```
```
        };
```
```
        ~Test()
```
```
        {
```
```
        };
```
```
        type Funct1(type Var1)
```
```
        {
```
```
            return Var1;
```
```
        }
```
```
        type Funct2(type Var2)
```
```
        {
```
```
            return Var2;
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        Test<int> Var1;
```
```
        Test<float> Var2;
```

        cout << Var1.Funct1(200) << endl;

        cout << Var2.Funct2(3.123) << endl;

```
        return 0;
```
```
    }
```

   200
   3.123

   3.123
   200

c) 200
d) 3.123

Answer: a
Clarification: In this program, We are passing the values and getting it back from template. And we are using the constructor and destructor for the function template.
Output:

$ g++ ftemp1.cpp
$ a.out
200
3.123

6. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    template<typename type>
```
```
    class TestVirt
```
```
    {
```
```
        public:
```

        virtual type TestFunct(type Var1)

```
        {
```
```
            return Var1 * 2;
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        TestVirt<int> Var1;
```

        cout << Var1.TestFunct(100) << endl;

```
        return 0;
```
```
    }
```

a) 100
b) 200
c) 50
d) 150

Answer: b
Clarification: In this program, We are using class to pass the value and then we are manipulating it.
Output:

$ g++ ftemp3.cpp
$ a.out
200

7. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    template<typename T>
```
```
    inline T square(T x)
```
```
    {
```
```
        T result;
```
```
        result = x * x;
```
```
        return result;
```
```
    };
```
```
    int main()
```
```
    {
```
```
        int i, ii;
```
```
        float x, xx;
```
```
        double y, yy;
```
```
        i = 2;
```
```
        x = 2.2;
```
```
        y = 2.2;
```
```
        ii = square(i);
```

        cout << i << " "  << ii << endl;

```
        yy = square(y);
```
```
        cout << y << " " << yy << endl;
```
```
    }
```

   2 4
   2.2 4.84

b) 2 4
c) error
d) 3 6

Answer: a
Clarification: In this program, We are passing the values and calculating the square of the value by using the function template.
Output:

$ g++ ftemp4.cpp
$ a.out
2 4
2.2 4.84

8. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    template<typename T>
```
```
    void loopIt(T x)
```
```
    {
```
```
        int count = 3;
```
```
        T val[count];
```

        for (int ii=0; ii < count; ii++)

```
        {
```
```
            val[ii] = x++;
```
```
            cout <<  val[ii] << endl;
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        float xx = 2.1;
```
```
        loopIt(xx);
```
```
    }
```

a) 2.1
b) 3.1
c)

   2.1
   3.1
   4.1

d) 3.2

Answer: d
Clarification: In this program, We are using the for loop to increment the value by 1 in the function template.
Output:

$ g++ ftemp5.cpp
$ a.out
2.1
3.1
4.1

9. What can be passed by non-type template parameters during compile time?
a) int
b) float
c) constant expression
d) string

Answer: c
Clarification: Non-type template parameters provide the ability to pass a constant expression at compile time. The constant expression may also be an address of a function, object or static class member.

10. From where does the template class derived?
a) regular non-templated C++ class
b) templated class
c) regular non-templated C++ class or templated class
d) main function

Answer: c
Clarification: Class derived template is derived from regular non-templated C++ class or templated class.

250+ TOP MCQs on Exception Handling – 1 and Answers

C++ Programming Multiple Choice Questions & Answers (MCQs) on “Exception Handling – 1”.

1. What is an exception in C++ program?
a) A problem that arises during the execution of a program
b) A problem that arises during compilation
c) Also known as the syntax error
d) Also known as semantic error
Answer: a
Clarification: An exception is defined as the problem in C++ program that arises during the execution of the program for example divide by zero error.

2. By default, what a program does when it detects an exception?
a) Continue running
b) Results in the termination of the program
c) Calls other functions of the program
d) Removes the exception and tells the programmer about an exception
Answer: b
Clarification: By default, whenever a program detects an exception the program crashes as it does not know how to handle it hence results in the termination of the program.

3. Why do we need to handle exceptions?
a) To avoid unexpected behaviour of a program during run-time
b) To let compiler remove all exceptions by itself
c) To successfully compile the program
d) To get correct output
Answer: a
Clarification: We need to handle exceptions in a program to avoid any unexpected behaviour during run-time because that behaviour may affect other parts of the program. Also, an exception is detected during run-time, therefore, a program may compile successfully even with some exceptions cases in your program.

4. How Exception handling is implemented in the C++ program?
a) Using Exception keyword
b) Using try-catch block
c) Using Exception block
d) Using Error handling schedules
Answer: b
Clarification: C++ provides a try-catch block to handle exceptions in your program.

5. What is the correct syntax of the try-catch block?
a)

try
{
	// programable codes.....
}
catch(Exceptions)
{
	// Code for handling exceptions....
}

try()
{
	// programable codes.....
}
catch(Exceptions)
{
	// Code for handling exceptions....
}

try
{
	// programable codes.....
}
catch
{
	// Code for handling exceptions....
}

try()
{
	// programable codes.....
}
catch
{
	// Code for handling exceptions....
}

View Answer

Answer: a
Clarification: Try-catch block has the following syntax:

try{
	// codes that needs to check for exceptions
}
catch(Exception E1){
      // codes for handling exception.... 
      // Exception E denotes the type of exception this block is handling.
}
catch(Exception E2){
	// other exception that needs to be handled...
}

You can have any number of catch blocks catching different exceptions…..

6. Which part of the try-catch block is always fully executed?
a) try part
b) catch part
c) finally part
d) throw part
Answer: c
Clarification: finally part of the try-catch block is always executed whether exceptions are caught or not.

7. Which of the following is an exception in C++?
a) Divide by zero
b) Semicolon not written
c) Variable not declared
d) An expression is wrongly written
Answer: a
Clarification: Exceptions are those which are encountered during run-time of the program. semicolon, variable not declared and the wrong expression are compile-time errors, therefore, they are not exceptions. Divide by zero is the problem that is encountered during run-time, therefore, it is an exception.

8. What is an error in C++?
a) Violation of syntactic and semantic rules of a languages
b) Missing of Semicolon
c) Missing of double quotes
d) Violation of program interface
Answer: a
Clarification: An error occurs when rules and laws of a language is violated while writing programs in that language.

9. What is the difference between error and exception?
a) Both are the same
b) Errors can be handled at the run-time but the exceptions cannot
c) Exceptions can be handled at the run-time but the errors cannot
d) Both can be handled during run-time
Answer: c
Clarification: Exceptions can be handled during run-time whereas errors cannot be because exceptions occur due to some unexpected conditions during run-time whereas about errors compiler is sure and tells about them during compile-time.

10. What are the different types of exceptions?
a) 1
b) 2
c) 3
d) 4
Answer: b
Clarification: There are two types of exceptions: Synchronous and asynchronous exceptions. Synchronous exceptions that are caused by the event which can be controlled by the program whereas Asynchronous exceptions are those which are beyond the control of the program.

11. Which keyword is used to throw an exception?
a) try
b) throw
c) throws
d) except
Answer: b
Clarification: ‘throw’ keyword is used to throw exceptions if something bad happens.

12. What will be the output of the following C++ code?

#include 
#include 
#include 
using namespace std;
 
void func(int a, int b)
{
 
	if(b == 0){
		throw "This value of b will make the product zero. " 
                      "So please provide positive values.n";
	}
	else{
		cout<<"Product of "<<a<<" and  "<<b<<" is: "<<a*b<<endl;
	}
}
 
int main()
{
	try{
		func(5,0);
	}
	catch(const char* e){
		cout<<e;
	}
}

a) 0
b) 5
c) This value of b will make the product zero. So please provide positive values.
d) Product of 5 and 0 is: 0
Answer: c
Clarification: As the value of b = 0 is provided to the func() and the function is throwing an exception whenever the value of b = 0. Therefore the function throws the exception which will be printed on the screen.
Output:

$ ./a.out 
This value of b will make the product zero. So please provide positive values.

13. What will be the output of the following C++ code?

#include 
#include 
#include 
using namespace std;
void func(int a, int b)
{
	if(b == 0){
		throw "This value of b will make the product zero. " 
                       "So please provide positive values.n";
	}
	else{
		cout<<"Product of "<<a<<" and  "<<b<<" is: "<<a*b<<endl;
	}
}
 
int main()
{
	try{
		func(5,0);
	}
	catch(char* e){
		cout<<e;
	}
}

a) 0
b) Aborted (core dumped)
c) This value of b will make the product zero. So please provide positive values.
d) Product of 5 and 0 is: 0
Answer: b
Clarification: As the func() is throwing a const char* string but we the catch block is not catching any const char* exception i.e. exception thrown is not handled therefore the program results into Aborted(core dumped).
Output:

$ ./a.out 
terminate called after throwing an instance of 'char const*'
Aborted (core dumped)

14. What is Re-throwing an exception means in C++?
a) An exception that is thrown again as it is not handled by that catching block
b) An exception that is caught twice
c) An exception that is not handled in one caught hence thrown again
d) All of the mentioned
Answer: d
Clarification: Exception that is caught by a catch block but not handled by that catch block can be re-thrown by that catch block to further try-catch block.

15. What will be the output of the following C++ code?

#include 
#include 
#include 
using namespace std;
void func(int a, int b)
{
	if(b < 1){
		throw b;
	}
	else{
		cout<<"Product of "<<a<<" and  "<<b<<" is: "<<a*b<<endl;
	}
}
 
int main()
{
	try
        {
		try
                {			
		    func(5,-1);
		}
		catch(int b)
                {
			if(b==0)
				throw "value of b is zeron";
			else
				throw "value of b is less than zeron";
		}
	}
	catch(const char* e)
        {
		cout<<e;
	}
 
}

a) value of b is zero
b) value of b is less than zero
c) Product of 5 and -1 is: -5
d) Aborted(core dumped)
Answer: b
Clarification: Here the func() throws the value of b which is caught by the inner try-catch block, which again throws the message inorder to handle different cases of b which is caught by the outer try-catch block. Now as the value of b is negative the program outputs the message as shown.
Output:

$ ./a.out 
value of b is less than zero

250+ TOP MCQs on Sequences and Answers

This section on online C++ test on “Sequences”. One shall practice these test questions to improve their C++ programming skills needed for various interviews (campus interviews, walkin interviews, company interviews), placements, entrance exams and other competitive exams. These questions can be attempted by anyone focusing on learning C++ programming language. They can be a beginner, fresher, engineering graduate or an experienced IT professional. Our online C++ test questions come with detailed explanation of the answers which helps in better understanding of C++ concepts.

Here is a listing of online C++ test questions on “Sequences” along with answers, explanations and/or solutions:

1. How many items are there in sequence container?
a) 2
b) 3
c) 4
d) 5
Answer: d
Clarification: There are five items in sequence container. They are array, vector, list, forward_list and dequeue.

2. Which of the following class template are based on arrays?
a) vector
b) list
c) dequeue
d) both vector & dequeue
Answer: d
Clarification: Class template vector and class template dequeue both are based on arrays.

3. Which of the following will return the new element at the end of container?
a) front
b) back
c) push_back
d) pop_back
Answer: b
Clarification: Q3: back() in containers are used to access the last element of the sequence.

4. What will be the output of the following C++ code?

```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main ()
```
```
    {
```
```
        deque<int> mydeque (5);  
```

        deque<int>::reverse_iterator rit = mydeque.rbegin();

```
        int i = 0;
```

        for (rit = mydeque.rbegin(); rit!= mydeque.rend(); ++rit)

```
            *rit = ++i;
```

        for (deque<int> :: iterator it = mydeque.begin();

```
        it != mydeque.end(); ++it)
```
```
        cout << ' ' << *it;
```
```
        return 0;
```
```
    }
```

a) 12345
b) 1234
c) 54321
d) 43210
Answer: c
Clarification: In this program, We used the operation of rbegin and rend on dequeue and produced the result.
Output:

$ g++ seq.cpp
$ a.out
5 4 3 2 1

5. What will be the output of the following C++ code?

```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main ()
```
```
    {
```
```
        unsigned int i;
```
```
        deque<int> a (3,100);
```
```
        deque<int> b (5,200);
```
```
        a.swap(b);
```
```
        cout << "a contains:";
```

        for (deque<int>::iterator it = a.begin(); it != a.end(); ++it)

```
            cout << ' ' << *it;
```
```
        cout << "b contains:";
```

        for (deque<int>::iterator it = b.begin(); it != b.end(); ++it)

```
            cout << ' ' << *it;
```
```
        return 0;
```
```
    }
```

a) a contains: 200 200 200 200 200b contains: 100 100 100
b) a contains: 100 100 100 100 100b contains: 200 200 200
c) a contains: 200 200 200 200 200b contains: 200 200 200
d) a contains: 200 200 200 200 200b contains: 100 200 150
Answer: a
Clarification: In this program, We swapped the values of both dequeues and printing the dequeues.
Output:

$ g++ seq1.cpp
$ a.out
a contains: 200 200 200 200 200b contains: 100 100 100

6. What will be the output of the following C++ code?

```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main ()
```
```
    {
```
```
        unsigned int i;
```
```
        deque<int> mydeque;
```
```
        mydeque.push_back (100);
```
```
        mydeque.push_back (200);
```
```
        mydeque.push_back (300);
```

        for(deque<int> :: iterator it = mydeque.begin(); it != mydeque.end(); ++it)

```
        {
```
```
        }
```
```
        mydeque.clear();
```
```
        mydeque.push_back (110);
```
```
        mydeque.push_back (220);
```

        for(deque<int> :: iterator it = mydeque.begin(); it != mydeque.end(); ++it)

```
            cout << ' ' << *it;
```
```
        cout << 'n';
```
```
        return 0;
```
```
    }
```

a) 110
b) 220
c) Both 110 & 220
d) 330
Answer: c
Clarification: In this program, We cleared the old values presented in the dequeue with the new values.
Output:

$ g++ seq2.cpp
$ a.out
110 220

7. What will be the output of the following C++ code?

```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main ()
```
```
    {
```
```
        vector<int> myvector;
```
```
        int * p;
```
```
        unsigned int i;
```

        p = myvector.get_allocator().allocate(5);

```
        for (i = 0; i < 5; i++) 
```

            myvector.get_allocator().construct(&p[i], i);

```
        for (i = 0; i < 5; i++)
```
```
            cout << ' ' << p[i];
```
```
        for (i = 0; i < 5; i++)
```

            myvector.get_allocator().destroy(&p[i]);

        myvector.get_allocator().deallocate(p, 5);

```
        return 0;
```
```
    }
```

a) 1 2 3 4 5
b) 0 1 2 3 4
c) 1 2 3 4
d) 5 4 3 2 1
Answer: b
Clarification: In this program, We allocated the values to the vector by using get allocater and then we are destroying it.
Output:

$ g++ seq3.cpp
$ a.out
0 1 2 3 4

8. What will be the output of the following C++ code?

```
    #include 
```
```
    #include 
```
```
    #include 
```
```
    using namespace std;
```

    bool same_integral_part (double first, double second)

```
    {  
```

        return ( int(first) == int(second) );

```
    }
```
```
    struct is_near 
```
```
    {
```

        bool operator() (double first, double second)

```
        { 
```

            return (fabs(first - second) < 5.0);

```
        }
```
```
    };
```
```
    int main ()
```
```
    {
```

        double mydoubles[] = { 12.15,  2.72, 73.0,  12.77,  3.14, 12.77, 73.35, 72.25, 15.3,  72.25 };

        list<double> mylist (mydoubles, mydoubles + 10);

```
        mylist.sort();
```
```
        mylist.unique();
```

        mylist.unique (same_integral_part);

```
        mylist.unique (is_near());
```

        for (list<double> :: iterator it = mylist.begin(); it != mylist.end(); ++it)

```
            cout << ' ' << *it;
```
```
        cout << 'n';
```
```
        return 0;
```
```
    }
```

a) 2.72 12.15 72.25
b) 12.15 73.0 12.77
c) 73.35
d) 74.45
Answer: a
Clarification: In this program, We are eliminating the values by using the unique operation in the list.
Output:

$ g++ seq4.cpp
$ a.out
2.72 12.15 72.25

9. How the list containers are implemented?
a) Using Double linked list
b) Using Single linked list
c) Using Single & Double linked list
d) Using linear linked list
Answer: a
Clarification: List containers are implemented as doubly-linked lists. Doubly linked lists can store each of the elements they contain in different and unrelated storage locations.

10. Which of the following does not support any insertion or deletion?
a) Array
b) Vector
c) Dequeue
d) List
Answer: a
Clarification: Because array is not dynamic in nature, So they can’t be manipulated.

250+ TOP MCQs on Array Type Manipulation and Answers

C++ Programming Multiple Choice Questions & Answers (MCQs) on “Array Type Manipulation”.

1. Which of the header file is used for array type manipulation?
a)
b)
c)
d) std namespace
Answer: d
Clarification: Array type manipulation functions are declared incside the namespace std so you can use namespace std to use these functions.

2. What is the use of is_array() function in C++?
a) To check if a variable is array type or not
b) To check if a variable is 1-D array type or not
c) To check if a variable is 2-D array type or not
d) To check if a variable is 1-D or 2-D array type or not
Answer: a
Clarification: is_array() function is used to check whether a given variable is of array type or not.

3. What will be the output of the following C++ code?

#include 
#include 
using namespace std;
int main()
{
	cout<<is_array<int>::value;
	cout<<is_array<char[10]>::value;
	cout<<is_array<string>::value;
	return 0;
}

a) 010
b) 101
c) 001
d) 110
Answer: a
Clarification: As int and string are not of array type therefore 0 is printed corresponding to them and char[10] is an array of character of size 10 therefore 1 is printed corresponding to this. Hence answer is 010.

4. What is the use of is_same() function in C++?
a) To check if a variable is array type or not
b) To check whether two variables have the same characteristics
c) To check if two variable is of array type or not
d) To check whether two variables are different or not
Answer: b
Clarification: is_same() function is used to check whether two variables have the same characteristics or not.

5. What will be the output of the following C++ code?

#include 
#include 
using namespace std;
int main()
{
	cout<<is_same<int,char>::value;
	cout<<is_same<char[10], char[10]>::value;
	cout<<is_same<char*[10], string>::value;
	return 0;
}

a) 011
b) 101
c) 010
d) 110
Answer: c
Clarification: In 1st and 3rd case both the variables passed to is_same() function are different whereas for 2nd they are same. Hence the answer is 010.

6. What is the use of rank() function in C++?
a) Returns size of each dimension
b) Returns how many total elements can be stored in an array
c) Returns how many elements are in array currently
d) Returns the dimension of an array
Answer: d
Clarification: rank() function returns the rank of the array i.e. the dimension of an array. For example, int arr[10][10] has rank 2.

7. What will be the output of the following C++ code?

#include 
#include 
using namespace std;
int main()
{
	cout<<rank<int[10]>::value;
	cout<<rank<char[10][10]>::value;
	cout<<rank<string[10][10][10]>::value;
	return 0;
}

a) 111
b) 123
c) 321
d) 121
Answer: b
Clarification: In this program first array has the single dimension, second one has two dimensions and third one has three dimension therefore the program prints 123.

8. Which of the following is correct about extent() function?
a) Returns how many elements are in array currently
b) Returns the size of the 1st dimension
c) Returns how many total elements can be stored in an array
d) Returns the size of a given dimension
Answer: d
Clarification: The extent() function takes two parameters one denoting the array other showing the dimension for which the size we want to know.

9. What will be the output of the following C++ code?

#include 
#include 
using namespace std;
int main()
{
	cout<<extent<string[10][20][30], 0>::value;
	cout<<extent<string[10][20][30], 1>::value;
	cout<<extent<string[10][20][30], 2>::value;
	return 0;
}

a) 101010
b) 102030
c) 302010
d) 102010
Answer: b
Clarification: In first cout we are passing 0 and size of first dimension of array is 10 therefore 10 is printed. In following cases we have passed 1 and 2 therefore 20 and 30 are printed respectively.

10. Which of the following is correct about remove_extent() function?
a) Removes the given dimension from an array
b) Removes the first dimension from the right of the array
c) Removes the first dimension from the left of the array
d) Removes the last dimension from the left of the array
Answer: c
Clarification: remove_extent() function removes the first dimension i.e. the first dimension from the given array.

11. What will be the output of the following C++ code?

#include 
#include 
using namespace std;
int main()
{
	cout<<rank<remove_extent<string[10][20]>::type>::value;
	cout<<rank<remove_extent<string[10][20][30]>::type>::value;
	return 0;
}

a) 11
b) 12
c) 21
d) 22
Answer: b
Clarification: As we are removing the dimensions from these array and then printing the rank of arrays. Therefore as initially they have 2 and 3 as their rank so after deleting the rank becomes 1 and 2 hence the output is 12.

12. Which of the following is correct about remove_all_extents() function?
a) Removes the all dimension from an array
b) Removes the first dimension from the left of the array
c) Removes the first dimension from the right of the array
d) Removes the last dimension from the left of the array
Answer: a
Clarification: As the name suggests remove_all_extent() function removes all the dimensions from the array. So rank os array after this operation becomes 0.

13. What will be the output of the following C++ code?

#include 
#include 
using namespace std;
int main()
{
	cout<<rank<remove_all_extents<string[10][20]>::type>::value;
	return 0;
}

a) 1
b) 0
c) Error
d) Segmentation fault
Answer: b
Clarification: As we ahve deleted all the dimensions of this array therefore the rank of the array becomes zero hence the output is 0.

14. What will be the output of the following C++ code?

#include 
#include 
using namespace std;
int main()
{
	cout<<extent<remove_extent<string[10][20]>::type>::value;
	cout<<extent<remove_extent<string[10][20][30]>::type>::value;
	return 0;
}

a) 1010
b) 1020
c) 2020
d) 2030
Answer: c
Clarification: As we are deleting the first dimension from both the arrays and then printing the extent i.e. size of dimension therefore the answer is 2020 as both the array have 20 as the size of their second dimension.

15. What will be the output of the following C++ code?

#include 
#include 
using namespace std;
int main()
{
	cout<<extent<remove_all_extents<string[10][20][30]>::type>::value;
	return 0;
}

a) 20
b) 10
c) Error
d) 0
Answer: d
Clarification: As we have removed all the dimensions from the array therefore the output of extent is 0.

Category: C++ Programming Objective Questions

250+ TOP MCQs on Exceptions and Answers

250+ TOP MCQs on Subscripting and Answers

250+ TOP MCQs on Function Templates – 1 and Answers

250+ TOP MCQs on Exception Handling – 1 and Answers

250+ TOP MCQs on Sequences and Answers

250+ TOP MCQs on Array Type Manipulation and Answers