C++ Standard Library Containers

Question 1

Why do we want containers?

Answer 1

To avoid consuming time and effort when writing memory efficient and performant data structures.

Question 2

What is OOP about?

Answer 2

Producing reusable code, that encapsulates data implementation and abstraction of inner workings ( as well as inheritance and polymorphism)

Question 3

What are built-in containers an example of?

Answer 3

Template metaprogramming

Question 4

What do containers provide?

Answer 4

Well-tested code with guaranteed time and memory complexities.

Question 5

What are some advantages of using containers?

Answer 5

• Provides a common and consistent interface for accessing data in different container types
• Allows for easy swapping between containers without having to change too much code
  -Makes code more readable
• Generalises passing data to standard algorithms.
• Once behaviour is encoded once it can be easily reused.

Question 6

What are derived containers?

Answer 6

Containers that are built upon existing container classes, inheriting their functionality and extending it to provide additional features of customization.

Question 7

What is template metaprogramming?

Answer 7

A technique that leverages compile-time computation using templates to perform complex tasks and computations, allowing for efficient and flexible code generation.

Question 8

What are the advantages of derived containers?

Answer 8

• Code reusability
• Customisation
• Abstraction
• Efficiency
• Consistency

Question 9

What order do associative containers store items in?

Answer 9

Order or unordered variants.

Question 10

How do we order containers for our own types/classes?

Answer 10

Using operator overload.

Question 11

When should we use the std::array container?

Answer 11

Fixed size array small enough to go on the stack.

Question 12

When should we use std::vector container?

Answer 12

• When dealing with small data elements with mostly push/pop_back modification
• Large elements where the number of elements is constant.

Question 13

When should we use std::deque?

Answer 13

Front and back modifications are needed. Less memory efficient but fast front modifications.

Question 14

When should we use std::list or std::foward_list?

Answer 14

When adding, removing or randomly inserting elements. (Forward list if only integrating forward). But not specific search for one element, as list works as a linked list.

Question 15

When should we use std::set?

Answer 15

For ordering unique elements and fast look/insertion.

Question 16

When should we use std::map?

Answer 16

• Mapping non-sequential integers or hashable type to some other value.

Question 17

When should we use std::onordered_set and std::onordered_map?

Answer 17

When fast access/insertion is required and order of traversal is not important

Question 18

What does std::set do?

Answer 18

Only allows unique elements. It internally orders the elements so they are iterated in a sorted order.

Question 19

What are std::lists?

Answer 19

Double-linked list, each elements points to the previous and next item in the list. Meaning we don’t have to store things contiguously in memory. Can be iterated backwards of forwards

Question 20

What is an example of a derived container?

Answer 20

Stack
std::stack<T, Container = std::Dequeue<T>></T>

Question 21

What are the time complexities of derived containers?

Answer 21

The time complexity of the underlying structure.

Question 22

What are associate containers?

Answer 22

Containers that map keys of “some” type to another type. Examples are sets and maps.

Question 23

What must associate keys be?

Answer 23

Hashable

Question 24

What is the time complexity of accessing a set?

Answer 24

O(log n)

Question 25

How do we find elements in a set?

Answer 25

Using the find operator
auto it = set.find(4)
If it isn’t null value or != set.end has been found

Question 26

What are maps?

Answer 26

Maps store the value along with a key to uniquely identify the value.