How to use move semantics iterators and templates

Question

I want to write functions to add items. addItem and addItems each with a move variant. The latter accepts two input iterators. To add a single item I can overload the signature with rvalue references. But how do I overload a template function to work with move semantics?

void addItem(const shared_ptr<Item>& item, uint score) {
    // code that copies the shared_ptr…
}

void addItem(shared_ptr<Item>&& item, uint score) {
    // code that moves the shared_ptr…
}

template<typename Iterator>
void addItems(Iterator begin, Iterator end) {
    /*
     * What to do here to take both move and normal iterators?
     * Since I cannot overload by signature I dont know how to
     * differentiate between move and non move iterators
     */
}

Is it possible to have a single name for a function and to differentiate between the input iterators?

I have, but I dont understand how to overload the function to accept both move and non-move iterators. — ManuelSchneid3r
– ManuelSchneid3r, Commented Sep 6, 2017 at 16:30
@ManuelSchneid3r: Your current signature accepts all iterators — Mooing Duck
– Mooing Duck, Commented Sep 6, 2017 at 19:54

Guillaume Racicot · Accepted Answer · 2017-09-06 16:36:41Z

4

Since you are using iterator to insert to your list, the most straightforward solution would be to use move iterators. With move iterators, you don't need to change your template function addItems. The move iterators will move the referred element into the new container:

// Same function as before
addItems(
    std::make_move_iterator(someList.begin()),
    std::make_move_iterator(someList.end())
);

Alternatively, you could provide a move insert function, which uses the std::move algorithm:

template<typename Iterator>
void moveItems(Iterator begin, Iterator end) {
    std::move(begin, end, thelist.end());
}

This overload will move each elements to thelist container. The std::move algorithm is meant to be used with normal, non const iterators. The move item function is used like that:

std::vector<int> vec{1, 2, 3};

// move each ints into the new container
moveItems(vec.begin(), vec.end());

// With your old function, move semantics
// can still be applied with move Iterators
addItems(
    std::make_move_iterator(vec.begin()),
    std::make_move_iterator(vec.end())
);

edited Sep 6, 2017 at 16:36

answered Sep 6, 2017 at 16:14

Guillaume Racicot

42.7k9 gold badges93 silver badges163 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

ManuelSchneid3r Over a year ago

What if I dont pass move iterators? I need both of them.

Guillaume Racicot Over a year ago

@ManuelSchneid3r both what? Is there a way I can improve this answer?

ManuelSchneid3r Over a year ago

Well I can overload the addItem function by passing a reference in one function and a rvalue reference in the other function. Thats not the case with a templatet function. So I want to understand how I can overload this addItems function for both r- and lvalue references just like in the addItem function. What happens if I pass a regular iterator (non move) to your moveItems function?

Guillaume Racicot Over a year ago

@ManuelSchneid3r iterator are not passed by reference. Iterator are passed by value. There's no overload to do. If you were to take a container as parameter, I would also take the container by value and move the contained elements.

Collectives™ on Stack Overflow

How to use move semantics iterators and templates

1 Answer 1

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related