No known conversions - c++

Question

I'm have a problem with my constructors.
I get the following error:
no known conversion for argument 1 from ‘std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char> >*’ to ‘std::multiset<std::__cxx11::basic_string<char> >::iterator {aka std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char> >}’
multiset.cpp:47:1: note: candidate: my_multiset::iterator::iterator()
my_multiset::iterator::iterator(void){}
multiset.h:17:10: note: no known conversion for argument 1 from ‘std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char> >*’ to ‘const cpt323::my_multiset::iterator&’
multiset.h:17:10: note: candidate: constexpr my_multiset::iterator::iterator(cpt323::my_multiset::iterator&&)
multiset.h:17:10: note: no known conversion for argument 1 from ‘std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char> >*’ to ‘my_multiset::iterator&&’
The code is working with the exception of this part, any suggestion on how to make the appropriate changes
class my_multiset : custom_datastructure
{
std::multiset<std::string> the_set;
std::multiset<std::string>::iterator head;
std::multiset<std::string>::iterator tail;
public:
class iterator : public custom_datastructure::iterator
{
std::multiset<std::string>::iterator current;
public:
iterator(void){};
iterator(std::multiset<std::string>::iterator a_set) : current(a_set)
{
}
};
multiset(void);
std::unique_ptr<custom_datastructure::iterator> begin(void)
{
head = the_set.begin();
return std::make_unique<my_multiset::iterator>(&head);
}
std::unique_ptr<custom_datastructure::iterator> end(void)
{
tail = the_set.end();
return std::make_unique<my_multiset::iterator>(&tail);
}
}
custom_datastructure is as below
struct datastructure
{
struct iterator
{
/** OPERATORS HERE **/
virtual std::unique_ptr<datastructure::iterator> operator++(void) = 0;
/** ETC **/
};
virtual std::unique_ptr<iterator> begin(void) = 0;
virtual std::unique_ptr<iterator> end(void) = 0;
}

Answer 1

Why is your code breaking?
The reason your code breaks is because unique_ptr can't be used as an iterator, so if you wrap your iterator in a unique_ptr when returning it from begin() and end(), then it isn't usable as an iterator anymore.
An iterator doesn't have to be a pointer; it just needs to act like one. In addition, an iterator shouldn't own data. A class owns data if the class is responsible for deleting that data, but an iterator shouldn't be responsible for deleting anything. It should just provide a way of accessing the data. This means that iterators can and should be passed around by value (instead of using std::unique_ptr).
How do we fix the design?
So here's the big question: are you trying to create an interface that returns some iterators, or are you trying to create an interface for things that act like iterators?
Creating an interface that returns some iterators
The most generic way to do this is through templates. The benefit of using templates is that it enables us to re-use this interface in a wide variety of situations, and we can #include the interface where we need it, without having any dependencies in the file defining the template.
template<class Iterator>
class Iterable {
public:
virtual Iterator begin() = 0;
virtual Iterator end() = 0;
};
We can use this to define my_multiset as returning iterators to std::multiset:
class my_multiset
: public Iterable<typename std::multiset<std::string>::iterator>
{
std::multiset<std::string> the_set;
public:
using iterator = typename std::multiset<std::string>::iterator;
iterator begin() override {
return the_set.begin();
}
iterator end() override {
return the_set.end();
}
};
Creating a GenericIterator<Value> - a class that can be assigned any iterator
Because pointers-to-iterators act like pointers, and not the underlying iterator, instead of using a unique_ptr<BaseIterator>, we're going to want to create a wrapper class that handles everything for us, while still acting like a normal iterator.
You'll be able to use it just like any old iterator, except that it can be assigned or created with an iterator to anything that derefences to Value. That means that the same GenericIterator can bind to a list iterator, a vector iterator, or even a std::multiset iterator.
Example showing how it could be used:
#include <iostream>
#include <list>
#include <vector>
int main()
{
std::vector<int> v{1, 2, 3};
std::list<int> l{10, 20, 30};
GenericIterator<int&> begin, end;
begin = v.begin();
end = v.end();
for (; begin != end; ++begin)
{
std::cout << *begin << " ";
}
begin = l.begin();
end = l.end();
for (; begin != end; ++begin)
{
std::cout << *begin << " ";
}
}
What parts do we need to make GenericIterator?
GenericIterator is going to store a pointer to a virtual base class. We'll also need a derived class that implements the base for a specific Iter.
Base class:
The base class virtualizes the main functions of an iterator: Increment, Dereference, and equality. It also provides a clone() method so that it's possible to make copies of iterators. close() comes in handy when writing a GenericIterator class that wraps this functionality.
template <class Value>
class IteratorBase
{
public:
virtual Value operator*() const = 0;
virtual IteratorBase& operator++() = 0;
virtual bool operator!=(IteratorBase const&) const = 0;
virtual bool operator==(IteratorBase const&) const = 0;
// We need this function for making copies of the iterator
virtual IteratorBase* clone() const = 0;
virtual ~IteratorBase() = default;
};
Derived class:
This derived class can wrap basically any other iterator on the planet, and it overrides all the methods in IteratorBase to give a fully-functioning iterator.
template <class Iter, class Value>
class IteratorDerived : public IteratorBase<Value>
{
Iter it;
public:
IteratorDerived() = default;
IteratorDerived(Iter it) : it(it) {}
IteratorDerived(IteratorDerived const&) = default;
IteratorDerived(IteratorDerived&&) = default;
Value operator*() const override { return *it; }
IteratorBase<Value>& operator++() override
{
++it;
return *this;
}
bool operator!=(IteratorBase<Value> const& other) const override
{
auto* derived = dynamic_cast<IteratorDerived const*>(&other);
return derived == nullptr || it != derived->it;
}
bool operator==(IteratorBase<Value> const& other) const override
{
auto* derived = dynamic_cast<IteratorDerived const*>(&other);
return derived != nullptr && it == derived->it;
}
IteratorBase<Value>* clone() const override
{
return new IteratorDerived(*this);
}
};
Generic Wrapper:
This GenericWrapper encapsulates all the functionality of an iterator, and because of how we're writing it, you can automatically assign any iterator that deferences to a matching value type.
template <class Value>
class GenericIterator
{
std::unique_ptr<IteratorBase<Value>> iterator;
public:
GenericIterator() = default;
GenericIterator(GenericIterator const& it) : iterator(it.iterator->clone())
{
}
GenericIterator(GenericIterator&&) = default;
// Creates a GenericIterator from an IteratorBase
explicit GenericIterator(IteratorBase<Value> const& it)
: iterator(it.clone())
{
}
// Creates a GenericIterator from an IteratorDerived
template <class Iter>
explicit GenericIterator(IteratorDerived<Iter, Value> const& it)
: iterator(it.clone())
{
}
// Creates a GenericIterator by wrapping another Iter
template <class Iter>
GenericIterator(Iter it) : iterator(new IteratorDerived<Iter, Value>(it))
{
}
GenericIterator& operator=(GenericIterator const& it)
{
iterator = std::unique_ptr<IteratorBase<Value>>(it.iterator->clone());
return *this;
}
GenericIterator& operator=(GenericIterator&&) = default;
Value operator*() const { return *(*iterator); }
GenericIterator& operator++()
{
++(*iterator);
return *this;
}
bool operator==(GenericIterator const& other) const
{
return *iterator == *other.iterator;
}
bool operator!=(GenericIterator const& other) const
{
return *iterator != *other.iterator;
}
};
Optional: C++17 template deduction guide
We can write a template type deduction guide for GenericIterator that automatically fills in the correct template parameter, making it easy to wrap any other iterator.
template<class Iter>
GenericIterator(Iter) -> GenericIterator<decltype(*std::declval<Iter>())>;