请解释一下使用std :: ignore的代码

Question

I'm reading the documentation on std::ignore from cppreference. I find it quite hard to grasp the true purpose of this object, and the example code doesn't do it much justice. For example, in the below code, how and why is inserted set to true? It doesn't make much sense to me.

#include <iostream>
#include <string>
#include <set>
#include <tuple>

int main()
{
    std::set<std::string> set_of_str;
    bool inserted;
    std::tie(std::ignore, inserted) = set_of_str.insert("Test");
    if (inserted) {
        std::cout << "Value was inserted sucessfully\n";
    }
}

If someone can explain the code to me, it would be appreciated. Thanks.

Answer 1

set::insert returns a pair where first is the iterator to the inserted element and second is a bool saying whether the element was inserted.

std::tie creates a tuple of lvalue references. When assigned to the result from insert it enables you to set the variables in the tie to the results of the insert in the return pair 's first and second members.

std::ignore is a value that can be assigned to with no effect.

So basically, this code ignores the iterator to the element where "Test" was inserted and asigns inserted to the second member of the pair returned by set::insert that indicates whether the an element was inserted.

Answer 2

I think Dave's answer is pretty good, but I would like to explain a bit why to use such approach.

In other languages like Scala, Haskell or Python, you have usually the presence of tuples (being pair a tuple of two elements) and they have this idiomatic way to assign them to variables:

(var1,...,varN) = func_returning_tuple()

This has the purpose of expand semantic value of your code and improve his readability, where otherwise you would have a single variable with no semantics to their elements (like t.first, and so on), and in C++ to access values of tuples you would have to use:

varN = std::get<N>(my_tuple);

So, using only tie, you could make your example code easier to read as follows:

std::tie( element_iterator, inserted ) = set_of_str.insert("test");

And then use your isolated variables at will, this improves the way others (and even yourself) read the next statements of your code.

The std::ignore is used when you don't care for what is returned, in some other languages you also have this resource, in Scala for example this is the underscore. For example, if I use the insert function in a map and the value already exists it just returned the pair containing (iterator,false) so if I want the iterator for some key, even if I don't care if it already exists in the map, I can do it with this line:

std::tie( element_iterator, std::ignore ) = set_of_str.insert("test");

That's the way C++ solves this readability issue of tuples and pairs.