Returning iterator from constant member function - c++

Question

In the following code why the return type of foo::func is vector<int>::const_iterator and not vector<int>::iterator though I am returning an object of vector<int>::iterator.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class foo
{
private:
vector<int> ar;
public:
foo()
{
ar.resize(10);
iota(ar.begin(), ar.end(), 1);
}
auto func() const
{
return ar.begin() + 5;
}
};
int main()
{
foo x;
cout<<boolalpha<<endl;
auto it = x.func();
cout<<is_same<decltype(it), vector<int>::iterator>::value<<endl;
cout<<is_same<decltype(it), vector<int>::const_iterator>::value<<endl;
return 0;
}
Output of above code is :
false
true
Instead if I redefine foo::func() as
auto func()
{
return ar.begin() + 5;
}
The output will be
true
false
Why the constant member function is changing return type to constant?
And should I need to remove const keyword to make the return type as vector<int>::iterator or is there any other way?

Answer 1

A member function declared const affects the type of the this pointer. Within func(), this has type const foo*. As a result, all member types accessed via a const this pointer will themselves be const, so the implicit type of ar is in fact const std::vector<int>. Of the two begin() overloads for vector, the only viable overload is the const overload, which returns a const_iterator.
When you redefine func() to be non-const, then the type of this is simply foo*, so the type of the member ar is std::vector<int> and the overload of begin() returning iterator is preferred.

Answer 2

There are two std::vector::begin depending on whether the instance is const or not.
In foo::func() const, you are trying to access ar which is then viewed as a const std::vector<int>, and std::vector::begin() const returns a const_iterator.
When you access ar in foo::func(), it is then viewed as a std::vector<int>, without const, and begin will then refer to std::vector::begin() (without const again), which is not the same function.
Similarly, your own foo class could define two versions of foo::func simultaneously:
auto func()
{ return ar.begin() + 5; }
auto func() const
{ return ar.begin() + 5; }
And the constness of the instances will decide which version to call:
foo x;
const foo y;
x.func(); // First version, get an iterator
y.func(); // Second version, get a const_iterator

Answer 3

The iterator points to one of its data members and so if the function is const then the iterator must be const too otherwise you could change the data contained in the class from the iterator returned by a const member function.
That's my understanding at least - I would be grateful if someone else could confirm or deny this.

Answer 4

Member function begin is overloaded the following way
iterator begin() noexcept;
const_iterator begin() const noexcept;
Thus functions that are declared with qualifier const deal with constant objects. That means that data members of a constant object if they are not declared as mutable are also constant. In this case the second overloaded function begin is called for data member ar that returns const_iterator.