*
Aber im ernst ... warum net 2d auf 1d blitten?
template<typename value_type>
struct array2
{
typedef value_type value_t;
typedef std::pair<std::size_t, std::size_t> dimension_t;
value_t const& get(const std::size_t x, const std::size_t y) const { return m_data[y * m_size.first + x]; }
value_t& at(const std::size_t x, const std::size_t y) { if (x > m_size.first || y > m_size.second) throw std::out_of_range("index"); return m_data[y * m_size.first + x]; }
value_t& operator()(const std::size_t x, const std::size_t y) { return m_data[y * m_size.first + x]; }
value_t const& operator() (const std::size_t x, const std::size_t y) const { return m_data[y * m_size.first + x]; }
array2(const std::size_t width, const std::size_t height, value_type const& default_value = value_type())
: m_size(std::make_pair(width, height)), m_data(new value_type[width * height](default_value))
{}
~array2() { delete [] m_data; }
array2& operator=(array2 const& rhs)
{
if (this == &rhs) return *this;
delete [] m_data;
m_data = new value_type[rhs.m_size.first * rhs.m_size.second];
m_size = rhs.m_size;
std::copy(m_data, m_data + (m_size.first * m_size.second), rhs.m_data);
return *this;
}
array2(array2 const& rhs)
: m_size(rhs.m_size), m_data(new value_type[rhs.m_size.first * rhs.m_size.second])
{ std::copy(m_data, m_data + (m_size.first * m_size.second), rhs.m_data); }
private:
value_t* m_data;
dimension_t m_size;
};
std::ostream& foo(std::ostream& out, array2<double> const& bar)
{ return out << bar.get(1, 2) }
int main()
{
array2<double> data(10, 10, 1.0);
std::cout << data(0, 1) << std::endl;
std::cout << foo(data) << std::endl;
}
usw. ... ist viel schöner als so nen dummer 2d array ^^ aber noch einfacher:
std::vector< std::vector<double> > data;
_D
