Introduction to Iterator in C++
Traversing through your highly complex data stored in different types of containers such as an Array, Vector, etc. in the smallest execution time is possible because of the Iterator in C++, a component of Standard Template Library (STL). Don’t worry it is just a pointer like an object but it’s smart because it doesn’t matter what container you are using, it will make your algorithm independent of Container type by providing a common interface for all types of container like a bridge between algorithm and container. Iterator not only reduces the complexity of a program instead makes execution time much faster.
For example, the sort()algorithm which has two parameters, ending and starting iterator will perform the sorting in order irrespective of what type of container you are using. Iterator allows the application of generic Algorithms to data structures. Data structures can use an Iterator to expose a range of elements.
Operations using the Iterator
- begin(): This function will return an iterator pointing to the first element of the container.
- end(): This function will return an iterator pointing to the past the last element of the container.
- advance(): This function will increment an iterator position to the specified argument.
- next(): This function will return the new iterator that will be pointed by iterator after incrementing the positions in the arguments.
- previous(): This function will return the new iterator that will be pointed by iterator after decrementing the positions in the arguments.
- inserter(): This function will insert the element at any position in the container.
1. C++ code to implement the Iterator
using namespace std;
//Declaring a Vector
//Function for iterating through vector elements
std::cout << *i <<" ";
2. C++ code to show iterator functionality
using namespace std;
//Declaring a Vector
cout << *i <<" ";
As of C++ 17, there are 5 different types of Iterators that can be classified depending upon the type of functionality as shown in the flowchart below:
- Input Iterator(stdin): Because of limited functionality they are weakest of all iterators with read-only and forward-moving functionality. It can’t modify the container value. Dereference operator(*),Not equal operator(!=), Increment operator(++) and Equal operator(==) can be used as input iterators. Also for sequential input operations.
- Output Iterator(stdout): Iterator only for storing, write-only iterator which is used to modify the value of a container. They also have very limited functionality. Iterator cannot access the element. The assignment operator(=) and Increment operator(++) can be used as output iterators. Only in a single-pass algorithm.
- Forward Iterator(singly linked list): This Iterator contains the functionality of both Input and Output Iterators. It can move forward in direction with one step at a time. For reading and writing to a container, it is the most preferred iterator which supports reusing and saving. It supports all the above operators.
- Bidirectional Iterator(doubly linked list): As the name already suggests bi-directional which makes it stronger than the above iterators. It also supports reading and writing to a container. It supports the Decrement operator(–).
- Random Access Iterator(arrays): Strongest iterator is the most powerful iterator as it can read, write and can access randomly. Pointer like functionality like the pointer addition and subtraction.
Advantages of Iterator in C++
If you need to move from one element that iterator is currently pointing to another element that is potentially n steps away from your current iterator. The first four in the hierarchy will take a linear amount of time to do that while a random access iterator can do that in constant time and that is way more fascinating because that’s where time is saved. It is the most important feature that an Iterator provides. Some more are mentioned below
- Code Efficiency: If we have P kinds of containers of data and Q things we want to do with them, then we will end up writing P * Q algorithms. If the data is also of R different types then we might end up with the P * Q * R algorithm. So by using the iterators, we can do it in the P + Q algorithm. We saved 90% of the time and work. Taking efficiency of code to the next level. The concept behind efficiency is that input iterator over source and output iterator over the target sequence need not be of the same type.
- Dynamic Processing: Iterators have dynamic functionalities such as swapping in the same container, Copy-assignable, incrementing, dereferencing and decrementing. The iterator provides the functionality to remove and dynamically add elements to the container. As all iterators can be incremented, input iterators can be compared and dereferenced to a value. Bidirectional iterators can be decremented. The main aspect is to write one function and use it for any container.
Disadvantages of Iterator in C++
- You can’t move from one data structure to another at the same time in some complex way. Iterator won’t work in that case.
- If you are processing through a list and you forgot something and now you want to go back then you can’t because iterators won’t work in that way.
- In case you need to update structure during traversing, you can’t do that too because of the iterator way of storing its position.
While using iterators keep these two things always in mind for making code efficient. Always pass the iterator into a function instead of containers. You should never return containers instead of return or pass iterator. You can get any element using an iterator, dereference and passing a pair of the iterator to an algorithm
This is a guide to the Iterator in C++. Here we discuss operations in the iterator, categories, advantages, and disadvantages with codes and outputs. You can also go through our other related articles to learn more-