是否可以使用（const或非const）引用iter，以使*iter成为const int？
你调用std::array::cbegin()成员函数，它将返回一个std::array<int, 3>::const_iterator .解引用，它将给予你一个const int&。

• 然而，你不能通过非const引用来获取const_iterator，你必须通过值或const&来获取它（以延长由cbegin()函数返回的临时变量的生命期），一般的建议是通过值来获取迭代器。

有没有可能找出iter的类型，使得*iter是const int？
如果你 * 知道 * iter是某种指针（const T*，const T*&，T*或T*&等），那么你可以得到一个const T*，如下所示：

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

对于一般情况，从iterator获取const_iterator，而不使用容器的typedef作为const_iterator，将有点麻烦。一种方法是将迭代器 Package 在一个interator类中，该类在解引用时只返回const&。下面是一个std::list<int>::iterator的示例，它比指针稍微复杂一些。不过它对指针也有效。

#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&`
}

这个问题的目的是如何定义iter，以便在取消引用时给予常量访问
这就是const迭代器发挥作用的地方，对于迭代器来说，这实际上是一个不太全局的问题，因为const迭代器仅仅意味着一个常量容器的标准迭代器：

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"
);

在这种情况下，迭代器自身类型的一致性实际上并不取决于它们是否指向const类型，正如你已经注意到的，const迭代器意味着迭代器本身不能被改变，不能指向不同的对象。
回答你的第二个问题：
是否可以改为使用（const或non_const）引用const int？
不，引用总是const隐式的，并且在绑定到变量之后不能被重新绑定。