250+ TOP MCQs on Associative Containers and Answers

By engineer / May 26, 2024

This section on C++ aptitude questions and answers on “Associative Containers”. One shall practice these aptitude questions to improve their C++ programming skills needed for various interviews (campus interviews, walkin interviews, company interviews), placements, entrance exams, aptitude tests 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++ questions come with detailed explanation of the answers which helps in better understanding of C++ concepts.

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

1. What do associate containers implement?
a) Arrays
b) Associative arrays
c) Functional Arrays
d) Static arrays
Answer: b
Clarification: Associative containers refer to a group of class templates in the standard library of the C++ programming language that implements ordered associative arrays.

2. By using which of the following the elements in the associate container can be efficiently accessed?
a) Key
b) Position
c) Both Key & Position
d) Value
Answer: a
Clarification: Associative containers are designed to be especially efficient in accessing its elements by their key, as opposed to sequence containers which are more efficient in accessing elements by their position.

3. How many items are presented in the associate container?
a) 2
b) 3
c) 4
d) 5
Answer: c
Clarification: There are 4 items presented in the associate container. They are set, multiset, map and multimap.

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

```
    #include 
```
```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main ()
```
```
    {
```
```
        string mystring;
```
```
        bitset<4> mybits; 
```
```
        mybits.set();
```

        mystring = mybits.to_string<char, char_traits<char>,

```
        allocator<char> >();
```
```
        cout << mystring << endl;
```
```
        return 0;
```
```
    }
```

a) 0000
b) 0001
c) 0011
d) 1111
Answer: d
Clarification: In this program, We converted the bitset values to string and printing it.
Output:

$ g++ asc.cpp
$ a.out
1111

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

```
    #include 
```
```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main () 
```
```
    {
```
```
        vector<int> first (5, 10);
```
```
        vector<int> second (5, 33);
```
```
        vector<int>::iterator it;
```

        swap_ranges(first.begin() + 1, first.end() - 1, second.begin());

```
        cout << " first contains:";
```

        for (it = first.begin(); it != first.end(); ++it)

```
            cout << " " << *it;
```
```
        cout << "nsecond contains:";
```

        for (it = second.begin(); it != second.end(); ++it)

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

   first contains: 10 33 33 33 10
   second contains: 10 10 10 33 33

   first contains: 10 33 33 33 10
   second contains: 10 10 10 33 10

   first contains: 10 33 33 33 30
   second contains: 10 10 10 33 10

   first contains: 10 10 10 33 30
   second contains: 10 10 10 10 10

View Answer

Answer: a
Clarification: In this program, We swapped the values according to their position.
Output:

$ g++ asc1.cpp
$ a.out
first contains: 10 33 33 33 10
second contains: 10 10 10 33 33

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

```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main ()
```
```
    {
```
```
        map<char, int> mymap;
```
```
        map<char, int> :: iterator it;
```
```
        mymap['b'] = 100;
```
```
        mymap['a'] = 200;
```
```
        mymap['c'] = 300;
```

        for (map<char, int> :: iterator it = mymap.begin(); it != mymap.end(); ++it)

            cout << it -> first << " => " << it -> second << 'n';

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

   a => 200 
   c => 300

   a => 200
   b => 100

   a => 200  
   b => 100
   c => 300

d) a => 200
Answer: c
Clarification: In this program, We used the map template and then we used the begin operation and then we are printing the elements.
Output:

$ g++ asc2.cpp
$ a.out
a => 200
b => 100
c => 300

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

```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main ()
```
```
    {
```
```
        set<int> myset;
```
```
        myset.insert(20);
```
```
        myset.insert(30);
```
```
        myset.insert(10);
```
```
        while (!myset.empty())
```
```
        {
```

            cout << ' ' << *myset.begin();

```
            myset.erase(myset.begin());
```
```
        }
```
```
        cout << 'n';
```
```
        return 0;
```
```
    }
```

a) 10
b) 20
c) 30
d) 10 20 30
Answer: d
Clarification: In this program, We used the set template and then we are initializing the values and then we are erasing it.
Output:

$ g++ asc3.cpp
$ a.out
 10 20 30

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

```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main ()
```
```
    {
```
```
        multiset<int> mymultiset;
```

        for (int i = 0; i < 5; i++) mymultiset.insert(i);

        multiset<int> :: key_compare mycomp = mymultiset.key_comp();

        int highest = *mymultiset.rbegin();

        multiset<int> :: iterator it = mymultiset.begin();

```
        do 
```
```
        {
```
```
            cout << ' ' << *it;
```

        } while (mycomp(*it++, highest));

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

a) 12345
b) 01234
c) 1234
d) 0123
Answer: b
Clarification: In this program, We used the set template and then we compared the keys and printing the result.
Output:

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

250+ TOP MCQs on Associative Containers and Answers

Leave a Comment Cancel Reply

Interview Questions List

Related Posts

Leave a Comment Cancel Reply