c++ - "SafeArray"指针的

Question

我正在尝试实现一个“安全数组”类来练习运算符重载。我已成功重载“[]”运算符以返回正确的对象引用。

我的安全数组的要求之一是指向项目的指针将支持指针算法，例如，给定一个指向 arr[i] 的指针我将能够访问 arr[i+1] 通过 *(&(arr[i]) + 1)。安全数组也必须保护此操作，并且在尝试访问越界对象的情况下将抛出异常。

实现这个目标的最佳方式是什么？

Answer 1

您要求的有点棘手，但可以通过实现一些代理对象来实现，例如:

template<typename T>
class SafeArray
{
private:
    T* m_arr;
    size_t m_size;

    T& at(size_t index);
    const T& at(size_t index) const;

public:
    ...

    class Proxy
    {
    private:
        SafeArray<T>& m_sa;
        size_t m_index;

        Proxy(SafeArray<T>& sa, size_t index);

        friend class SafeArray<T>;

    public:
        operator T() const;
        Proxy& operator=(const T &value);

        class Ptr
        {
        private:
            SafeArray<T>& m_sa;
            size_t m_index;

            Ptr(SafeArray<T>& sa, size_t index);

            friend class SafeArray<T>::Proxy;

        public:
            Ptr operator+(size_t rhs);
            Ptr operator-(size_t rhs);
            Ptr& operator++();
            Ptr operator++(int);
            Ptr& operator--();
            Ptr operator--(int);

            Proxy operator*();
        };

        Ptr operator&();
    };

    friend class Proxy;

    Proxy operator[](size_t index);
};

template<typename T>
T& SafeArray<T>::at(size_t index)
{
    if (index >= m_size)
        throw std::out_of_range();
    return m_arr[index];
}

template<typename T>
const T& SafeArray<T>::at(size_t index) const
{
    if (index >= m_size)
        throw std::out_of_range();
    return m_arr[index];
}

template<typename T>
SafeArray<T>::Proxy SafeArray<T>::operator[](size_t index)
{
    return Proxy(*this, index);
}

template<typename T>
SafeArray<T>::Proxy::Proxy(SafeArray<T>& sa, size_t index)
    : m_sa(sa), m_index(index)
{
}

template<typename T>
SafeArray<T>::Proxy::operator T() const
{
    return m_sa.at(m_index);
} 

template<typename T>
SafeArray<T>::Proxy& SafeArray <T>::Proxy::operator=(const T &value)
{
    m_sa.at(m_index) = value;
    return *this;
}

template<typename T>
SafeArray<T>::Proxy::Ptr SafeArray<T>::Proxy::operator&()
{
    return Ptr(m_sa, m_index);
}

template<typename T>
SafeArray<T>::Proxy::Ptr::Ptr(SafeArray<T>& sa, size_t index)
    : m_sa(sa), m_index(index)
{
}

template<typename T>
SafeArray<T>::Proxy::Ptr SafeArray<T>::Proxy::Ptr::operator+(size_t rhs)
{
    return Ptr(m_sa, m_index + rhs);
}

template<typename T>
SafeArray<T>::Proxy::Ptr SafeArray<T>::Proxy::Ptr::operator-(size_t rhs)
{
    return Ptr(m_sa, m_index - rhs);
}

template<typename T>
SafeArray<T>::Proxy::Ptr& SafeArray<T>::Proxy::Ptr::operator++()
{
    ++m_index;
    return *this;
}

template<typename T>
SafeArray<T>::Proxy::Ptr SafeArray<T>::Proxy::Ptr::operator++(int)
{
     retrurn Ptr(m_sa, m_index++);
}

template<typename T>
SafeArray<T>::Proxy::Ptr& SafeArray<T>::Proxy::Ptr::operator--()
{
     --m_index;
     return *this;
}

template<typename T>
SafeArray<T>::Proxy::Ptr SafeArray<T>::Proxy::Ptr::operator--(int)
{
    return Ptr(m_sa, m_index--);
}

template<typename T>
SafeArray<T>::Proxy SafeArray<T>::Proxy::Ptr::operator*()
{
    return m_sa[m_index];
}