Реализация классов вектор и строка

#include <iostream>
#include <stdexcept>
#include <utility>
using std::rel_ops::operator!=;
using std::rel_ops::operator>;
using std::rel_ops::operator<=;
using std::rel_ops::operator>=;
 
template <typename T> 
class mvector
{
public:
    typedef size_t size_type;
    typedef T value_type;
    typedef T *pointer;
    typedef const T *const_pointer;
    typedef T& reference;
    typedef const T& const_reference;
    typedef T* iterator;
    typedef const T* const_iterator; 
    explicit mvector();
    explicit mvector( size_type, const T& val = T() );
    mvector( const mvector<T>& );
    mvector( iterator, iterator );
    ~mvector();
    size_type size() const;
    size_type capacity() const;
    void resize( size_type, T = T() );
    void assign( iterator first, iterator last );
    void assign (size_type n, const T& u );
    void push_back( const T& );
    void pop_back();
    iterator erase( iterator );
    iterator erase( iterator, iterator );
    iterator insert( iterator, const T& );
    void insert( iterator, size_type, const T& );
    void insert( iterator, iterator, iterator );
    void clear();
    void swap( mvector<T>& ); 
    T& front();
    T& back();
    T& at( size_type );
    const T& at( size_type ) const;
    bool empty() const;
    const mvector& operator= ( const mvector& );
    const T& operator[] ( size_type ) const;
    T& operator[] ( size_type );
    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;
private:
    size_type _size;    
    size_type _capacity;    
    T *_arr;
};
 
template <typename T>
mvector<T>::mvector():
_size( 0 ), _capacity( 2*_size ), _arr( nullptr )
{
}   
 
template <typename T>
mvector<T>::mvector( size_type num, const T& val ):
_size( num ), _capacity( 2*_size ), _arr( new T[_capacity] )
{
    for ( size_type i = 0; i != _size; ++i )
        _arr[i] = val;
}
 
template <typename T>
mvector<T>::mvector( const mvector<T>& c ):
_size( c._size ), _capacity( c._capacity ), _arr( new T[_capacity] )
{
    for ( size_type i = 0; i != _size; ++i )
        _arr[i] = c._arr[i];
}
 
template <typename T>
mvector<T>::mvector( iterator start, iterator end ):
_size( end - start ), _capacity( 2*_size ), _arr( new T[_capacity] )
{
    for ( size_type i = 0; i != _size && start != end; ++i )
        _arr[i] = *start++;
}
 
template <typename T>
mvector<T>::~mvector()
{
    delete [] _arr;
}
 
template <typename T>
typename mvector<T>::size_type mvector<T>::size() const
{
    return _size;
}
 
template <typename T>
typename mvector<T>::size_type mvector<T>::capacity() const
{
    return _capacity;
}
 
template <typename T>
void mvector<T>::resize( size_type _new_size, T c )
{
    _capacity = 2 * _new_size;
    T *_new_arr = new T[_capacity];
    for ( size_type i = 0; i != std::min( _size, _new_size ); ++i )
        _new_arr[i] = _arr[i];
    for ( size_type i = std::min( _size, _new_size ); i != _new_size; ++i )
        _new_arr[i] = c;
 
    delete [] _arr;
    _size = _new_size;  
    _arr = _new_arr;
}
 
template <typename T>
void mvector<T>::assign( iterator first, iterator last )
{
    delete [] _arr;
    _size = last - first;
    _capacity = 2*_size;
    _arr = new T[_capacity];
    for ( size_type i = 0; i != _size && first != last; ++i )
        _arr[i] = *first++;
}
 
template <typename T>
void mvector<T>::assign( size_type n, const T& u )
{
    delete [] _arr;
    _size = n;
    _capacity = 2*_size;
    _arr = new T[_capacity];
    for ( size_type i = 0; i != _size; ++i )
        _arr[i] = u;
}
 
template <typename T>
void mvector<T>::push_back( const T& val )
{
    if ( _size == _capacity )
    {
        resize( _size + 1 );
        --_size;
    }
 
    _arr[_size++] = val;
}
 
template <typename T>
void mvector<T>::pop_back()
{
    if ( _size > 0 )
        --_size;
}
 
template <typename T>
typename mvector<T>::iterator mvector<T>::erase( iterator position )
{
    for ( iterator i = position; i != end(); ++i )
        *i = *( i + 1 );
    --_size;
    return position;
}
 
template <typename T>
typename mvector<T>::iterator mvector<T>::erase( iterator first, iterator last )
{
    size_type beg = first - begin();
    size_type end = last - begin();     
    size_type _new_size = _size - end + beg;
    size_type _new_capacity = 2 * _new_size;
 
    T *_new_arr = new T[_new_capacity];
 
    for ( size_type i = 0; i != beg; ++i )
        _new_arr[i] = _arr[i];
 
    for ( size_type i = beg, j = end; j != _size; ++i, ++j )
        _new_arr[i] = _arr[j];
 
    delete [] _arr;
 
    _size = _new_size;
    _capacity = _new_capacity;
    _arr = _new_arr;
    return begin() + beg;
}
 
template <typename T>
typename mvector<T>::iterator mvector<T>::insert( iterator position, const T& x )
{
    size_type tmp = position - begin();
    if ( _size + 1 > _capacity )
        resize( _size + 1 );
    else
        ++_size;
    position = begin() + tmp;
    for ( iterator i = end() - 1; i != position; --i )
        *i = *( i - 1 );
    *position = x;
    return position;
}
 
template <typename T>
void mvector<T>::insert( iterator position, size_type n, const T& x )
{
    size_type tmp = position - begin();
    if ( _size + n > _capacity )
        resize( _size + n );
    else
        _size += n;
    position = begin() + tmp;
    for ( iterator i = end() - 1; i != position + n - 1; --i )
        *i = *( i - n );
    for ( iterator i = position; i != position + n; ++i )
        *i = x;
}
 
template <typename T>
void mvector<T>::insert( iterator position, iterator first, iterator last )
{
    size_type tmp = position - begin();
    size_type n = last - first;
    if ( _size + n > _capacity )
        resize( _size + n );    
    else
        _size += n;
    position = begin() + tmp;
    for ( iterator i = end() - 1; i != position + n - 1; --i )
        *i = *( i - n );
    for ( iterator i = position; i != position + n && first != last; ++i )
        *i = *first++;
}
 
template <typename T>
void mvector<T>::clear() 
{
    delete [] _arr;
    _arr = nullptr;
    _size = 0;
    _capacity = 0;
}
 
template <typename T>
void mvector<T>::swap( mvector<T>& c ) 
{ 
    if ( *this != c )
    {
        std::swap( _size, c._size );
        std::swap( _capacity, c._capacity );
        std::swap( _arr, c._arr );
    }
}
 
template <typename T>
T& mvector<T>::at( size_type index )
{
    if ( index >= _size )
        throw std::out_of_range( "Expression: vector subscript out of range." );
    return _arr[index];
}
 
template <typename T>
const T& mvector<T>::at( size_type index ) const
{
    if ( index >= _size )
        throw std::out_of_range( "Expression: vector subscript out of range." );
    return _arr[index];
}
 
template <typename T>
T& mvector<T>::front()
{
    return at( 0 );
}
 
template <typename T>
T& mvector<T>::back()
{
    return at( _size - 1 );
}
 
template <typename T>
bool mvector<T>::empty() const
{
    return _size == 0;
}
 
template <typename T>
const mvector<T>& mvector<T>::operator= ( const mvector<T>& c )
{
    if ( *this != c )
    {
        _size = c._size;
        _capacity = c._capacity;
        delete [] _arr;
        _arr = new T[_capacity];
        for ( size_type i = 0; i != c._size; ++i )
            _arr[i] = c._arr[i];
    }
 
    return *this;
}
 
template <typename T>
const T& mvector<T>::operator[] ( size_type n ) const
{
    return _arr[n];
}
 
template <typename T>
T& mvector<T>::operator[] ( size_type n )
{   
    return _arr[n];
}
 
template <typename T>
bool operator== ( const mvector<T>& c1, const mvector<T>& c2 )
{
    if (c1.size() != c2.size())
        return false;
    else
    {
        for ( int i = 0; i != c1.size(); ++i )
            if ( c1[i] != c2[i] )
                return false;
    }
    return true;
}
 
template <typename T>
bool operator< ( const mvector<T>& c1, const mvector<T>& c2 )
{
    if (c1.size() != c2.size())
        return c1.size() < c2.size();
    else
    {
        for ( int i = 0; i != c1.size(); ++i )
            if ( c1[i] != c2[i] )
                return c1[i] < c2[i];
    }
    return false;
}
 
template <typename T>
typename mvector<T>::iterator mvector<T>::begin()
{
    return _arr; 
}
 
template <typename T>
typename mvector<T>::const_iterator mvector<T>::begin() const 
{
    return _arr; 
}
 
template <typename T>
typename mvector<T>::iterator mvector<T>::end() 
{
    return _arr + _size;
}
 
template <typename T>
typename mvector<T>::const_iterator mvector<T>::end() const 
{ 
    return _arr + _size; 
}

#include <iostream>
#include <stdexcept>
#include <utility>
using std::rel_ops::operator!=;
using std::rel_ops::operator>;
using std::rel_ops::operator<=;
using std::rel_ops::operator>=;
 
class mstring
{
public:
    typedef size_t size_type;
    typedef char value_type;
    typedef char* pointer;
    typedef const char* const_pointer;
    typedef char& reference;
    typedef const char& const_reference;
    typedef char* iterator;
    typedef const char* const_iterator; 
    static const size_type npos = -1;
    mstring();
    mstring( const mstring& );
    mstring( size_type, char );
    mstring( const char* );
    mstring( const char* str, size_type length );
    mstring( const mstring&, size_type, size_type length = npos );
    mstring( iterator, iterator );
    ~mstring(); 
    friend bool operator== ( const mstring&, const mstring& );
    friend bool operator< ( const mstring&, const mstring& );
    char& at( size_type );
    const char& at( size_type ) const;
    char& operator[] ( size_type );
    const char& operator[] ( size_type ) const;
    mstring& operator= ( const mstring& );
    mstring& operator= ( const char* );
    mstring& operator= ( char );
    friend std::ostream& operator<< ( std::ostream&, const mstring& );
    friend std::istream& operator>> ( std::istream&, mstring& );
    mstring& operator+= ( const mstring& );
    mstring& operator+= ( const char* );
    mstring& operator+= ( const char ); 
    friend mstring operator+ ( const mstring&, const mstring& );
    friend mstring operator+ ( const char*, const mstring& );
    friend mstring operator+ ( char, const mstring& );
    friend mstring operator+ ( const mstring&, const char* );
    friend mstring operator+ ( const mstring&, char );
    mstring& append( const mstring& );
    mstring& append( const char* );
    mstring& append( const mstring&, size_type, size_type );
    mstring& append( const char*, size_type );
    mstring& append( size_type, char );
    mstring& append( iterator, iterator );
    mstring& assign( iterator, iterator );
    mstring& assign( const mstring& );
    mstring& assign( const char* );
    mstring& assign( const char*, size_type );
    mstring& assign( const mstring&, size_type, size_type );
    mstring& assign( size_type, char );
    iterator erase( iterator );
    iterator erase( iterator, iterator );
    mstring& erase( size_type index = 0, size_type num = npos );    
    iterator insert( iterator, char );
    mstring& insert( size_type, const mstring& );
    mstring& insert( size_type, const char* );
    mstring& insert( size_type, const mstring&, size_type, size_type );
    mstring& insert( size_type, const char*, size_type );
    mstring& insert( size_type, size_type, char );
    void insert( iterator, size_type, char );
    void insert( iterator, iterator, iterator );
    void insert( iterator, const_iterator, const_iterator );    
    size_type find( const mstring&, size_type index = 0 ) const;
    size_type find( const char*, size_type index = 0 ) const;
    size_type find( const char*, size_type, size_type ) const;
    size_type find( char, size_type index = 0 ) const;
    const char * data() const;
    char * c_str() const;
    mstring substr( size_type index = 0, size_type length = npos ) const;   
    size_type copy( char*, size_type, size_type index = 0 ) const;
    void resize( size_type );
    void push_back( const char& );
    void pop_back();
    void clear();
    void swap( mstring& );
    char& front();
    char& back();
    bool empty() const;
    int compare( const mstring& ) const;
    int compare( const char* ) const;
    int compare( size_type, size_type, const mstring& ) const;
    int compare( size_type, size_type, const char* s ) const;
    int compare( size_type, size_type, const mstring& str, 
        size_type, size_type ) const;
    int compare( size_type, size_type, const char*, size_type ) const;
    size_type length() const;
    size_type size() const;
    size_type capacity() const; 
    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;
private:
    size_type _len;
    size_type _capacity;
    char *_arr;
};
 
mstring::size_type _mstrlen( const char *str )
{ 
    mstring::size_type res = 0;
    while( *str++ )
        res++;
    return res;
}
 
char * _mstrcpy( char *dst, const char *src )
{
    char *res = dst;
    while( (*dst++ = *src++) );
    return res; 
}
 
char * _mstrncpy( char *dst, const char *src, mstring::size_type len )
{
    char *res = dst;
    while( len-- && ( *dst++ = *src++ ) );
    if ( *dst )
        *dst = '\0';
    return res; 
}
 
char * _mstrcat( char *str1, const char *str2 )
{
    char *res = str1;
    while( *str1 ) 
        str1++;
    while( (*str1++ = *str2++) );
    return res;
}
 
char * _mstrncat(char *str1, const char *str2, mstring::size_type count)
{
    char *res = str1;
    while(*str1) 
        str1++;
    while(count-- && (*str1++ = *str2++));
    if (*str1) 
        *str1 = '\0';
    return res;
}
 
int _mstrcmp( const char *str1, const char *str2 )
{
    while( ( unsigned char )*str1 == ( unsigned char )*str2 && *str1 )
    {
        str1++;
        str2++;
    }
    return ( int )*str1 - ( int )*str2;
}
 
int _mstrncmp( const char *str1, const char *str2, size_t count )
{
    while( --count && ( ( unsigned char )*str1 == ( unsigned char )*str2 ) && *str1 )
    {
        str1++;
        str2++;
    }
    return ( int )*str1 - ( int )*str2;
}
 
char * _mstrnset( char *str, int c, mstring::size_type n )
{
    char *res = str;
    if ( n > _mstrlen( str ) ) 
        n = _mstrlen( str );
    for( mstring::size_type i = 0; i != n; ++i )
        *str++ = c;
    return res;
}
 
char * _mstrstr( const char *str1, const char *str2 )
{
    mstring::size_type l1 = _mstrlen( str1 ), l2 = _mstrlen( str2 );
    for ( mstring::size_type i = 0; i != l1 - l2 + 1; ++i )
    {
        mstring::size_type f = 0;
        for ( mstring::size_type j = 0; j != l2; ++j )
        {
            if ( str1[i + j] == str2[j] ) 
                f++; 
            else 
                break;
        }
        if ( f == l2 ) 
            return ( char* const )str1 + i;
    }
    if ( l2 )
        return nullptr;
    else 
        return ( char* const )str1;
} 
 
char * _mstrnstr( const char *str1, const char *str2, mstring::size_type length1 )
{
    mstring::size_type l1 = length1, l2 = _mstrlen( str2 );
    for ( mstring::size_type i = 0; i != l1 - l2 + 1; ++i )
    {
        mstring::size_type f = 0;
        for ( mstring::size_type j = 0; j != l2; ++j )
        {
            if ( str1[i + j] == str2[j] ) 
                f++; 
            else 
                break;
        }
        if ( f == l2 ) 
            return ( char* const )str1 + i;
    }
    if ( l2 )
        return nullptr;
    else 
        return ( char* const )str1;
} 
 
mstring::mstring():
_len( 0 ), _capacity( 2*_len+1 ), _arr( new char[_capacity] )
{
    *_arr = '\0';
}
 
mstring::mstring( const mstring& s ):
_len( s._len ), _capacity( 2*_len+1 ), _arr( new char[_capacity] )
{
    _mstrcpy( _arr, s._arr );
}
 
mstring::mstring( size_type length, char ch ):
_len( length ), _capacity( 2*_len+1 ), _arr( new char[_capacity] )
{
    _mstrnset( _arr, ch, length );
}
 
mstring::mstring( const char* str ):
_len( _mstrlen( str ) ), _capacity( 2*_len+1 ), _arr( new char[_capacity] )
{
    _mstrcpy( _arr, str );
}
 
mstring::mstring( const char* str, size_type length ):
_len( std::min( length, _mstrlen( str ) ) ), 
    _capacity( 2*_len+1 ), _arr( new char[_capacity] )
{
    _mstrncpy( _arr, str, std::min( length, _mstrlen( str ) ) );
}
 
mstring::mstring( const mstring& str, size_type index, size_type length ):
_len( std::min( length, str._len ) - index ), 
    _capacity( 2*_len+1 ), _arr( new char[_capacity] )
{
    _mstrncpy( _arr, str._arr + index, std::min( length, str._len ) );
}
 
mstring::mstring( iterator start, iterator end ):
_len( end - start ), _capacity( 2*_len+1 ), _arr( new char[_capacity] )
{
    _mstrncpy( _arr, start, end - start );
}
 
mstring::~mstring()
{
    delete [] _arr;
}
 
bool operator== ( const mstring& c1, const mstring& c2 )
{
    return _mstrcmp( c1._arr, c2._arr ) == 0;
}
 
bool operator< ( const mstring& c1, const mstring& c2 )
{
    return _mstrcmp( c1._arr, c2._arr ) < 0;
}
 
char& mstring::at( size_type index )
{
    if ( index >= _len )
        throw std::out_of_range( "Expression: string subscript out of range." );
    return _arr[index];
}
 
const char& mstring::at( size_type index ) const
{
    if ( index >= _len )
        throw std::out_of_range( "Expression: string subscript out of range." );
    return _arr[index];
}
 
char& mstring::operator[] ( size_type index )
{
    return at( index );
}
 
const char& mstring::operator[]( size_type index ) const
{
    return at( index );
}
 
mstring& mstring::operator= ( const mstring& s )
{
    if ( *this != s )
    {
        _len = s._len;
        _capacity = s._capacity;
        delete [] _arr;
        _arr = new char[_capacity];
        _mstrcpy( _arr, s._arr );       
    }
 
    return *this;
}
 
mstring& mstring::operator= ( const char* s )
{
    if ( this->_arr != s )
    {
        _len = _mstrlen( s );
        _capacity = 2*_len+1;
        delete [] _arr;
        _arr = new char[_capacity];
        _mstrcpy( _arr, s );        
    }
 
    return *this;
}
 
mstring& mstring::operator= ( char ch )
{
    delete [] _arr;
    _len = 1;
    _capacity = 2*_len+1;
    _arr = new char[_capacity];
    *_arr = ch;
    *( _arr+1 ) = '\0';
    return *this;
}
 
std::ostream& operator<< ( std::ostream& out, const mstring& s )
{
    out << s._arr;
    return out;
}
 
std::istream& operator>> ( std::istream& in, mstring& s )
{
    char tmp[4096];
    in >> tmp;
    s = in ? tmp : mstring();
    return in;
}
 
mstring& mstring::operator+= ( const mstring& append )
{
    resize( _len + append._len + 1 );
    _mstrcat( _arr, append._arr );
    return *this;
}
 
mstring& mstring::operator+= ( const char* append )
{
    resize( _len + _mstrlen( append ) + 1 );
    _mstrcat( _arr, append );
    return *this;
}
 
mstring& mstring::operator+= ( const char append )
{
    push_back( append );
    return *this;
}
 
mstring operator+ ( const mstring& lhs, const mstring& rhs )
{
    mstring ret( lhs );
    ret += rhs;
    return ret;
}
 
mstring operator+ ( const char* lhs, const mstring& rhs )
{
    mstring ret( lhs );
    ret += rhs;
    return ret;
}
 
mstring operator+ ( char lhs, const mstring& rhs )
{
    mstring ret( 1, lhs );
    ret += rhs;
    return ret;
}
 
mstring operator+ ( const mstring& lhs, const char* rhs )
{
    mstring ret( lhs );
    ret += rhs;
    return ret;
}
 
mstring operator+ ( const mstring& lhs, char rhs )
{
    mstring ret( lhs );
    ret += rhs;
    return ret;
}
 
mstring& mstring::append( const mstring& str )
{
    _mstrcat( _arr, str._arr );
    return *this;
}
 
mstring& mstring::append( const char* str )
{
    _mstrcat( _arr, str );
    return *this;
}
 
mstring& mstring::append( const mstring& str, size_type index, size_type len )
{
    _mstrncat( _arr, str._arr + index, len );
    return *this;
}
 
mstring& mstring::append( const char* str, size_type num )
{
    _mstrncat( _arr, str, num );
    return *this;
}
 
mstring& mstring::append( size_type num, char ch )
{
    *this += mstring( num, ch );
    return *this;
}
 
mstring& mstring::append( iterator start, iterator end )
{
    _mstrncat( _arr, start, end - start );
    return *this;
}
 
mstring& mstring::assign( iterator start, iterator end )
{
    delete [] _arr;
    _len = end - start;
    _capacity = 2*_len+1;
    _arr = new char[_capacity];
    _mstrncpy( _arr, start, end - start );
    return *this;
}
mstring& mstring::assign( const mstring& str )
{
    *this = str;
    return *this;
}
mstring& mstring::assign( const char* str )
{
    *this = str;
    return *this;
}
 
mstring& mstring::assign( const char* str, size_type num )
{
    delete [] _arr;
    _len = num;
    _capacity = 2*_len+1;
    _arr = new char[_capacity];
    _mstrncpy( _arr, str, num );
    return *this;
}
 
mstring& mstring::assign( const mstring& str, size_type index, size_type len )
{
    delete [] _arr;
    _len = str._len;
    _capacity = 2*_len+1;
    _arr = new char[_capacity];
    _mstrncpy( _arr, str._arr + index, len );
    return *this;
}
 
mstring& mstring::assign( size_type num, char ch )
{
    *this = mstring(num, ch); 
    return *this;
}
 
mstring::iterator mstring::erase( iterator position )
{
    for ( iterator i = position; i != end(); ++i )
        *i = *( i + 1 );
    --_len;
    return position;
}
 
mstring::iterator mstring::erase( iterator first, iterator last )
{
    size_type beg = first - begin();
    size_type end = last - begin();     
    size_type _new_len = _len - end + beg;
    size_type _new_capacity = 2 * _new_len + 1;
 
    char *_new_arr = new char[_new_capacity];
 
    for ( size_type i = 0; i != beg; ++i )
        _new_arr[i] = _arr[i];
 
    for ( size_type i = beg, j = end; j != _len + 1; ++i, ++j )
        _new_arr[i] = _arr[j];
 
    delete [] _arr;
 
    _len = _new_len;
    _capacity = _new_capacity;
    _arr = _new_arr;
    return begin() + beg;
}
 
mstring& mstring::erase( size_type index, size_type num )
{
    num = std::min( num, _len - index );
    erase( begin() + index, begin() + index + num );
    return *this;
}
 
mstring::iterator mstring::insert( iterator p, char c )
{
    size_type tmp = p - begin();
    if ( _len + 1 > _capacity )
        resize( _len + 1 );
    else
        ++_len;
    p = begin() + tmp;
    for ( iterator i = end(); i != p; --i )
        *i = *( i - 1 );
    *p = c;
    return p;
}
 
void mstring::insert( iterator p, size_t n, char c )
{
    size_type tmp = p - begin();
    if ( _len + n > _capacity )
        resize( _len + n );
    else
        _len += n;
    p = begin() + tmp;
    for ( iterator i = end(); i != p + n - 1; --i )
        *i = *( i - n );
    for ( iterator i = p; i != p + n; ++i )
        *i = c;
}
 
void mstring::insert( iterator p, iterator first, iterator last )
{
    size_type tmp = p - begin();
    size_type n = last - first;
    if ( _len + n > _capacity )
        resize( _len + n ); 
    else
        _len += n;
    p = begin() + tmp;
    for ( iterator i = end(); i != p + n - 1; --i )
        *i = *( i - n );
    for ( iterator i = p; i != p + n && first != last; ++i )
        *i = *first++;
}
 
void mstring::insert( iterator p, const_iterator first, const_iterator last )
{
    size_type tmp = p - begin();
    size_type n = last - first;
    if ( _len + n > _capacity )
        resize( _len + n ); 
    else
        _len += n;
    p = begin() + tmp;
    for ( iterator i = end(); i != p + n - 1; --i )
        *i = *( i - n );
    for ( iterator i = p; i != p + n && first != last; ++i )
        *i = *first++;
}
 
mstring& mstring::insert ( size_t pos1, const mstring& str )
{
    insert( begin() + pos1, str.begin(), str.end() );
    return *this;
}
 
mstring& mstring::insert ( size_t pos1, const mstring& str, size_t pos2, size_t n )
{
    insert( begin() + pos1, str.begin() + pos2, str.begin() + n );
    return *this;
}
 
mstring& mstring::insert ( size_t pos1, const char* s, size_t n)
{
    insert( begin() + pos1, s, s + n );
    return *this;
}
 
mstring& mstring::insert ( size_t pos1, const char* s )
{
    insert( begin() + pos1, s, s + _mstrlen(s) );
    return *this;
}
 
mstring& mstring::insert ( size_t pos1, size_t n, char c )
{
    insert( begin() + pos1, n, c );
    return *this;
}
 
mstring::size_type mstring::find( const mstring& str, size_type index ) const
{
    pointer ptr = _mstrstr( _arr + index, str._arr );
    if (ptr != nullptr)
        return ptr - begin();
    else
        return npos;
}
 
mstring::size_type mstring::find( const char* str, size_type index ) const
{
    pointer ptr = _mstrstr( _arr + index, str );
    if (ptr != nullptr)
        return ptr - begin();
    else
        return npos;
}
 
mstring::size_type mstring::find( const char* str, size_type index,
    size_type length ) const
{
    pointer ptr = _mstrnstr( _arr + index, str , length);
    if (ptr != nullptr)
        return ptr - begin();
    else
        return npos;
}
 
mstring::size_type mstring::find( char ch, size_type index ) const
{
    for ( size_type i = index; i != _len; ++i )
    {
        if ( _arr[i] == ch ) 
            return i;
    }
    return npos;
}
 
const char * mstring::data() const
{
    return _arr;
}
 
char * mstring::c_str() const
{
    return _arr;
}
 
mstring mstring::substr( size_type index, size_type length ) const
{
    mstring res( this->_arr, index, length );
    return res;
}
 
mstring::size_type mstring::copy( char* str, size_type num, size_type index ) const
{
    _mstrncpy( str, _arr + index, num );
    return num - index;
}
 
void mstring::resize( size_type _new_len )
{
    _capacity = 2 * _new_len + 1;
    char *_new_arr = new char[_capacity];
    _mstrcpy( _new_arr, _arr );
    delete [] _arr;
    _len = _new_len;
    _arr = _new_arr;
}
 
void mstring::push_back( const char& val )
{
    if ( _len == _capacity )
    {
        resize( _len + 1 );
        --_len;
    }
 
    _arr[_len++] = val;
}
 
void mstring::pop_back()
{
    if ( _len > 0 )
        --_len;
}
 
void mstring::clear() 
{
    delete [] _arr;
    _len = 0;
    _capacity = 2*_len+1;
    _arr = new char[_capacity];
    *_arr = '\0';
}
 
void mstring::swap( mstring& c ) 
{ 
    if ( *this != c )
    {
        std::swap( _len, c._len );
        std::swap( _capacity, c._capacity );
        std::swap( _arr, c._arr );
    }
}
 
char& mstring::front()
{
    return at( 0 );
}
 
char& mstring::back()
{
    return at( _len - 2 );
}
 
bool mstring::empty() const
{
    return _len == 0;
}
 
int mstring::compare( const mstring& str ) const
{
    return _mstrcmp( this->_arr, str._arr );
}
 
int mstring::compare( const char* s ) const
{
    return _mstrcmp( this->_arr, s );
}
 
int mstring::compare( size_type pos1, size_type n1, const mstring& str ) const
{
    return _mstrncmp( this->_arr+pos1, str._arr, n1 - pos1 );
}
 
int mstring::compare( size_type pos1, size_type n1, const char* s ) const
{
    return _mstrncmp( this->_arr+pos1, s, n1 - pos1 );
}
 
int mstring::compare( size_type pos1, size_type n1,
    const mstring& str, size_type pos2, size_type n2 ) const
{
    return _mstrncmp( this->_arr+pos1, str._arr+pos2, 
        std::min( n1 - pos1, n2 - pos2 ) );
}
 
int mstring::compare( size_type pos1, size_type n1, 
    const char* s, size_type n2 ) const
{
    return _mstrncmp( this->_arr+pos1, s, std::min( n1 - pos1, n2 ) );
}
 
mstring::size_type mstring::length() const
{
    return _len;
}
 
mstring::size_type mstring::size() const
{
    return _len;
}
 
mstring::size_type mstring::capacity() const
{
    return _capacity;
}
 
mstring::iterator mstring::begin()
{
    return _arr; 
}
 
mstring::const_iterator mstring::begin() const 
{
    return _arr; 
}
 
mstring::iterator mstring::end() 
{
    return _arr + _len;
}
 
mstring::const_iterator mstring::end() const 
{ 
    return _arr + _len; 
}