Const methods and custom iterators - c++

Question

I have a class that contains a std::vector, and another that is a custom iterator for that class. It works great for non-const methods, but when I try to create an iterator in a const method, the compiler fails because it can't convert a const_iterator to an iterator. For example, the code below fails, but if the call to ConstFunc is commented out, it compiles and runs fine.
#include <vector>
template <class T>
class FooIter {
public:
typename std::vector<T>::iterator iterator;
FooIter(std::vector<T> &vec) {iterator = vec.begin();}
};
template <class T>
class Foo {
public:
std::vector<T> vec;
Foo() {}
void NonConstFunc() {
FooIter<T> iter(vec);
}
void ConstFunc() const {
FooIter<T> iter(vec);
}
};
int main()
{
Foo<int> foo;
foo.NonConstFunc();
foo.ConstFunc();
return 0;
}
Is there a way to modify FooIter so it can serve as both iterator and const_iterator?
EDIT: A commenter asked "How do you plan to use FooIter<T> in a const method?" Below is one example.
std::vector< std::pair<unsigned, unsigned> > find() const {
std::vector< std::pair<unsigned, unsigned> > list(0);
Matrix2dIterator<T> it = this->begin(true);
Matrix2dIterator<T> itEnd = this->end(true);
for (; it != itEnd; ++it) {
if (*it) {
list.push_back(std::make_pair(it.getRow(), it.getCol()));
}
}
return list;
}
Matrix2d is "Foo", and Matrix2dIterator is "FooIter". find needs to iterate over the std::vector which holds the matrix data, but it is not changing that data.

Answer 1

The reason for this is, that you could modify vec and therefore your class through a std::vector<T>::iterator. So you cannot have them in a const member function. The more technical reason is that in a const member function all members are const and the std::vector has the functions
std::vector<T>::iterator begin();
std::vector<T>::const_iterator begin() const;
std::vector<T>::const_iterator cbegin() const;
so if vec is const begin() will return a const iterator which is also very sensible, since you cannot modify the vector through a const_iterator.
You can adapt your code by providing a ConstFooIter that has a member of type std::vector<T>::const_iterator this would look like the following:
#include <vector>
template <class T>
class ConstFooIter {
public:
typename std::vector<T>::const_iterator iterator;
ConstFooIter(const std::vector<T> &vec) {iterator = vec.cbegin();}
};
Alternatively, you don't template on the value_type of the vector but on the vector itself, this detects const-ness automatically:
#include <vector>
template <class T, class = std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, std::vector<typename T::value_type, typename T::allocator_type>>>>
class FooIter {
public:
decltype(std::declval<T>().begin()) iterator;
FooIter(T &vec) {iterator = vec.begin();}
};
template <class T>
class Foo {
public:
std::vector<T> vec;
Foo() {}
void NonConstFunc() {
FooIter iter(vec);
}
void ConstFunc() const {
FooIter iter(vec);
}
};
int main()
{
Foo<int> foo;
foo.NonConstFunc();
foo.ConstFunc();
return 0;
}
Note that this does not imply that you only have one class left. The iters in your two methods will be of different types (FooIter<std::vector<T>> vs FooIter<const std::vector<T>>). The advantage is that the compiler will do the dirty work of writing the two classes for you and hence you decrease the code duplication since the two classes are nearly the same.
This comes at a disadvantage. It is not that easy to see which variant is used right now and using a const iterator in a non-const context (which you should always do if you do not intend to modify anything) is a bit tricky since FooIter(vec) will always return the non-const variant when vec is not const.
EDIT: Added some template magic to only allow std::vector, i.e. std::set<int> s; FooIter f{s}; won't compile anymore.

Answer 2

You should go for one of n314159's solutions. I'm just showing what the problem is of making your FooIter work for both non-const and const vectors.
You can add an overloaded constructor to FooIter that takes a const reference:
FooIter(const std::vector<T> &vec) {iterator = vec.begin();}
This would be enough, if it were not for the fact that iterator itself is non-const, and so the compiler will rightfully complain about that. You could have two member variables, one non-const and the other const:
typename std::vector<T>::iterator iterator;
typename std::vector<T>::const_iterator const_iterator;
FooIter(std::vector<T> &vec) {iterator = vec.begin();}
FooIter(const std::vector<T> &vec) {const_iterator = vec.begin();}
But then other member functions would need to know which one to use. You could add a flag variable for that, but that would be rather inefficient; it needs more memory (apart from the duplication of the iterator itself), and it needs a check for every member function call. So the best solution is to have two separate iterator classes, one for non-const and the other for const.

Answer 3

maybe..?
#include <vector>
using namespace std;
template <class T>
class FooIter {
public:
const typename vector<T>::iterator itr; // const added
FooIter(vector<T> &vec) : itr{vec.begin()} {}
};
template <class T>
class Foo {
public:
vector<T> vec;
Foo() {}
void NonConstFunc() {
FooIter<T> iter(vec);
}
void ConstFunc() { // const removed, if
FooIter<T> iter(vec); // needed prefix it on each needed line
}
};
int main() {
Foo<int> foo;
foo.NonConstFunc();
foo.ConstFunc();
return 0;
}