Написать класс «массив».

template< typename T >
class Array
{
    template< typename T >
    friend void swap(T &, T &);
 
public:
    Array();
    Array(size_t);
    Array(const Array &);
    ~Array();
 
    template< typename T >
    friend std::istream &operator>>(std::istream &, Array &);
    template< typename T >
    friend std::ostream &operator<<(std::ostream &, const Array &);
 
    void print(std::ostream & = std::cout) const;
 
    size_t size() const;
    size_t capacity() const;
 
    void resize(size_t);
 
    void push_back(const T &);
 
    void sort();
 
    const Array operator+(const T &) const;
    const Array &operator+=(const T &);
 
    const Array &operator=(const Array &);
 
    template< typename T >
    friend bool operator==(const Array &, const Array &);
 
    const T &operator[](size_t) const;
    T &operator[](size_t);
 
private:
    T *_array;
    size_t _size;
    size_t _capacity;
};
 
template< typename T >
Array< T >::Array():
_array(0),
_size(0),
_capacity(0)
{
}
 
template< typename T >
Array< T >::Array(size_t size):
_size(size),
_capacity(1)
{
    while (_capacity < _size)
        _capacity *= 2;
 
    _array = new T [_capacity];
}
 
template< typename T >
Array< T >::Array(const Array< T > &original):
_size(original._size),
_capacity(original._capacity)
{
    _array = new T [_capacity];
 
    for (size_t i = 0; i < _size; ++i)
        _array[i] = original._array[i];
}
 
template< typename T >
Array< T >::~Array()
{
    delete [] _array;
}
 
template< typename T >
std::istream &operator>>(std::istream &input, Array< T > &rhs)
{
    if (rhs._size != 0)
        for (size_t i = 0; i < rhs._size; ++i)
            input >> rhs._array[i];
 
    return input;
}
 
template< typename T >
std::ostream &operator<<(std::ostream &output, const Array< T > &rhs)
{
    if (rhs._size != 0)
    {
        for (size_t i = 0; i < rhs._size - 1; ++i)
            output << rhs._array[i] << "  ";
 
        output << rhs._array[rhs._size - 1];
    }
 
    return output;
}
 
template< typename T >
void Array< T >::print(std::ostream &output) const
{
    output << *this;
}
 
template< typename T >
size_t Array< T >::size() const
{
    return _size;
}
 
template< typename T >
size_t Array< T >::capacity() const
{
    return _capacity;
}
 
template< typename T >
void Array< T >::resize(size_t new_size)
{
    _capacity = 1;
 
    while (_capacity < new_size)
        _capacity *= 2;
 
    T *new_array = new T [_capacity];
 
    if (_array != 0)
    {
        size_t count = new_size < _size ? new_size : _size;
 
        for (size_t i = 0; i < count; ++i)
            new_array[i] = _array[i];
 
        delete [] _array;
    }
 
    _array = new_array;
    _size = new_size;
}
 
template< typename T >
void Array< T >::push_back(const T &element)
{
    if (_size == _capacity)
    {
        resize(_size + 1);
        --_size;
    }
 
    _array[_size++] = element;
}
 
template< typename T >
void Array< T >::sort()
{
    for (size_t i = 0; i < _size; ++i)
        for (size_t j = _size - 1; j > i; --j)
            if (_array[j - 1] > _array[j])
                swap(_array[j - 1], _array[j]);
}
 
template< typename T >
const Array< T > Array< T >::operator+(const T &rhs) const
{
    Array result(*this);
 
    result.push_back(rhs);
 
    return result;
}
 
template< typename T >
const Array< T > &Array< T >::operator+=(const T &rhs)
{
    push_back(rhs);
 
    return *this;
}
 
template< typename T >
const Array< T > &Array< T >::operator=(const Array &rhs)
{
    if (&rhs != this)
    {
        _size = rhs._size;
        _capacity = rhs._capacity;
 
        delete [] _array;
 
        _array = new T [_capacity];
 
        for (size_t i = 0; i < _size; ++i)
            _array[i] = rhs._array[i];
    }
 
    return *this;
}
 
template< typename T >
bool operator==(const Array< T > &lhs, const Array< T > &rhs)
{
    if (lhs._size != rhs._size)
        return false;
 
    for (size_t i = 0; i < lhs._size; ++i)
        if (lhs._array[i] != rhs._array[i])
            return false;
 
    return true;
}
 
template< typename T >
const T &Array< T >::operator[](size_t index) const
{
    return _array[index];
}
 
template< typename T >
T &Array< T >::operator[](size_t index)
{
    return _array[index];
}
 
template< typename T >
void swap(T &left, T &right)
{
    T temp = left;
    left = right;
    right = temp;
}
 
template< typename T >
class Matrix
{
public:
    Matrix();
    Matrix(size_t, size_t);
    Matrix(const Matrix &);
    ~Matrix();
 
    template< typename T >
    friend std::istream &operator>>(std::istream &, Matrix &);
    template< typename T >
    friend std::ostream &operator<<(std::ostream &, const Matrix &);
 
    void print(std::ostream & = std::cout) const;
 
    void resize(size_t, size_t);
 
    template< typename T >
    friend const Matrix operator+(const Matrix &, const Matrix &);
    const Matrix &operator+=(const Matrix &);
 
    template< typename T >
    friend const Matrix operator-(const Matrix &, const Matrix &);
    const Matrix &operator-=(const Matrix &);
 
    const Matrix &operator=(const Matrix &);
 
    template< typename T >
    friend bool operator==(const Matrix &, const Matrix &);
 
    const Array< T > &operator[](size_t) const;
    Array< T > &operator[](size_t);
 
private:
    Array< T > *_matrix;
    size_t _cols;
    size_t _rows;
};
 
template< typename T >
Matrix< T >::Matrix():
_cols(1),
_rows(1),
_matrix(new Array< T > [1])
{
    _matrix[0] = Array< T > ();
}
 
template< typename T >
Matrix< T >::Matrix(size_t cols, size_t rows):
_cols(cols),
_rows(rows),
_matrix(new Array< T > [rows])
{
    for (size_t i = 0; i < rows; ++i)
        _matrix[i] = Array< T > (cols);
}
 
template< typename T >
Matrix< T >::Matrix(const Matrix &original):
_cols(original._cols),
_rows(original._rows),
_matrix(new Array< T > [original._rows])
{
    for (size_t i = 0; i < _rows; ++i)
    {
        _matrix[i] = Array< T > (original._cols);
 
        for (size_t j = 0; j < _cols; ++j)
            _matrix[i][j] = original._matrix[i][j];
    }
}
 
template< typename T >
Matrix< T >::~Matrix()
{
    delete [] _matrix;
}
 
template< typename T >
std::istream &operator>>(std::istream &input, Matrix< T > &rhs)
{
    for (size_t i = 0; i < rhs._rows; ++i)
        input >> rhs[i];
 
    return input;
}
 
template< typename T >
std::ostream &operator<<(std::ostream &output, const Matrix< T > &rhs)
{
    for (size_t i = 0; i < rhs._rows; ++i)
        output << rhs[i] << std::endl;
 
    return output;
}
 
template< typename T >
void Matrix< T >::print(std::ostream &output) const
{
    output << *this;
}
 
template< typename T >
void Matrix< T >::resize(size_t new_cols, size_t new_rows)
{
    size_t temp_rows = new_rows < _rows ? new_rows : _rows;
    Array< T > *new_matrix = new Array< T > [new_rows];
 
    for (size_t i = 0; i < temp_rows; ++i)
        new_matrix[i] = _matrix[i];
 
    for (size_t i = 0; i < new_rows; ++i)
        new_matrix[i].resize(new_cols);
 
    _cols = new_cols;
    _rows = new_rows;
 
    delete [] _matrix;
 
    _matrix = new_matrix;
}
 
template< typename T >
const Matrix< T > operator+(const Matrix< T > &lhs, const Matrix< T > &rhs)
{
    Matrix< T > result;
 
    if (lhs._cols == rhs._cols && lhs._rows == rhs._rows)
    {
        result.resize(lhs._cols, lhs._rows);
 
        for (size_t i = 0; i < lhs._rows; ++i)
            for (size_t j = 0; j < lhs._cols; ++j)
                result._matrix[i][j] = lhs._matrix[i][j] + rhs._matrix[i][j];
    }
 
    return result;
}
 
template< typename T >
const Matrix< T > &Matrix< T >::operator+=(const Matrix< T > &rhs)
{
    return (*this = *this + rhs);
}
 
template< typename T >
const Matrix< T > operator-(const Matrix< T > &lhs, const Matrix< T > &rhs)
{
    Matrix< T > result;
 
    if (lhs._cols == rhs._cols && lhs._rows == rhs._rows)
    {
        result.resize(lhs._cols, lhs._rows);
 
        for (size_t i = 0; i < lhs._rows; ++i)
            for (size_t j = 0; j < lhs._cols; ++j)
                result._matrix[i][j] = lhs._matrix[i][j] - rhs._matrix[i][j];
    }
 
    return result;
}
 
template< typename T >
const Matrix< T > &Matrix< T >::operator-=(const Matrix< T > &rhs)
{
    return (*this = *this - rhs);
}
 
template< typename T >
const Matrix< T > &Matrix< T >::operator=(const Matrix< T > &rhs)
{
    if (this != &rhs)
    {
        if (_rows != rhs._rows)
        {
            delete [] _matrix;
 
            _matrix = new Array< T > [rhs._rows];
        }
 
        _cols = rhs._cols;
        _rows = rhs._rows;
 
        for (size_t i = 0; i < _rows; ++i)
            _matrix[i] = rhs._matrix[i];
    }
 
    return *this;
}
 
template< typename T >
bool operator==(const Matrix< T > &lhs, const Matrix< T > &rhs)
{
    if (lhs._rows != rhs._rows)
        return false;
 
    for (size_t i = 0; i < lhs._rows; ++i)
        if (!(lhs._matrix[i] == rhs._matrix[i]))
            return false;
 
    return true;
}
 
template< typename T >
const Array< T > &Matrix< T >::operator[](size_t index) const
{
    return _matrix[index];
}
 
template< typename T >
Array< T > &Matrix< T >::operator[](size_t index)
{
    return _matrix[index];
}