如何在C ++中使用模板更有效地实现带有边界约束的2D数组？

Question

Now I implement it like this:

template <typename T>
class Array2D{
  private:
    T **pointer = nullptr;
    int n1, n2;
    class tmp{
        private:
            T* pointer;
            int n;
        public:
            tmp(T* p, int n):pointer(p),n(n){}
            T& operator[](unsigned int x){
                assert(x<n);
                return pointer[x];
            }
    };
  public:
    Array2D(int n, int m):n1(n), n2(m){
        pointer = new T *[n];
        for (int i = 0; i < n; i++)
            pointer[i] = new T[m];
    }
    ~Array2D(){delete[] pointer;}
    tmp&& operator[](unsigned int x){
        assert(x < n1);
        return move(tmp(pointer[x], n2));
    }
};

I feel that the code a little bit ugly. The reason why I use tmp class is that if it return T* directly in the class Array2D, it could not check the bounce in the second dimension. So I add a class named temporary. But I feel the effiency get worse for this class. Is there a better solution?

And another thing confuses me. I want others could use this class only in two dimension form. I mean that if you only use a [] to a instance of this class, you will get an error. So I put class tmp in the private section. But I find it can not work. Is there a solution?

Answer 1

The existence of tmp is fine, any compiler will optimize these temporary instances away.

Preventing the use of a single [] cannot be enforced, but you can trigger warnings by using [[nodiscard]] on the return value from Array2D::operator[] .

There is, however, a bug in your implementation: you're returning a dangling reference from your operator[] . Just do:

tmp operator[](unsigned int x){
    assert(x < n1);
    return tmp(pointer[x], n2);
}

Finally, you shouldn't go through the hassle of managing the storage's lifetime manually. In fact, there's already several other bugs there: your destructor leaks memory, and your class doesn't obey the rule of 5, so copying or assigning Array2D 's will lead to UB. Just use a std::vector<std::vector<T>> , or better yet (for contiguity) a single std::vector<T> which you split into rows.

Closing note: once your code works and is ready to be shown, you can take it for a walk at Code Review .

Answer 2

One option would be not to use the subscript operator at all and just have an at function which takes both indexes. This would also be more consistent with the standard library containers which perform bounds checking in the at functions.

For example:

template < typename T >
class Array2D
{
public:
    Array2D(size_t m, size_t n)
    : data( m, std::vector< T >( n, T() ) )
    {
    }

    T& at( size_t x, size_t y )
    {
        return data.at( x ).at( y );
    }

    const T& at( size_t x, size_t y ) const
    {
        return data.at( x ).at( y );
    }
private:
    std::vector<std::vector<T>> data;
};

Using std::vector to store your data gives:

1. fixes rule of 5 bugs
2. manages all memory allocation for you
3. implements the bounds checking for you

The less code you write and the more you rely on the standard library the fewer bugs you'll create (generally).

You can use the subscript operator with a non-integral type, for example if you use std::pair< size_t, size_t > you can implement it like this:

T& operator [] ( std::pair<size_t, size_t> p )
{
    return data.at( p.first ).at( p.second );
}

T& operator [] ( std::pair<size_t, size_t> p ) const
{
    return data.at( p.first ).at( p.second );
}

And call it like this:

Array2D< int > a( 10, 20 );
a[{5,5}] = 10;
std::cout << a[{5,5}] << "\n";