reference with const access

Question

Using pointers, I can create all combinations of (const/non_const) to (T / const T) for any type T, as discussed in detail this answer.

But using references, how can I define a reference to a variable which can be dereferences (like an iterator), such that the dereferenced reference gives a const access?

For example, consider this program:

#include <array>

int main()
{
    std::array<int, 3> a{0, 0, 0};
    auto const& iter = a.begin();
    // iter++; // Error!
    (*iter)++;
}

iter is const variable, and if you uncomment the line iter++ the code cannot compile. But iter dereferences to a non-const int, which in fact can be incremented with (*iter)++. In a sense, iter mimics int * const, i.e., a const pointer to int.

Is it possible to instead have a (const or non_const) reference iter, such that *iter is a const int?

Please bear in mind that I am aware that I could use const auto& iter = a.cbegin() in the example above. The purpose of the question is how to define iter, such that, when dereferenced, give a const access, irrespective of what is on the right of the equal operator. For iterators I can imagine to explicitly bind to a const_iterator, like:

const decltype(a)::const_iterator& iter = a.begin();

This solution works because I know that the equivalent "const-access" of an iterator is a const_iterator.

But, more generally:

(some type)& iter = rhs

If all I know is that *rhs is a int, is it possible to find out the type of iter, such that *iter is a const int?

Another point worth to consider is the possible cost of the conversion of rhs.

Technically, you can't have a *"const reference"* in c++. You can have *"reference to const type"* though. — Jason, Jan 23 '23 at 11:41
`auto iter = a.cbegin()` - `iter` is now a `const_iterator` - not a `const iterator&` — Ted Lyngmo, Jan 23 '23 at 11:43
references do already refer to the actual object, you don't "dereference them". — 463035818_is_not_an_ai, Jan 23 '23 at 12:08
Do you want `iter` to be `const` as well so it mimics a `const T * const`? — NathanOliver, Jan 23 '23 at 13:02
The definition of `iter` will never change the meaning of your rhs. — Captain Giraffe, Jan 23 '23 at 13:15
@463035818_is_not_a_number Sure, the sentence was not accurate-- I amended the text. — francesco, Jan 23 '23 at 14:13
@NathanOliver the reference itself could also be const, when necessary. — francesco, Jan 23 '23 at 14:14

score 1 · Answer 1 · answered Jan 23 '23 at 12:05

The purpose of the question is how to define iter, such that, when dereferenced, give a const access

And this is where const iterators come into play. For iterators it's actually a less global question, because a const iterator merely means a standard iterator to a constant container:

const std::array<int, 3> a{ 0, 0, 0 };
static_assert(
    std::is_same_v<decltype(a.begin()), decltype(a.cbegin())>,
    "The iterators are of different type"
);

Constness of the iterators' own types in this case doesn't actually depend on whether they point to a const type or not. As you already noticed, const iterator instead means that the iterator itself cannot be changed and point to a different object.

Answering your second question:

Is it possible to instead have a (const or non_const) reference to const int?

No, a reference is always const implicitly and cannot be rebound after being bound to a variable.

Regarding the second question/answer, it's better to think of a reference as an *alias* which just an alternative identifier to the same object, rather than thinking of as being a bound "thing" that cannot be rebound. The compiler may implement either approach under the covers, but that's not programmatically exposed. — Eljay, Jan 23 '23 at 14:08

score 1 · Accepted Answer · answered Jan 25 '23 at 21:28

Is it possible to instead have a (const or non-const) reference iter, such that *iter is a const int?

You call the std::array::cbegin() member function that will return a std::array<int, 3>::const_iterator. Dereferencing that will give you a const int&.

You can however not take the const_iterator by a non-const reference. You must take it by value or by const& (to prolong the life of the temporary returned by the cbegin() function). The general recommendation is to take iterators by value though.

is it possible to find out the type of iter, such that *iter is a const int?

If you know that iter is some kind of pointer (const T*, const T*&, T* or T*& etc.) then you could get a const T* like this:

const std::remove_cvref_t<decltype(iter)> constiter = iter;

For the general case, getting a const_iterator from an iterator without using the container's typedef for const_iterator, will be a bit cumbersome. One way could be to wrap the iterator in an interator class that only returns const&s when dereferenced. Here's an example with a std::list<int>::iterator which is a little more complicated than a pointer. It works for pointers too though.

#include <iostream>
#include <list>

template<class It>
struct const_iterator {
    using IterType = std::remove_reference_t<It>;
    using Traits = std::iterator_traits<IterType>;   

    using difference_type = typename Traits::difference_type;
    using value_type = const typename Traits::value_type;
    //                 ^^^^^
    using pointer = value_type*;
    using reference = value_type&;
    using iterator_category = typename Traits::iterator_category;

    const_iterator(It nc) : value(nc) {}
    
    // dereferencing gives a const&
    reference operator*() const { return *value; }

    bool operator==(const const_iterator& rhs) const { return value == rhs.value; }
    bool operator!=(const const_iterator& rhs) const { return !(*this == rhs); }
    
    const_iterator& operator++() { ++value; return *this; }
    const_iterator operator++(int) { const_iterator rv(*this); ++value; return rv; }

    // Add conditional support for proxy member functions supported
    // by the original iterator type / iterator_category

    IterType value;
};

template<class It>
const_iterator(It) -> const_iterator<It>;

int main()
{
    std::list<int> a{1, 2, 3};
    auto iter = a.begin();
    *iter = 10;                // Ok

    const_iterator cit(iter);  // make a const_iterator from the original iterator
    ++cit;                     // Ok
    std::cout << *cit << '\n'; // prints 2
    //*cit = 20;               // Error: *cit is a `const int&`
}

reference with const access

2 Answers2