Cpp Programming Containers Vector List Deque Set Map Unordered Map Complete Guide

1. Vector

Problem: Create a vector of integers and perform basic operations like adding elements, accessing elements, and iterating through the vector.

#include <iostream>
#include <vector>

int main() {
    // Step 1: Create an empty vector of integers
    std::vector<int> vec;
    
    // Step 2: Add elements to the vector
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);
    vec.push_back(40);

    // Step 3: Access and print elements using index
    std::cout << "Elements of vector: ";
    for (size_t i = 0; i < vec.size(); i++) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;

    // Step 4: Use iterator to traverse the vector and print elements
    std::cout << "Using iterator: ";
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); it++) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

Explanation:

• std::vector<int> vec; declares a vector that will store integers.
• vec.push_back() adds elements to the end of the vector.
• Elements can be accessed using vec[i] where i is the index.
• Iterators are used to traverse the vector, with vec.begin() and vec.end() marking the start and end of the vector, respectively.

2. List

Problem: Create a list of strings and perform basic operations like adding elements, accessing elements, and removing elements.

#include <iostream>
#include <list>
#include <string>

int main() {
    // Step 1: Create an empty list of strings
    std::list<std::string> lst;

    // Step 2: Add elements to the list
    lst.push_back("Apple");
    lst.push_back("Banana");
    lst.push_back("Cherry");

    // Step 3: Add an element to the front of the list
    lst.push_front("Watermelon");

    // Step 4: Remove an element from the list
    lst.remove("Banana");

    // Step 5: Use iterator to traverse the list and print elements
    std::cout << "Elements of list: ";
    for (std::list<std::string>::iterator it = lst.begin(); it != lst.end(); it++) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

Explanation:

• std::list<std::string> lst; declares a list that will store strings.
• lst.push_back() and lst.push_front() are used to add elements to the list.
• lst.remove() removes elements from the list.
• Iterators are used to traverse the list.

3. Deque

Problem: Create a deque of doubles and perform basic operations like adding elements, accessing elements, and removing elements.

#include <iostream>
#include <deque>

int main() {
    // Step 1: Create an empty deque of doubles
    std::deque<double> deq;

    // Step 2: Add elements to the deque
    deq.push_back(4.5);
    deq.push_front(3.5);

    // Step 3: Access and print elements using index
    std::cout << "Elements of deque: ";
    for (size_t i = 0; i < deq.size(); i++) {
        std::cout << deq[i] << " ";
    }
    std::cout << std::endl;

    // Step 4: Remove an element from the deque
    deq.pop_back();

    // Step 5: Use iterator to traverse the deque and print elements
    std::cout << "After removing an element: ";
    for (std::deque<double>::iterator it = deq.begin(); it != deq.end(); it++) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

Explanation:

• std::deque<double> deq; declares a deque that will store doubles.
• deq.push_back() and deq.push_front() add elements to the back and front of the deque, respectively.
• deq.pop_back() removes the last element of the deque.
• Iterators are used to traverse the deque.

4. Set

Problem: Create a set of integers and perform basic operations like adding elements, checking if an element exists, and iterating through the set.

#include <iostream>
#include <set>

int main() {
    // Step 1: Create an empty set of integers
    std::set<int> s;

    // Step 2: Add elements to the set
    s.insert(10);
    s.insert(20);
    s.insert(10);

    // Step 3: Check if an element exists in the set
    if (s.find(20) != s.end()) 
        std::cout << "Element 20 exists in set!" << std::endl;
    else 
        std::cout << "Element 20 does not exist!" << std::endl;

    // Step 4: Use iterator to traverse the set and print elements
    std::cout << "Elements of set: ";
    for (std::set<int>::iterator it = s.begin(); it != s.end(); it++) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

Explanation:

• std::set<int> s; declares a set that will store integers.
• s.insert() adds elements to the set. Note that sets automatically avoid duplicate entries.
• s.find() checks if an element exists in the set. It returns an iterator to the element if found, Otherwise, it returns s.end().
• Iterators are used to traverse the set.

5. Map

Problem: Create a map that associates names with ages and perform basic operations like adding elements, accessing elements, and removing elements.

#include <iostream>
#include <map>
#include <string>

int main() {
    // Step 1: Create an empty map associating names (string) with ages (int)
    std::map<std::string, int> ageMap;

    // Step 2: Add key-value pairs to the map
    ageMap["Alice"] = 25;
    ageMap["Bob"] = 30;
    ageMap["Charlie"] = 35;

    // Step 3: Access and print the age of a specific person
    std::cout << "Alice's age: " << ageMap["Alice"] << std::endl;

    // Step 4: Check if a key exists in the map
    if (ageMap.find("Bob") != ageMap.end()) 
        std::cout << "Bob is in the map!" << std::endl;
    else 
        std::cout << "Bob is not in the map!" << std::endl;

    // Step 5: Use iterator to traverse the map and print key-value pairs
    std::cout << "Elements of map: ";
    for (std::map<std::string, int>::iterator it = ageMap.begin(); it != ageMap.end(); it++) {
        std::cout << it->first << " : " << it->second << ", ";
    }
    std::cout << std::endl;

    // Step 6: Remove a key-value pair from the map
    ageMap.erase("Charlie");

    // Step 7: Print the map after removing a key-value pair
    std::cout << "After removing Charlie: ";
    for (std::map<std::string, int>::iterator it = ageMap.begin(); it != ageMap.end(); it++) {
        std::cout << it->first << " : " << it->second << ", ";
    }
    std::cout << std::endl;

    return 0;
}

Explanation:

• std::map<std::string, int> ageMap; declares a map that associates strings (names) with integers (ages).
• ageMap[key] = value; adds key-value pairs to the map.
• ageMap.find() checks if a key exists in the map. It returns an iterator to the key if found, otherwise ageMap.end().
• Iterators are used to traverse the map, with it->first and it->second accessing the key and value, respectively.

6. Unordered Map

Problem: Create an unordered_map that associates names with ages and perform basic operations like adding elements, accessing elements, and removing elements.

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    // Step 1: Create an empty unordered_map associating names (string) with ages (int)
    std::unordered_map<std::string, int> ageUnorderedMap;

    // Step 2: Add key-value pairs to the unordered_map
    ageUnorderedMap["Alice"] = 25;
    ageUnorderedMap["Bob"] = 30;
    ageUnorderedMap["Charlie"] = 35;

    // Step 3: Access and print the age of a specific person
    std::cout << "Alice's age: " << ageUnorderedMap["Alice"] << std::endl;

    // Step 4: Check if a key exists in the unordered_map
    if (ageUnorderedMap.find("Bob") != ageUnorderedMap.end()) 
        std::cout << "Bob is in the unordered_map!" << std::endl;
    else 
        std::cout << "Bob is not in the unordered_map!" << std::endl;

    // Step 5: Use iterator to traverse the unordered_map and print key-value pairs
    std::cout << "Elements of unordered_map: ";
    for (std::unordered_map<std::string, int>::iterator it = ageUnorderedMap.begin(); it != ageUnorderedMap.end(); it++) {
        std::cout << it->first << " : " << it->second << ", ";
    }
    std::cout << std::endl;

    // Step 6: Remove a key-value pair from the unordered_map
    ageUnorderedMap.erase("Charlie");

    // Step 7: Print the unordered_map after removing a key-value pair
    std::cout << "After removing Charlie: ";
    for (std::unordered_map<std::string, int>::iterator it = ageUnorderedMap.begin(); it != ageUnorderedMap.end(); it++) {
        std::cout << it->first << " : " << it->second << ", ";
    }
    std::cout << std::endl;

    return 0;
}

Explanation:

• std::unordered_map<std::string, int> ageUnorderedMap; declares an unordered_map that associates strings (names) with integers (ages).
• ageUnorderedMap[key] = value; adds key-value pairs to the unordered_map.
• ageUnorderedMap.find() checks if a key exists in the unordered_map. It returns an iterator to the key if found, otherwise ageUnorderedMap.end().
• Iterators are used to traverse the unordered_map, and you can access the key and value using it->first and it->second.