Overview of C++
There are so many programming languages today, all with their own advantages and limitations. These programming languages follow different operating principles to solve the problems associated with them. The object-oriented technique is a paradigm that looks upon a problem and solves it in terms of objects. It pays less heed to the procedure it follows.
OOP is one of the most popularly used programming languages in today's age and age by coders world-wide and is one of the many subjects you'll learn in our Caltech Coding Bootcamp.
Let’s take the example of the simulation traffic flow at a red light crossing. This problem in an OOP paradigm is that it will be viewed in terms of the objects involved, which are cars, trucks, buses, scooters, taxis, and people crossing by. These objects will have some characteristics as well. Like a four-wheeler vehicle will have a steering wheel, motor brakes, and so on. And its behavior will be its mobility. So, here, a car will be an object for a class named Vehicle.
C++ also supports Standard Template Library or STL. Standard Template Library is a collection of pre-written classes that are used as templates in your C++ codes. You can add these STL classes by adding the header files of the respective STL templates in your code. STL usually provides three types of templates:
1. Algorithms: Standard Template Library contains various algorithms for various programs such as binary search. It provides algorithms for sorting, which comes as sort() function where you just have to pass the array or vector which you want to get sorted. This saves time and hard work of yours to a great extent. Using STL algorithm templates also makes the code clean and increases the code readability. Some of the most used STL algorithm templates are:
- std::sort(): The sort() function is widely used by the programmers. The sort() function allows you to sort the given array or vector. It takes the name and size as the parameter in the array's case and the starting point and the endpoint in the case of the vector. The sort() function is a hybrid of heap sort and quicksort.
- std::swap(): The swap() function is another STL algorithm template. The swap() function lets you swap two entities. It accepts the two entities that are to be swapped as their parameters. This function saves you from hard work.
- std::reverse(): The reverse() function is used to return the elements in an order which will be the reverse of the original order. This function accepts two parameters, the iterators storing the memory addresses of the first and the last entity. The first iterator will point to the first entity from which the elements need to be reversed, and the last iterator will point to the last element up to which the values need to be reversed.
Other popular algorithm templates used are: std:: min(), std::max(), std::swap(), std::rotate(), std::reverse(), std::min_element(), std::max_element(), std:: binary_search().
2. Containers: Standard Template Library contains several container templates that are used to store the data. Some of the most popular container templates provided by STL are:
- Vector: Vector is an alternative of arrays that works on dynamic memory allocation. A vector is superior to an array in several ways. While using vector class, you do not have to worry about the size of your container, as it can be increased or decreased dynamically. Plus, it also gives you the privilege of restricting the size by using the reserve() function so that memory does not get wasted.
- Map: C++ Map is another commonly used STL container. The map is an ordered data structure that holds the data in an ordered or sorted form so that elements can easily be looked up in this dictionary-like data structure. In a map, two or more keys can not be the same or identical, which means all the keys have to be unique. You will dive deep into the map, further in this article.
- List: A list in STL is used to implement the doubly-linked lists. Unlike an array, lists are used to store the data, which is not contiguous. The operations such as insertion and deletion of elements are faster in lists. However, traversing a list is not an optimized operation.
Other popular container templates used are list, hash_set, multiset, hash_map, deque, hash_multimap.
3. Iterators: C++ STL provides iterators that are used to make traversing the STL containers efficient. These iterators return the memory address of the elements stored in the container. There are many pre-defined operations in STL that can be performed through the iterators. This also optimizes the program’s time complexity. These iterators do not depend on the type of container they are being used for. Therefore, they provide common operations for algorithms. Some of the iterators are:
- Forward iterators: Forward iterators are one of the most common iterators provided by STL. Forward iterators are built by merging input iterators and output iteratWhileors. You can use these iterators for the comparison between two entities with another iterator. If both the iterators point to the same element then they are said to be equal otherwise, they are not equal.
- Bidirectional iterators: Bidirectional iterators are the type of iterators that can be used to iterate in both directions. Bidirectional iterators and Forward iterators are alike in many ways, except that Bidirectional iterators can iterate in both directions. While forward iterators can iterate in only one direction.
Other iterators, STL provides to us are input iterators, output iterators, random-access iterators.
What Is C++ Map?
The map is an ordered data structure that holds the data in an ordered or sorted form so that elements can easily be looked up in this dictionary-like data structure. A map holds two parameters, a key, and its associative value, and these key-value combinations are sorted, but the sorting is dependent on the comparison function operating internally. In C++, you can traverse a map bidirectionally, which means C++ STL provides you iterators that can traverse a map from both ends, and this makes the map a very flexible data structure.
In a map, two or more keys can not be the same or identical, which means all the keys have to be unique. Also, you cannot modify a key in a map, only insertion or deletion of a key is possible. However, this is not the case with the associative values of the keys. These values can be modified or altered as per your choice. Also, the mapped values of two or more keys can be the same. Since the combinations of keys and their associated values are sorted, this makes searching for an element in a map very efficient.
Have a look at an example to understand what a map looks like and how it works.
Consider a batch of students studying different subjects. You can store this information using a map where the name of the subject will be the key and the number of students who are studying that subject will be the value.
|
Key |
Value |
|
Mathematics |
10 |
|
Computer_Science |
20 |
|
English |
15 |
|
Physics |
20 |
In this example, notice that all keys are different and unique, but in the value column, the value 20 is the same for the key Computer_Science and Physics.
Now, understand the syntax and parameters of the map in C++.
Syntax
You can declare a map in C++ STL using the following syntax:
map <datatype_of_key, datatype_of_value> name_of_map;
// example
map <char, int> mp;
/*****************************/
/* char -> datatype of keys */
/* int -> datatype of values */
/* mp -> name of the map */
/*****************************/
Parameters
- datatype_of_key: This parameter takes up the data type of the keys to be entered.
- datatype_of_value: This parameter takes up the data type of the values that will be associated with the keys.
Additional Parameters:
- compare: This is the default comparator in the template class map. You can also write your own comparator to sort the pairs on the map.
- alloc: This is the fourth and optional parameter of the map container. It is the allocator object type that handles the storage requirements of the map.
Uses of Maps
There are two main purposes that the map serves for the developers. Since the keys are stored in a sorted manner in a map, it allows the searching for any value in a linear time. So, when you want to develop an application that needs to have some sort of reference or index. You can also sort the keys using your user-defined comparator, which makes this data structure customizable. Another major purpose that the map serves is that it avoids data redundancy, as the keys stored are all unique. So, this technique avoids the cases of data duplication. These reasons make the map very useful for the developers. It can have the following applications:
- Hash Table: You can implement a map as a hash table, although there will be an additional requirement of a hash function. But the map implementation of a hash table serves the searching in almost constant time.
- Binary Search Tree: A binary search can also be implemented using a map, where all the key-value combinations will be in an ordered manner. The complexity will be O(log N) in this case for searching a value in the tree.
- Data compression using a dictionary: For achieving data compression in a dictionary, the long terms can have associated short-length codes, and this can be easily achieved by the map data structure.
- Memoized function: This technique can be very useful for the optimization of functions that can be otherwise very expensive like the recursive functions.
How to Create a Map?
A map in C++ can be constructed in many ways. This article will discuss the most common methods that are in practice.
1. Construct an empty map, and then using the insert() method, insert the keys and values to the map.
SYNTAX
// syntax to declare an empty map
map<key_datatype, value_datatype> map_name;
// syntax to insert keys and values using insert()
map_name.insert({key, value});
The following example illustrates how to create a map using this method:
Consider a batch of students studying different subjects. This program will store this information using a map, where the name of the subject will be the key and the number of students who are studying that subject will be the value.
#include<bits/stdc++.h>
using namespace std;
int main()
{
// create an empty map
map<string, int> subjects;
subjects.insert({"Mathematics", 10});
subjects.insert({"Computer_Science", 20});
subjects.insert({"English", 15});
subjects.insert({"Physics", 20});
// iterate over the map and print the key-values
for (auto i = subjects.begin(); i != subjects.end(); ++i) {
cout << i->first
<< ' ' << i->second << '\n';
}
cout << "\n\n";
}
2. The second method to create a map in C++ is by initializing the map with the key-value pairs. This method is a cleaner approach if you have a small list of elements.
SYNTAX
// syntax to initialize the map
// with key value combinations
map<key_datatype, value_datatype> map_name { { key_1, value_1 }, { key_2, value_2 } };
The following example illustrates how to create a map using this method:
#include<bits/stdc++.h>
using namespace std;
int main() {
// create a map named subjects
// initialize its values
map<string, int> subjects { { "Mathematics", 10}, { "Computer_Science", 20 } };
// iterate over the map and print the key-values
for (auto i = subjects.begin(); i != subjects.end(); ++i) {
cout << i->first
<< ' ' << i->second << '\n';
}
}
What Are Member Functions in C++ Maps?
C++ Map is a pre-defined class of Standard Template Library or STL that you can use as a template. Data members with visibility mode as private can not be accessed directly by the user. So, to access them, you need to define member functions. Member functions are those functions that are defined to perform some specific task using the data members of the same class. These member functions are predefined, and you do not have to define them again in your code. C++ Map also contains various member functions that will be discussed in this section.
-
begin()
Syntax
// use begin() in a map in C++ STL
// using the following syntax
map_name.begin()
Parameters
None
There is no requirement of passing parameters.
begin() is a member function of C++ Map in STL. begin() function returns a pointer pointing to the first element of the container. This pointer can point in either direction of the container and hence it is bidirectional.
-
end()
end() function returns a pointer pointing to the element that comes after the last element of the container. This element is not real, it is a virtual element that contains the address of the last element.
Syntax
// use end() in a map in C++ STL
// using the following syntax
map_name.end()
Parameters
None
There is no requirement of passing parameters.
-
size()
size() function is a critical member function of C++ Map. size() returns the total number of elements of the map container.
Syntax
// use size() in a map in C++ STL
// using the following syntax
map_name.size()
Parameters
None
There is no requirement of passing parameters.
-
max_size()
max_size() is a pre-defined member function of c++ Map. max_size() function returns the maximum number of elements that can be stored by the container.
Syntax
// use map_size() in a map in C++ STL
// using the following syntax
map_name.max_size()
Parameters
None
There is no requirement of passing parameters.
-
empty()
empty() function is a member function of C++ Map with boolean datatype. It checks if the container is empty or not. If the container is empty, it returns True, otherwise, it gives False.
Syntax
// use map_name() in a map in C++ STL
// using the following syntax
map_name.empty()
Parameters
None
There is no requirement of passing parameters.
-
erase()
erase() function is a pre-defined member function of C++ Map. This function is used to remove an element from the given STL container.
Syntax
// use erase() in a map in C++ STL
// using the following syntax
map_name.erase(key)
Parameters
None
There is no requirement of passing parameters.
-
insert()
insert() function is used to add elements in the Map container. This function passes a pair as its argument. This pair consists of a key and an element corresponding to that key.
Syntax
// use erase() in a map in C++ STL
// using the following syntax
map_name.erase(key)
Parameters
key
erase() takes a "key" parameter, that needs to be erased.
-
clear():
clear() function is a pre-defined member function of C++ Map. If you want to clear the entire STL container then you can use this function.
Syntax
// use clear() in a map in C++ STL
// using the following syntax
map_name.clear()
Parameters
None
There is no requirement of passing parameters.
The following example implements these member functions of a map in C++ :
#include <bits/stdc++.h>
using namespace std;
int main()
{
// create an empty map
map<char, int> ascii;
/************* 1. insert() *****************/
// insert alphabet letters as key
// and their ascii codes as the values.
ascii.insert(pair<char, int>('a', 97));
ascii.insert(pair<char, int>('b', 98));
ascii.insert(pair<char, int>('c', 99));
ascii.insert(pair<char, int>('d', 100));
ascii.insert(pair<char, int>('e', 101));
ascii.insert(pair<char, int>('f', 102));
/************* 2. max_size() *****************/
cout << "\nThe maximum capacity of the ASCII Map is: " << ascii.max_size() << "\n";
// traversing the map
// to print the map
// having the alphabet letters and
// their ascii values
map<char, int>::iterator i;
cout << "\nASCII Map \n";
cout << "\tKEY\tELEMENT\n";
/************* 3. begin() *****************/
/************* 4. end() *****************/
for (i = ascii.begin(); i != ascii.end(); ++i) {
cout << '\t' << i->first
<< '\t' << i->second << '\n';
}
/************* 5. size() *****************/
// print the size of the
// original map
// using the size() function
cout << "Original size of map: " << ascii.size() << "\n";
/************* 6. erase() *****************/
// erasing elements from the start of the map
// up to the key 'c' using the
ascii.erase(ascii.begin(), ascii.find('c'));
cout << "Updated ASCII Map after erasing"
" entries up to key 'c' \n";
cout << "\tKEY\tELEMENT\n";
for (i = ascii.begin(); i != ascii.end(); ++i) {
cout << '\t' << i->first
<< '\t' << i->second << '\n';
}
cout << "Size of the updated map: " << ascii.size() << "\n";
cout << "\n\n";
return 0;
}
Member Functions of C++ Map
Apart from the functions mentioned in the above section, there are a lot of other member functions in C++ Map which you will explore in the table given below:
MEMBER FUNCTIONS |
DESCRIPTION |
|
count() |
This function returns the total number of identical elements to a given key element |
|
equal_range() |
This function returns a pair of pointers. The first pointer points to the key passed, and the second pointer points to the next element of the key. |
|
rend() |
This function returns a pointer pointing to the element that comes before the first element of the container. |
|
rbegin() |
This function returns a pointer pointing to the last element of the container. |
|
rfind() |
This function returns a pointer pointing to the key passed, if found else returns to the last element. |
|
crbegin() |
This function returns a constant pointer pointing to the last element. |
|
crend() |
This function returns a constant pointer pointing to the element that comes before the first element. |
|
cbegin() |
This function returns a constant pointer pointing to the first element. |
|
cend() |
This function returns a constant pointer pointing to the element that comes after the last element. |
|
emplace() |
This function returns a key and the element corresponding to it. |
|
upper_bound() |
This function returns a pointer pointing corresponding to the key or will point after the key value. |
|
lower_bound() |
This function returns a pointer pointing corresponding to the key or will point before the key value. |
|
value_comp |
This function returns how the elements should be compared based on the values. |
|
key_comp |
This function returns how the elements should be compared based on the keys. |
|
at() |
This function returns the value that resides on the passed index. |
|
swap() |
This function swaps the elements of two maps of the same type. |
Conclusion
In this article, you have learned about C++ Maps. You learned the syntax of maps, along with their parameters, and their uses in-depth. This article dived deep into how you can create a map and all the member functions of the map.
To get a better understanding of the entire C++ programming language, you can go through our guide on C++ Programming for Beginners. Check out the complete list of free courses offered by Simplilearn.
If you are perhaps looking for a more comprehensive software development course that covers practical training in today’s software development languages and tools, Simplilearn’s Post Graduate Program in Full Stack Web Development in collaboration with Caltech CTME should be your next stop. This coding bootcamp covers 30+ in-demand tools with top practitioners from around the world teaching you the most critical skills needed today to become a Full Stack Developer anywhere in the world. Explore and start today.
Have any questions for us on this C++ Map article? If yes, leave them in the comments section of this article, and our experts will get back to you at the earliest!
Happy Learning!