Why the value_type/difference_type/pointer/reference of back_insert_iterator/front_insert_iterator/insert_iterator are all void?

Question

In my project, I want to split stream into some given type of values, so I implement a template function as

template <typename TElem, typename TOutputIter>
TOutputIter SplitSpace(std::istream& IS, TOutputIter result)
{
    TElem elem;
    while (IS >> elem)
    {
        *result = elem;
        ++result;
    }
    return result;
}

I think this is awkward since I have to explicitly given the type of TElem when calling it. For example, I have to write:

std::vector<int> v;
SplitSpace<int>(std::cin, back_inserter(v));
// I want to it to be   SplitSpace(std::cin, back_inserter(v));

I tried to obtain the value type from an (template) iterator and used std::iterator_traits as follows:

template <typename TOutputIter>
TOutputIter SplitSpace(std::istream& IS, TOutputIter result)
{
    typename std::iterator_traits<TOutputIter>::value_type elem;
    while (IS >> elem)
    {
        *result = elem;
        ++result;
    }
    return result;
}

However, the above codes do not work for back_insert_iterator. I checked the source codes of back_insert_iterator/front_insert_iterator/insert_iterator in std namespace and found the value_type/difference_type/pointer/reference are all void.

I would like to know why these types are all void, is there any consideration for this? Another question is that is it possible to implement the SplitSpace function without explicitly giving the element type when call it? Thanks.

They are kind of write only iterators, what other type should those typedefs have? — PlasmaHH, Apr 23 '13 at 09:25
Not "kind of". They're OutputIterators, i.e. write only and non-repeatable. Still +1 for interesting question — sehe, Apr 23 '13 at 09:26
Definitely weird, there seem to be no reason to mangle the `typedef` when they can be used both to extract *and* insert elements... — Matthieu M., Apr 23 '13 at 09:38
It does not answer your question, but are you familiar with [`std::istream_iterator`](http://en.cppreference.com/w/cpp/iterator/istream_iterator)? As far as I can tell, it provides exactly the kind of feature you are trying to implement (along with [`std::copy`](http://en.cppreference.com/w/cpp/algorithm/copy)). — Luc Touraille, Apr 23 '13 at 09:44

score 7 · Answer 1 · edited Nov 16 '18 at 14:31

value_type does not make much sense in the case of OutputIterators, because an output iterator does not give access to any values, and more importantly it can accepts a wide range of value types.

The only requirement for an OutputIterator it is that it must supports the expression *it = o where o is a value of some type that is in the set of types that are writable to the particular iterator type of i (§24.2.1). This means that an output iterator can potentially accepts a wide range of types: for instance, its operator* can return a proxy object that overloads operator= for a variety of types ; what should be value_type in this case?

For instance, consider the following output iterator:

struct SwallowOutputIterator : 
    public std::iterator<output_iterator_tag, void, void, void, void>
{
    struct proxy // swallows anything
    {
        template <typename T>
        void operator=(const T &) {}
    };

    proxy operator*() 
    {
        return proxy();
    }

    // increment operators
};

There is no sensible choice for value_type here.

The same reasoning applies to pointer and reference_type. difference_type is not defined because you cannot calculate the distance between two output iterators, as they are single-pass.

N.B.: the standard explicitely states that insert_iterator and its siblings must inherits from iterator<output_iterator_tag, void, void, void, void>, so this is not a peculiarity of your implementation.

score 3 · Answer 2 · answered Apr 23 '13 at 09:51

3

As mentioned by Luc in the comments what you want to do can be easily done with the standard library:

std::vector<int> v;
std::copy( std::istream_iterator( std::cin )
         , std::istream_iterator()
         , std::back_inserter( v ) );

answered Apr 23 '13 at 09:51

indeterminately sequenced

626
6
17

score 3 · Answer 3 · answered Apr 23 '13 at 10:17

In case you are just looking for a way to avoid to specify the TElem template param, you can use this approach:

template <typename TOutputIter>
TOutputIter SplitSpace(std::istream& IS, TOutputIter result)
{
    typedef typename TOutputIter::container_type::value_type TElem;

    TElem elem;
    while (IS >> elem)
    {
        *result = elem;
        ++result;
    }
    return result;
}

...of course, depending on which TOutputIter types you pretend to use, you shouldn't use this approach.

score 2 · Answer 4 · answered Apr 23 '13 at 09:36

2

AFAIK, you should be able to obtain the container_type from the iterator, from which you should be able to obtain a value_type. You probably want to specialize for a pair at some point. This should answer part two, as for part one; not sure...

answered Apr 23 '13 at 09:36

Nim

33,299
2
62
101

1

How do you obtain the container type from an iterator (not every output iterator actually has a container type)? – Christian Rau Apr 23 '13 at 10:29
@ChristianRau, according to this, apparently there should be for the listed iterators: http://en.cppreference.com/w/cpp/iterator/front_insert_iterator – Nim Apr 23 '13 at 10:43
....doesn't mean that your custom defined iterator called `Bob` will support this functionality... that's your prerogative... – Nim Apr 23 '13 at 10:47
1

Well, tell this to the people expecting a generic function that expects an output iterator. Or at least tell it to the OP expecting a generic iterator when reading the word *"iterator"* in the answer. – Christian Rau Apr 23 '13 at 10:49

Why the value_type/difference_type/pointer/reference of back_insert_iterator/front_insert_iterator/insert_iterator are all void?

4 Answers4