C++ Input Iterator

The C++ Input Iterator is one of the five iterator categories defined by the C++ Standard Library. Iterators are objects that provide a way to access elements in a sequence (like an array or a container) in a generic and uniform manner. Input Iterators are one of the simplest types of iterators and are primarily used for reading values from a data structure.

Here are some key characteristics of Input Iterators:

1. Read-Only: Input Iterators can be used to read values from a sequence but cannot be used to modify the elements they point to. They support read operations like dereferencing and incrementing.
2. Single-Pass: Input Iterators are designed for single-pass traversal of a sequence. Once you increment an input iterator, you cannot go back to the previous element. This makes them suitable for algorithms that only need to read the sequence once.
3. Equality Comparison: Input Iterators support equality comparison (e.g., == and !=) to determine when they have reached the end of the sequence. When an input iterator reaches the end, it becomes equal to another input iterator pointing to the end.

Here’s a basic example of using an Input Iterator to read values from an std::istream (e.g., std::cin for reading from the console):

#include <iostream>
#include <iterator>

int main() {
    std::istream_iterator<int> input_iterator(std::cin);
    std::istream_iterator<int> end_iterator;  // Default-constructed end iterator

    while (input_iterator != end_iterator) {
        int value = *input_iterator;  // Dereferencing to read the value
        std::cout << "Read: " << value << std::endl;
        ++input_iterator;  // Increment the input iterator
    }

    return 0;
}

In this example, std::istream_iterator is an Input Iterator specifically designed for reading from input streams. It allows you to read integers from std::cin until the end of the input stream is reached.

Input Iterators are used with various algorithms from the C++ Standard Library, such as std::copy, std::find, and others, to process sequences in a generic and efficient manner.