CODEWITHSUNDEEP
c++unique-ptr
Henk
Henk

Reputation: 846

Returning a range of references to a std::vector<std::unique_ptr<T>>

I have an abstract base class T and another class holding a vector of unique pointers to T. The class should support two function returning references to the entries. One of them should provide read-access, the other one should be able to modify the values in the unique_ptrs but not the pointers:

class A {
  private:
    std::vector<std::unique_ptr<T>> data;
  public:
    auto access() -> RefRange<T>;
    auto const_access() -> ConstRefRange<T>;
};

The ranges should satisfy the requirements of a std::random_access_range. How can I do this without allocating additional memory in C++17 (boost is available)?

Upvotes: 1

Views: 1007

Answers (3)

Caleth
Caleth

Reputation: 62719

If you have boost, much of this is done by the range adaptor indirected

class A {
  private:
    static auto add_const(T & t) -> const T & { return t; }
    std::vector<std::unique_ptr<T>> data;
    using indirected = boost::adaptors::indirected;
    using transformed = boost::adaptors::transformed;
  public:
    auto access() { return data | indirected; }
    auto const_access() const { return data | indirected | transformed(add_const); }
};

Or with std::views::transform in C++20

class A {
  private:
    static auto indirect(const std::unique_ptr<T> & ptr) -> T & { return *ptr; }
    static auto add_const(T & t) -> const T & { return t; }
    std::vector<std::unique_ptr<T>> data;
    using transform = std::views::transform;
  public:
    auto access() { return data | transform(indirect); }
    auto const_access() const { return data | transform(indirect) | transform(add_const); }
};

If you have <experimental/propagate_const>, I'd use that instead of whichever transform(add_const).

class A {
  private:
    std::vector<std::experimental::propagate_const<std::unique_ptr<T>>> data;
    using indirected = boost::adaptors::indirected;
  public:
    auto access() { return data | indirected; }
    auto const_access() const { return data | indirected; }
};

Upvotes: 5

alagner
alagner

Reputation: 4062

Wrapper around iterator is the first thing that comes to my mind. It's a quick and dirty example, but you should get the idea I suppose.

Demo: https://godbolt.org/z/z365js1T9

#include <memory>
#include <vector>
#include <iostream>
#include <initializer_list>


template<typename T>
struct S
{
    using VecType = std::vector<std::unique_ptr<T>>;
    VecType v{};

    class RefRange
    {
    public:
        RefRange(VecType& v) : r{v} {}
        struct iterator
        {
            typename VecType::iterator underlying_iterator;
            //below just return const T& for ConstRefRange
            T& operator*() const { return *underlying_iterator->get();}
            iterator& operator++(){++underlying_iterator; return *this;}
            iterator operator++(int) {iterator ret{*this}; ++(*this); return ret;}

            friend bool operator==(const iterator& l, const iterator& r)
            { 
                return l.underlying_iterator==r.underlying_iterator;
            }

            friend bool operator!=(const iterator& l, const iterator& r)
            { 
                return !(l==r);
            }
        };

        iterator begin() {return iterator{r.begin()};}
        iterator end() {return iterator{r.end()};}
    
    private:
        VecType& r;
    };

    RefRange refs() {return RefRange{v};}
};

int main()
{
    S<int> s;
    s.v.push_back(std::make_unique<int>(5)); 
    s.v.push_back(std::make_unique<int>(6)); 
    s.v.push_back(std::make_unique<int>(7)); 
    
    auto r = s.refs();
    for (auto&& el : r) {std::cout << el;}
}

Upvotes: 0

Mestkon
Mestkon

Reputation: 4046

You can implement a wrapper type which wraps the std::vector::iterator and provides a reference to the element contained by the std::unique_ptr on dereference. Then return a simple struct containing begin and end iterators of these types.

Ex:

template<class T>
struct MyIterator
{
    typename std::vector<std::unique_ptr<T>>::iterator iter; // or const_iterator for the const version

    decltype(auto) operator*() const { return *iter->get(); }

   // implement the rest of the iterator functionality
   // ...
};

template<class T>
struct RefRange
{
    MyIterator<T> first, last;

    auto begin() const { return this->first; }
    auto end() const { return this->last; }
};

class A {
private:
    std::vector<std::unique_ptr<T>> data;
public:
    auto access() -> RefRange<T> { return { data.begin(), data.end() }; }
};

Upvotes: 0

Related Questions