Container adaptors

Question

How to improve the functionality, exception safeness and other aspects of the following container adaptors?

Allows to write more generic code (not working for, say, <set>):

#include <utility>
#include <iterator>
#include <type_traits>

template< typename container, bool = std::is_const< std::remove_reference_t< container > >::value >
struct consumable_container;

template< typename container >
struct consumable_container< container, false >
{

    consumable_container(container && _container) noexcept
        : container_(std::forward< container >(_container))
    { ; }

    auto
    begin() noexcept
    {
        return std::make_move_iterator(std::begin(container_));
    }

    auto
    end() noexcept
    {
        return std::make_move_iterator(std::end(container_));
    }

private :

    container container_;

};

template< typename container >
struct consumable_container< container, true >
{

    static_assert(!std::is_rvalue_reference< container >::value);

    consumable_container(container && _container) noexcept
        : container_(std::forward< container >(_container))
    { ; }

    auto
    begin() const noexcept
    {
        return std::cbegin(container_);
    }

    auto
    end() const noexcept
    {
        return std::cend(container_);
    }

private :

    container container_;

};

template< typename container >
consumable_container< container >
move_if_not_const(container && _container) noexcept
{
    return std::forward< container >(_container);
}

// some generic code
#include <list>

template< typename container >
auto
transform_to_list(container && _container) noexcept
{
    static_assert(std::is_reference< container >::value || !std::is_const< container >::value);
    std::list< typename std::remove_reference_t< container >::value_type > list_;
    for (auto && value_ : move_if_not_const(std::forward< container >(_container))) {
        list_.push_back(std::forward< decltype(value_) >(value_));
    }
    return list_;
}

// testing data type
#include <iostream>

struct A
{

    A() { std::cout << __PRETTY_FUNCTION__ << std::endl; }
    ~A() { std::cout << __PRETTY_FUNCTION__ << std::endl; }

    A(A const &) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
    A(A &) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
    A(A &&) { std::cout << __PRETTY_FUNCTION__ << std::endl; }

    A & operator = (A const &) { std::cout << __PRETTY_FUNCTION__ << std::endl; return *this; }
    A & operator = (A &) { std::cout << __PRETTY_FUNCTION__ << std::endl; return *this; }
    A & operator = (A &&) { std::cout << __PRETTY_FUNCTION__ << std::endl; return *this; }

};

// testing
#include <deque>
#include <forward_list>
#include <vector>

#include <cstdlib>

int
main()
{
    {
        std::deque< A > const deque_(1);
        std::list< A > ld_ = transform_to_list(deque_);
    }
    std::cout << std::endl;
    {
        std::forward_list< A > forward_list_;
        forward_list_.push_front(A{});
        std::list< A > ls_ = transform_to_list(forward_list_);
    }
    std::cout << std::endl;
    {
        std::vector< A > vector_;
        vector_.push_back(A{});
        std::list< A > lv_ = transform_to_list(std::move(vector_));
    }
    return EXIT_SUCCESS;
}

Allows to enumerate elements in reverse order:

#include <utility>
#include <iterator>

template< typename container >
struct reversed_container
{

    reversed_container(container && _container) noexcept
        : container_(std::forward< container >(_container))
    { ; }

    auto
    begin() noexcept
    {
        return std::rbegin(container_);
    }

    auto
    end() noexcept
    {
        return std::rend(container_);
    }

private :

    container container_;

};

template< typename container >
reversed_container< container >
reverse(container && _container) noexcept
{
    return std::forward< container >(_container);
}

// testing
#include <iostream>
#include <vector>

#include <cstdlib>

int
main()
{
    std::vector< int > vector_({1, 2, 3, 4, 5});
    // using
    for (int i : reverse(vector_)) {
        std::cout << i << std::endl;
    }
    return EXIT_SUCCESS;
}

Allows to print list of elements with delimiter (without trailing delimiter):

#include <utility>
#include <iterator>

template< typename container >
struct head_container
{

    head_container(container && _container) noexcept
        : container_(std::forward< container >(_container))
    { ; }

    auto
    begin() noexcept
    {
        return std::begin(container_);
    }

    auto
    end() noexcept
    {
        auto last = std::end(container_);
        if (last == std::begin(container_)) {
            return last;
        } else {
            return std::prev(last);
        }
    }

private :

    container container_;

};

template< typename container >
head_container< container >
head(container && _container) noexcept
{
    return std::forward< container >(_container);
}

// testing
#include <iostream>
#include <vector>

#include <cstdlib>

int
main()
{
    std::vector< int > vector_({1, 2, 3, 4, 5});
    // using
    if (!vector_.empty()) {
        for (int i : head(vector_)) {
            std::cout << i << ", ";
        }
        std::cout << vector_.back() << std::endl;
    }
    return EXIT_SUCCESS;
}

Allows to treat first element in special way:

#include <utility>
#include <iterator>

template< typename container >
struct tail_container
{

    tail_container(container && _container) noexcept
        : container_(std::forward< container >(_container))
    { ; }

    auto
    begin() noexcept
    {
        auto first = std::begin(container_);
        if (first == std::end(container_)) {
            return first;
        } else {
            return std::next(first);
        }
    }

    auto
    end() noexcept
    {
        return std::end(container_);
    }

private :

    container container_;

};

template< typename container >
tail_container< container >
tail(container && _container) noexcept
{
    return std::forward< container >(_container);
}

// testing
#include <iostream>
#include <vector>

#include <cstdlib>

int
main()
{
    std::vector< int > vector_({1, 2, 3, 4, 5});
    // using
    if (!vector_.empty()) {
        for (int i : tail(vector_)) {
            vector_.front() += i;
        }
        std::cout << vector_.front() << std::endl;
    }
    return EXIT_SUCCESS;
}

Answer 1

The point of the code is to reduce verbosity:

Lets examine that:

std::list< A > ls_ = transform_to_list(forward_list_);

// Using iterators.
std::list< A > ls_(begin(forward_list_), end(forward_list_));

// Don't think its that verbose.
// Not only does it work with list but it also works with every other container.

Reverse is already done:

for (int i : reverse(vector_)) {
    std::cout << i << std::endl;
}

// Or we can use the standard library (or probably future extensions)
// Slightly longer but its properly namespaced so that's understandable.
for (auto i : boost::adaptors::reverse(vector_))
    std::cout << i << std::endl;
}

And my favorite:

if (!vector_.empty()) {
    for (int i : head(vector_)) {
        std::cout << i << ", ";
    }
    std::cout << vector_.back() << std::endl;
}

// Or with a specialized iterator.
// Which definitely seems shorter and less verbose.
std::copy(std::begin(vector_), std::end(vector_), PrefexOutputIterator(std::cout, ","));

Code Review

I don't see anything wrong (or that needs improving) with your code. Its nice and clean (some comments may hep the less experienced read the code). But overall it looks fine.

Goal of Code

I don't agree that the code achieves its goals (reduced verbosity of user code). I also think it makes boilerplate code more likely in user code (and boilerplate is bad as it tends to be cut and paste rather than written).

if (!vector_.empty()) {
    for (int i : head(vector_)) {
        std::cout << i << ", ";
    }
    std::cout << vector_.back() << std::endl;
}

Forcing your user to write a whole section of code, rather than simplifying the task of writing code is where you fail.

I also think you need to understand where C++ has been going over the last 6->8 years. This is towards the use of ranges (with iterators as the underlying model used as the building block for ranges).