0

我正在尝试制作一个自定义数组切片类，它可以处理任意的，可能是负的跨步，并且想知道如何使用 const 正确性来做到这一点：

#include <vector>
#include <cstdio>

template< typename T >
class ArrayView
{
public:

    ArrayView( void* pointer, int strideInBytes, int length )
    {
        m_pPointer = reinterpret_cast< unsigned char* >( pointer );
        m_strideInBytes = strideInBytes;
        m_length = length;
    }

    const T& operator [] ( int index ) const
    {
        const unsigned char* p = m_pPointer + index * m_strideInBytes;
        return *( reinterpret_cast< const T* >( p ) );
    }

    T& operator [] ( int index )
    {
        unsigned char* p = m_pPointer + index * m_strideInBytes;
        return *( reinterpret_cast< T* >( p ) );
    }

    int length() const
    {
        return m_length;
    }

private:

    unsigned char* m_pPointer;
    int m_strideInBytes;
    int m_length;

};

void printFromReadOnlyView( const ArrayView< int >& view )
{
    for( int i = 0 ; i < view.length(); ++i )
    {
        printf( "%d: %d\n", i, view[i] );
    }
}

void useRef( std::vector< int >& ref )
{
    // works fine
    ArrayView< int > view( ref.data(), sizeof( int ), ref.size() );
    printFromReadOnlyView( view );
}

void useConstRef( const std::vector< int >& constRef )
{
    // const error
    ArrayView< int > view( constRef.data(), sizeof( int ), constRef.size() );
    printFromReadOnlyView( view );
}

int main()
{
    std::vector< int > v( 10 );
    for( int i = 0; i < v.size(); ++i )
    {
        v[i] = i;
    }

    useRef( v );
    useConstRef( v );
}

函数 useConstRef() 会导致编译时错误，因为 constRef.data() 是一个 const 指针，而 ArrayView 的构造函数接受一个非常量指针。

本质上，我希望 ArrayView 是 const（只读）或非常量（读写）。

我可以尝试添加一个接受 const 指针的构造函数，但是我必须存储 const 指针并记住我是哪个版本。我可以只使用一个类，还是必须制作单独的 ReadWriteArrayView 和 ReadOnlyArrayView 版本？

4

0 回答 0