std::move

std::move operates as a utility function rather than a standard algorithm, casting an object to an rvalue reference to activate move semantics. This mechanism facilitates the transfer of internal resources from one object to another, bypassing expensive deep copy operations. Performance gains are most notable when handling large, resource-intensive structures like dynamic containers or strings.

By leveraging std::move, developers signal that an object's current state is no longer required, allowing its resources to be repurposed. The source object enters a valid but unspecified state post-transfer, meaning its prior contents cannot be safely accessed without reinitialization.

For a type to be moveable, it must implement a move constructor and move assignment operator. The standard library inherently provides these for its containers and managed types.

#include <iostream>
#include <vector>
#include <string>
#include <utility>

int main() {
    std::vector<std::string> src_data = {"alpha", "beta", "gamma"};
    std::vector<std::string> dest_data;

    dest_data = std::move(src_data);

    if (src_data.empty()) {
        std::cout << "Source container is empty post-transfer." << std::endl;
    }

    for (const auto& item : dest_data) {
        std::cout << item << " ";
    }

    return 0;
}

std::move_backward

std::move_backward relocates elements from a source range to a destination range, beginning at the end and working towards the beginning. Despite processing elements in reverse, the original relative sequence of the items remains intact within the target range. This algorithm is particularly advantageous when shifting elements within overlapping memory regions where a forward pass would overwrite unread data.

template<class BidirIt1, class BidirIt2>
BidirIt2 move_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last);

The template parameters BidirIt1 and BidirIt2 denote bidirectional iterators. The function accepts starting and ending iterators for the source (first, last) and the ending iterator for the destination (d_last). Elements are sequentially moved into the target space concluding at d_last.

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<std::string> origin{"red", "green", "blue"};
    std::vector<std::string> target(3);

    std::move_backward(origin.begin(), origin.end(), target.end());

    std::cout << "Origin state: ";
    for (const auto& val : origin) {
        std::cout << "[" << val << "] ";
    }
    std::cout << std::endl;

    std::cout << "Target state: ";
    for (const auto& val : target) {
        std::cout << "[" << val << "] ";
    }
    std::cout << std::endl;

    return 0;
}