"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];
}

Answer 2

您需要为您的类创建迭代器。默认情况下，您可能不应该确保&arri +1是安全的，因为这将是很难做到的事情(不是返回值，而是返回某种特殊的类，该类保存指针访问的某种重载，然后重载用于添加)。

STL处理安全性的方式是通过使用arr.at( I )这样的成员来获得迭代器，它是一个类，它包含指向任何数据类型的指针，但也有一些额外的功能，可以确保迭代器操作中的某种程度的安全性。

class Array
{
    struct Iterator
    {
        Iterator( Array* array, TYPE* ptr ) : m_ptr( ptr ) {}
        ...
        Iterator operator +( int i ){ 
            if( (m_ptr + i) < m_arr->end() ) 
                return Iterator( m_arr, m_ptr + i ); 
        }
    };
    ...
    Iterator at( unsigned int i ) {
        if( i < m_size )
            return Iterator( this, m_array + i );
    }
}

注意，迭代器有一个指向原始数组类的指针。如果您希望您的迭代器不像您所要求的那样越界，这是必要的，但是STL迭代器不是这样工作的。相反，它们让您检查iterator < array.end()，这样迭代器就不需要知道它们的创建者了。