Re: Can we override [][] ?
Earl Purple wrote:
Axter wrote:
If you think your comments are constructive, then you're either
ignorant, or have no manners. IMHO, it's most likely both.
This is becoming too much of a flame war. But there was some
constructive criticism in there. Let me see if I can point it out:
template < class T>
class dynamic_2d_array
{
public:
dynamic_2d_array(size_t row, size_t col):m_row(row),m_col(col),
m_data((row!=0&&col!=0)?new T[row*col]:NULL){}
dynamic_2d_array(const
dynamic_2d_array&src):m_row(src.m_row),m_col(src.m_col),
m_data((src.m_row!=0&&src.m_col!=0)?new T[src.m_row*src.m_col]:NULL){
for(size_t r=0;r<m_row;++r)for(size_t c=0;c<m_col;++c) (*this)[r][c]
= src[r][c];
}
~dynamic_2d_array(){if(m_data) delete []m_data;}
inline T* operator[](size_t i) {return (m_data + (m_col*i));}
inline T const*const operator[](size_t i) const {return (m_data +
(m_col*i));}
protected:
dynamic_2d_array& operator=(const dynamic_2d_array&);
private:
const size_t m_row;
const size_t m_col;
T* m_data;
};
1. No method to retrieve back the dimensions. Easy enough to modify.
Add in:
size_t rows() const { return m_row; }
size_t cols() const { return m_col }
As I previously stated, the sole purpose of the dynamic_2d_array, is to
give the functionallity of a static size C-Style array that has a
dynamic size.
Since this is easy to add, IMHO, it's not needed for the example.
2. protected section when class cannot be inherited. Minor detail but
operator= is automatically disabled for this class anyway due to it
having const members.
Good point.
3. no need to check for NULL in destructor
Another good point.
4. To access the data you call matrix[0] which is unclear notation.
I'm not sure what you mean there. Accessing an array via [][] is the
standard notation for C/C++ code.
5. Your copy constructor is probably slower than you think as you are
calculating the position a lot of times. But as the arrays are
identical in size you can do member-by-member copy.
I think it would be hard to measure the perfromance difference, but
considering it could simplify the class, it would probably be a good
idea to do a std::copy instead of the two loops.
If you're really
advanced you'll have an is_pod<> traits-style function and use memcpy
when is_pod returns true.
I rather keep the class generic, and not have to rely on external
functions like boost::is_pod. I don't like creating generic code that
depends on third party libraries, even if it is boost.
You would be surprise at how many C++ developers don't even know what
boost is.
If you use a nested vector then resizing can be done with vector's
member resize() function.
I posted another link that had example code that does just that.
http://www.codeguru.com/forum/showthread.php?t=231046
The above class has a resize functoin, which I added, and it uses
vector.
I recomend using the above vector approach over my original
dynamic_2d_array class.
But if you need contiguous buffer, then the dynamic_2d_array might be a
better option.
Thanks for the constructive critique. I've already removed the op= and
the unnecessary check for NULL.