c++ - "const T& operator[](size_type i)"中的 const 有什么用？

Question

我在一本书 http://www.acceleratedcpp.com/ 中发现了这个有趣的行- 资源 - 第 11 章 - Vec.h(我是一个 std::vector 翻版)

而且我真的不明白这个版本的运算符有什么用。为什么要定义此运算符的两个版本(常量和非常量)？

我什至试过了，在我看来，非常量版本一直被调用......你能解释一下吗？

#include <iostream>
#include <algorithm>
#include <cstddef>
#include <memory>
using namespace std;

template <class T> class Vec {
public:
    typedef T* iterator;
    typedef const T* const_iterator;
    typedef size_t size_type;
    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;

    Vec() { create(); }
    explicit Vec(size_type n, const T& t = T()) { create(n, t); }

    Vec(const Vec& v) { create(v.begin(), v.end()); }
    Vec& operator=(const Vec&); // as defined in 11.3.2/196
    ~Vec() { uncreate(); }

    T& operator[](size_type i) { cout << "T&";return data[i]; }
    const T& operator[](size_type i) const { cout << "const T&!";return data[i]; }

    void push_back(const T& t) {
        if (avail == limit)
            grow();
        unchecked_append(t);
    }

    size_type size() const { return avail - data; }  // changed

    iterator begin() { return data; }
    const_iterator begin() const { return data; }

    iterator end() { return avail; }                 // changed
    const_iterator end() const { return avail; }     // changed
    void clear() { uncreate(); }
    bool empty() const { return data == avail; }

private:
    iterator data;  // first element in the `Vec'
    iterator avail; // (one past) the last element in the `Vec'
    iterator limit; // (one past) the allocated memory

    // facilities for memory allocation
    std::allocator<T> alloc;    // object to handle memory allocation

    // allocate and initialize the underlying array
    void create();
    void create(size_type, const T&);
    void create(const_iterator, const_iterator);

    // destroy the elements in the array and free the memory
    void uncreate();

    // support functions for `push_back'
    void grow();
    void unchecked_append(const T&);
};

template <class T> void Vec<T>::create()
{
    data = avail = limit = 0;
}

template <class T> void Vec<T>::create(size_type n, const T& val)
{
#ifdef _MSC_VER
    data = alloc.allocate(n, 0);
#else
    data = alloc.allocate(n);
#endif
    limit = avail = data + n;
    std::uninitialized_fill(data, limit, val);
}

template <class T>
void Vec<T>::create(const_iterator i, const_iterator j)
{
#ifdef _MSC_VER
    data = alloc.allocate(j - i, 0);
#else
    data = alloc.allocate(j - i);
#endif
    limit = avail = std::uninitialized_copy(i, j, data);
}

template <class T> void Vec<T>::uncreate()
{
    if (data) {
        // destroy (in reverse order) the elements that were constructed
        iterator it = avail;
        while (it != data)
            alloc.destroy(--it);

        // return all the space that was allocated
        alloc.deallocate(data, limit - data);
    }
    // reset pointers to indicate that the `Vec' is empty again
    data = limit = avail = 0;

}

template <class T> void Vec<T>::grow()
{
    // when growing, allocate twice as much space as currently in use
    size_type new_size = max(2 * (limit - data), ptrdiff_t(1));

    // allocate new space and copy existing elements to the new space
#ifdef _MSC_VER
    iterator new_data = alloc.allocate(new_size, 0);
#else
    iterator new_data = alloc.allocate(new_size);
#endif
    iterator new_avail = std::uninitialized_copy(data, avail, new_data);

    // return the old space
    uncreate();

    // reset pointers to point to the newly allocated space
    data = new_data;
    avail = new_avail;
    limit = data + new_size;
}

// assumes `avail' points at allocated, but uninitialized space
template <class T> void Vec<T>::unchecked_append(const T& val)
{
    alloc.construct(avail++, val);
}

template <class T>
Vec<T>& Vec<T>::operator=(const Vec& rhs)
{
    // check for self-assignment
    if (&rhs != this) {

        // free the array in the left-hand side
        uncreate();

        // copy elements from the right-hand to the left-hand side
        create(rhs.begin(), rhs.end());
    }
    return *this;
}

int main() {
    Vec<int> v;
    v.push_back(5);


    cout << v[0] << endl; // even now the non-const version is called!

    system("pause");
}

谢谢!

Answer 1

肯定是

 const T& operator[](size_type i) const // <-- note the extra const

Const 向编译器发出信号，表明调用代码不能可以修改返回值。

这与:

• 如果引用是可修改的，则通过引用返回是不安全的
• 通过引用返回比通过值返回更有效率
• 不能在const 对象(实例)上调用非常量方法

Rationale: if the declaring object itself is const there would be no way for the method to return a reference to a (part of) a member non-const; Const-ness cascades if you will: this is known as const-correctness.

在实践中你会经常看到像这样的 const/non-const 重载:

class Container
{
    private: 
       int data[10];
    public:
       int       & operator[](int i)       { return data[i]; }
       int const & operator[](int i) const { return data[i]; }
};

//
Container x;
Container& r = x;
const Container& cr = x;

x [3] += 1;
r [3] += 1;  // just fine, non-const overload selected
cr[3] += 1;  // compile error, return value `const &`

相关主题:

• 鲜为人知的 volatile 大体上也是如此修饰语
• const 的一个相关关键字(如果你愿意的话，它是相反的)是 mutable