Requirements for std::ignore

Question

C++11 introduces an object called std::ignore:

const /* unspecified */ ignore;

For brevity, let

typedef decltype(std::ignore) T;

From what I can tell, the only requirement for T is that it is CopyAssignable, due to the specification of std::tie [C++11, 20.4.2.4:7].

In g++-4.8, I find that T is additionally DefaultConstructible (e.g., T x; compiles). Is this implementation-defined behavior?

(If there are other requirements on T that I have missed, please elaborate.)

http://stackoverflow.com/questions/16227391/please-explain-this-code-that-uses-stdignore — , May 23 '13 at 19:13
That's an interesting question. What's the motivation behind it? It seems clear that the whole purpose of std::ignore is to be a placeholder: a kind of tag. It doesn't appear to have any use beyond that, specifically with std::tie. — Steven Maitlall, May 23 '13 at 19:15
No practical application. I'm making a "zip" iterator (see, e.g., boost) that allows the user to zip up a 'dummy' iterator. One use-case is supporting `std::copy_if` when the input iterators are zip iterators and the output iterator is a zip iterator with a subset of the tuple elements (of the inputs). I was wondering what would happen if a zip iterator with `ignore`d elements is used as an `InputIterator`, because the return value of `operator*` must be convertible to a tuple containing an object of type `T`. (Perhaps `DefaultConstructible`ity is a stronger requirement than necessary.) — nknight, May 23 '13 at 19:50

score 15 · Accepted Answer · answered May 23 '13 at 19:11

The standard has no requirements on the type of ignore, besides the fact that it is a type that is distinct from all other types.

Whatever machinery that a standard library container does to allow ignore to gain the required behavior when used with tie is up to that standard library implementation. The library may give it a template<T&> operator=(const T&) overload, or it may use some other mechanism to make it work. The standard doesn't say. So it doesn't even have to be CopyAssignable.

Note that tie only has special behavior if you specifically use ignore. If you use some other value, created by yourself (which, since the type has no requirements, you are not guaranteed to be able to do), you will get undefined behavior.

Andy Prowl · Answer 2 · 2013-05-23T20:10:05.590

From what I can tell, the only requirement for T is that it is CopyAssignable, due to the specification of std::tie [C++11, 20.4.2.4:7].

Formally, I don't think there is any requirement at all being placed. The fact that tie() can accept ignore as an argument does not mean that it has to store a value of that type in the tuple: although that's most likely what's going to happen in practice, I do not see this as being necessarily implied by the formal specification.

Is this implementation-defined behavior?

No, the behavior is unspecified, since the implementation is not required to document it (thanks to Pete Becker for clarifying this point).

Requirements for std::ignore

2 Answers2

Linked