Разработать класс String

@Vlad-letchik · Регистрация: 08.04.2012

Author24 — интернет-сервис помощи студентам

Разработка класса строка

Задание
Разработать класс String определив для него методы:
• копирования строк, реализовав оператор = ;
• поиска подстроки;
• слияния строк, реализовав операторы += и + ;
• эквивалентности строк, набор операторов == и !=;
• определения длины строки;
• вывода в поток, << ;
• ввода из потока >> ;
• вставки подcтроки с нужной позиции;
• конструктор копирования вида X::X(const X&);
Напишите программу иллюстрирующую основные методы класса String.

Я где-то нашел вот такой код здесь, но выдает ошибки:
http://www.cyberguru.ru/progra... age67.html
Пожалуйста помогите все исправить, т. к. я в программировании ничего не понимаю, а надо закрыть предмет(он как дополнительный)

C++

#include <iostream>
#include <string.h>
 
            class string {
               struct srep {
                 char* s;       // указатель на строку
                 int n;         // счетчик числа ссылок
                 srep() { n = 1; }
               };
               srep *p;
 
            public:
              string(const char *);   // string x = "abc"
              string();               // string x;
              string(const string &); // string x = string ...
              string& operator=(const char *);
              string& operator=(const string &);
              ~string();
              char& operator[](int i);
 
              friend ostream& operator<<(ostream&, const string&);
              friend istream& operator>>(istream&, string&);
 
              friend int operator==(const string &x, const char *s)
                { return strcmp(x.p->s,s) == 0; }
 
              friend int operator==(const string &x, const string &y)
                { return strcmp(x.p->s,y.p->s) == 0; }
 
              friend int operator!=(const string &x, const char *s)
                { return strcmp(x.p->s,s) != 0; }
 
              friend int operator!=(const string &x, const string &y)
                { return strcmp(x.p->s,y.p->s) != 0; }
           };
             string::string()
           {
             p = new srep;
             p->s = 0;
           }
 
           string::string(const string& x)
           {
             x.p->n++;
             p = x.p;
           }
 
           string::string(const char* s)
           {
             p = new srep;
             p->s = new char[ strlen(s)+1 ];
             strcpy(p->s, s);
           }
 
           string::~string()
           {
             if (--p->n == 0) {
                delete[]  p->s;
                delete p;
             }
           }
             string& string::operator=(const char* s)
          {
            if (p->n > 1) {  // отсоединяемся от старой строки
                p->n--;
                p = new srep;
            }
            else    // освобождаем строку со старым значением
                delete[] p->s;
 
            p->s = new char[ strlen(s)+1 ];
            strcpy(p->s, s);
            return *this;
          }
 
          string& string::operator=(const string& x)
          {
            x.p->n++;  // защита от случая ``st = st''
            if (--p->n == 0) {
               delete[] p->s;
               delete p;
            }
            p = x.p;
            return *this;
          }  ostream& operator<<(ostream& s, const string& x)
          {
             return s << x.p->s << " [" << x.p->n << "]\n";
          } istream& operator>>(istream& s, string& x)
          {
             char buf[256];
             s >> buf;   // ненадежно: возможно переполнение buf
                         // правильное решение см. в $$10.3.1
             x = buf;
             cout << "echo: " << x << '\n';
             return s;
           }  void error(const char* p)
          {
            cerr << p << '\n';
            exit(1);
          }
 
         char& string::operator[](int i)
        {
         if (i<0 || strlen(p->s)<i) error("недопустимое значение индекса");
           return p->s[i];
        }   int main()
         {
           string x[100];
           int n;
 
           cout << " здесь начало \n";
 
           for ( n = 0; cin>>x[n]; n++) {
               if (n==100) {
                  error("слишком много слов");
                  return 99;
               }
               string y;
               cout << (y = x[n]);
               if (y == "done") break;
 
           }
           cout << "теперь мы идем по словам в обратном порядке \n";
           for (int i=n-1; 0<=i; i--) cout << x[i];
           return 0;
         }

Добавлено через 2 минуты
Или вот еще код, но здесь похоже не все задание:

C++

#include <iostream>
#include <cstring>
#include <stdexcept>
 
class String
{
public:
   String():length_(0), is_copied_(false), string_(0)
   {
   }
   String(const char* str, const size_t len):length_(len), is_copied_(true)
   {
      string_ = new char[length_ + 1];
      strncpy(string_, str, length_);
      string_[length_] = '\0';
   }
   String(const char* str):length_(strlen(str)), is_copied_(true)
   {
      string_ = new char[length_ + 1];
      strncpy(string_, str, length_);
      string_[length_] = '\0';
   }
   ~String()
   {
      if (is_copied_)
      {
         delete[] string_;
         is_copied_ = false;
      }
   }
   String(const String& rhs)
   {
      is_copied_ = false;
      string_ = rhs.string_;
      length_ = rhs.length_;
   }
   String& operator =(const String& rhs)
   {
      is_copied_ = false;
      delete[] string_;
      String tmp(rhs);
      swap(tmp);
      return *this;
   }
   char& operator[](const size_t idx)
   {
      if (idx >= length_)
      {
         throw std::out_of_range("wrong index");
      }
      Copy();
      return string_[idx];
   }
   const char& operator[] (const size_t idx) const
   {
      if (idx >= length_)
      {
         throw std::out_of_range("wrong index");
      }
      return string_[idx];
   }
   String& operator += (const String& rhs)
   {
      Copy();
      char* tmp = new char[length_ + rhs.length_ + 1];
      strncpy(tmp, string_, length_);
      tmp[length_] = '\0';
      delete[] string_;
      strcat(tmp, rhs.string_);
      length_ += rhs.length_;
      tmp[length_] = '\0';
      string_ = tmp;
      return *this;
   }
   const char* string() const { return string_; }
   const size_t length() const { return length_; }
private:
   void swap(String& rhs)
   {
      std::swap(string_, rhs.string_);
      std::swap(length_, rhs.length_);
   }
   void Copy()
   {
      if (!is_copied_)
      {
         char* new_string = new char[length_ + 1];
         strncpy(new_string, string_, length_);
         new_string[length_] = '\0';
         string_ = new_string;
         is_copied_ = true;
      }
   }
   char* string_;
   size_t length_;
   bool is_copied_;
};
 
std::ostream& operator << (std::ostream& os, const String& rhs)
{
   os << rhs.string() << std::endl << "Address: " << (void*)rhs.string();
   return os;
}
 
String operator +(const String& lhs, const String& rhs)
{
   String result(lhs);
   result += rhs;
   return result;
}
 
bool operator == (const String& lhs, const String& rhs)
{
   return !strcpy(lhs.string(), rhs.string());
}
 
bool operator != (const String& lhs, const String& rhs)
{
   return !(lhs == rhs);
}
 
int main()
{
   String tmp("hello");
   String other("other");
   tmp = other;
   std::cout << tmp << std::endl;
   std::cout << other << std::endl;
   tmp[0] = 'a';
   std::cout << tmp << std::endl;
   std::cout << other << std::endl;
   tmp[1] = 'c';
   std::cout << tmp << std::endl;
   std::cout << other << std::endl;
   tmp += other;
   std::cout << tmp << std::endl;
   std::cout << other << std::endl;
   String new_s = tmp + other;
   std::cout << tmp << std::endl;
   std::cout << other << std::endl;
   std::cout << new_s << std::endl;
}

@softmob · 22.05.2012, 20:11

здесь немного больше чем вам надо...

class string

C++

#include <iostream>
#include <stdexcept>
#include <utility>
#include <iterator>
#include <cstddef>
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 ptrdiff_t difference_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; 
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_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 );
    template<typename Iterator>
    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 );
    template <class Iterator>
    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 );
    template<class Iterator>
    void insert( iterator, Iterator, 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;
    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const; 
    reverse_iterator rend();   
    const_reverse_iterator rend() const;
private:
    template <class Iterator>
    size_type calc_size( Iterator beg, Iterator end );
private:
    size_type m_len;
    size_type m_capacity;
    char *m_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():
m_len( 0 ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    *m_arr = '\0';
}
 
mstring::mstring( const mstring& s ):
m_len( s.m_len ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    mstrcpy( m_arr, s.m_arr );
}
 
mstring::mstring( size_type length, char ch ):
m_len( length ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    mstrnset( m_arr, ch, length );
}
 
mstring::mstring( const char* str ):
m_len( mstrlen( str ) ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    mstrcpy( m_arr, str );
}
 
mstring::mstring( const char* str, size_type length ):
m_len( std::min( length, mstrlen( str ) ) ), 
    m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    mstrncpy( m_arr, str, std::min( length, mstrlen( str ) ) );
}
 
mstring::mstring( const mstring& str, size_type index, size_type length ):
m_len( std::min( length, str.m_len ) - index ), 
    m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    mstrncpy( m_arr, str.m_arr + index, std::min( length, str.m_len ) );
}
 
template <class Iterator>
mstring::mstring( Iterator start, Iterator end ):
m_len( calc_size( start, end ) ), m_capacity( 2*m_len+1 ),
m_arr( new char[m_capacity]() )
{
    mstrncpy( m_arr, start, m_len );
}
 
mstring::~mstring()
{
    delete [] m_arr;
}
 
bool operator== ( const mstring& c1, const mstring& c2 )
{
    return mstrcmp( c1.m_arr, c2.m_arr ) == 0;
}
 
bool operator< ( const mstring& c1, const mstring& c2 )
{
    return mstrcmp( c1.m_arr, c2.m_arr ) < 0;
}
 
char& mstring::at( size_type index )
{
    if ( index >= m_len )
        throw std::out_of_range( "Expression: string subscript out of range." );
    return m_arr[index];
}
 
const char& mstring::at( size_type index ) const
{
    if ( index >= m_len )
        throw std::out_of_range( "Expression: string subscript out of range." );
    return m_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 )
        mstring( s ).swap( *this );  
    return *this;
}
 
mstring& mstring::operator= ( const char* s )
{
    mstring( s ).swap( *this );  
    return *this;
}
 
mstring& mstring::operator= ( char ch )
{
    mstring( 1, ch ).swap( *this );  
    return *this;
}
 
std::ostream& operator<< ( std::ostream& out, const mstring& s )
{
    out << s.m_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( m_len + append.m_len + 1 );
    mstrcat( m_arr, append.m_arr );
    return *this;
}
 
mstring& mstring::operator+= ( const char* append )
{
    resize( m_len + mstrlen( append ) + 1 );
    mstrcat( m_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( m_arr, str.m_arr );
    return *this;
}
 
mstring& mstring::append( const char* str )
{
    mstrcat( m_arr, str );
    return *this;
}
 
mstring& mstring::append( const mstring& str, size_type index, size_type len )
{
    mstrncat( m_arr, str.m_arr + index, len );
    return *this;
}
 
mstring& mstring::append( const char* str, size_type num )
{
    mstrncat( m_arr, str, num );
    return *this;
}
 
mstring& mstring::append( size_type num, char ch )
{
    *this += mstring( num, ch );
    return *this;
}
 
template<typename Iterator>
mstring& mstring::append( Iterator start, Iterator end )
{
    mstrncat( m_arr, start, calc_size( start, end ) );
    return *this;
}
 
mstring& mstring::assign( iterator start, iterator end )
{
    mstring( start, end ).swap( *this );  
    return *this;
}
mstring& mstring::assign( const mstring& str )
{
    mstring( str ).swap( *this );  
    return *this;
}
mstring& mstring::assign( const char* str )
{
    mstring( str ).swap( *this );  
    return *this;
}
 
mstring& mstring::assign( const char* str, size_type num )
{
    mstring( str, num ).swap( *this );  
    return *this;
}
 
mstring& mstring::assign( const mstring& str, size_type index, size_type len )
{
    mstring( str, index, len ).swap( *this );  
    return *this;
}
 
mstring& mstring::assign( size_type num, char ch )
{
    mstring( num, ch ).swap( *this );  
    return *this;
}
 
mstring::iterator mstring::erase( iterator position )
{
    for ( iterator i = position; i != end(); ++i )
        *i = *( i + 1 );
    --m_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 = m_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] = m_arr[i];
 
    for ( size_type i = beg, j = end; j != m_len + 1; ++i, ++j )
        new_arr[i] = m_arr[j];
 
    delete [] m_arr;
 
    m_len = new_len;
    m_capacity = new_capacity;
    m_arr = new_arr;
    return begin() + beg;
}
 
mstring& mstring::erase( size_type index, size_type num )
{
    num = std::min( num, m_len - index );
    erase( begin() + index, begin() + index + num );
    return *this;
}
 
mstring::iterator mstring::insert( iterator p, char c )
{
    size_type tmp = p - begin();
    if ( m_len + 1 > m_capacity )
        resize( m_len + 1 );
    else
        ++m_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 ( m_len + n > m_capacity )
        resize( m_len + n );
    else
        m_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;
}
 
template<typename Iterator>
void mstring::insert( iterator p, Iterator first, Iterator last )
{
    size_type tmp = p - begin();
    size_type n = calc_size( first, last );
    if ( m_len + n > m_capacity )
        resize( m_len + n ); 
    else
        m_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( m_arr + index, str.m_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( m_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( m_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 != m_len; ++i )
    {
        if ( m_arr[i] == ch ) 
            return i;
    }
    return npos;
}
 
const char * mstring::data() const
{
    return m_arr;
}
 
char * mstring::c_str() const
{
    return m_arr;
}
 
mstring mstring::substr( size_type index, size_type length ) const
{
    mstring res( this->m_arr, index, length );
    return res;
}
 
mstring::size_type mstring::copy( char* str, size_type num, size_type index ) const
{
    mstrncpy( str, m_arr + index, num );
    return num - index;
}
 
void mstring::resize( size_type new_len )
{
    m_capacity = 2 * new_len + 1;
    char *new_arr = new char[m_capacity]();
    mstrcpy( new_arr, m_arr );
    delete [] m_arr;
    m_len = new_len;
    m_arr = new_arr;
}
 
void mstring::push_back( const char& val )
{
    if ( m_len == m_capacity )
    {
        resize( m_len + 1 );
        --m_len;
    }
 
    m_arr[m_len++] = val;
}
 
void mstring::pop_back()
{
    if ( m_len > 0 )
        --m_len;
}
 
void mstring::clear() 
{
    delete [] m_arr;
    m_len = 0;
    m_capacity = 2*m_len+1;
    m_arr = new char[m_capacity]();
    *m_arr = '\0';
}
 
void mstring::swap( mstring& c ) 
{ 
    if ( this != &c )
    {
        std::swap( m_len, c.m_len );
        std::swap( m_capacity, c.m_capacity );
        std::swap( m_arr, c.m_arr );
    }
}
 
char& mstring::front()
{
    return at( 0 );
}
 
char& mstring::back()
{
    return at( m_len - 2 );
}
 
bool mstring::empty() const
{
    return m_len == 0;
}
 
int mstring::compare( const mstring& str ) const
{
    return mstrcmp( this->m_arr, str.m_arr );
}
 
int mstring::compare( const char* s ) const
{
    return mstrcmp( this->m_arr, s );
}
 
int mstring::compare( size_type pos1, size_type n1, const mstring& str ) const
{
    return mstrncmp( this->m_arr+pos1, str.m_arr, n1 - pos1 );
}
 
int mstring::compare( size_type pos1, size_type n1, const char* s ) const
{
    return mstrncmp( this->m_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->m_arr+pos1, str.m_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->m_arr+pos1, s, std::min( n1 - pos1, n2 ) );
}
 
mstring::size_type mstring::length() const
{
    return m_len;
}
 
mstring::size_type mstring::size() const
{
    return m_len;
}
 
mstring::size_type mstring::capacity() const
{
    return m_capacity;
}
 
mstring::iterator mstring::begin()
{
    return m_arr; 
}
 
mstring::const_iterator mstring::begin() const 
{
    return m_arr; 
}
 
mstring::iterator mstring::end() 
{
    return m_arr + m_len;
}
 
mstring::const_iterator mstring::end() const 
{ 
    return m_arr + m_len; 
}
 
mstring::reverse_iterator mstring::rbegin() 
{
    return reverse_iterator( end() );
}
 
mstring::const_reverse_iterator mstring::rbegin() const 
{
    return const_reverse_iterator( end() );
}
 
mstring::reverse_iterator mstring::rend()
{
    return reverse_iterator( begin() );
}
 
mstring::const_reverse_iterator mstring::rend() const
{
    return const_reverse_iterator( begin() );
}
 
template <class Iterator>
mstring::size_type mstring::calc_size( Iterator beg, Iterator end )
{
    Iterator tmp = beg;
    size_type res = 0;
    while ( tmp != end )
    {
        ++res;
        ++tmp;
    }
    return res;
}

или немного урезанная версия

C++

#include <iostream>
#include <utility>
#include <cstring>
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;
    static const size_type npos = -1;
    mstring();
    mstring( const mstring& );
    mstring( const char* );
    mstring( const char* str, size_type length );
    ~mstring(); 
    friend bool operator== ( const mstring&, const mstring& );
    friend bool operator< ( const mstring&, const mstring& );
    char& operator[] ( size_type );
    const char& operator[] ( size_type ) const;
    mstring& operator= ( const mstring& );
    mstring& operator= ( const char* );
    friend std::ostream& operator<< ( std::ostream&, const mstring& );
    friend std::istream& operator>> ( std::istream&, mstring& );
    mstring& operator+= ( const mstring& );
    mstring& operator+= ( const char* );
    friend mstring operator+ ( const mstring&, const mstring& );
    friend mstring operator+ ( const char*, const mstring& );
    friend mstring operator+ ( const mstring&, const char* );
    void insert( char*, size_t, char );
    void insert( char*, const char*, const char* );
    mstring& insert( size_type, const char*, size_type );
    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;
    void resize( size_type );
    mstring substr( size_type index = 0, size_type length = npos ) const;   
    void swap( mstring& );
    size_type size() const;
    size_type capacity() const; 
private:
    size_type m_len;
    size_type m_capacity;
    char *m_arr;
};
 
mstring::mstring():
m_len( 0 ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    *m_arr = '\0';
}
 
mstring::mstring( const mstring& s ):
m_len( s.m_len ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    strcpy( m_arr, s.m_arr );
}
 
mstring::mstring( const char* str ):
m_len( strlen( str ) ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    strcpy( m_arr, str );
}
 
mstring::mstring( const char* str, size_type length ):
m_len( std::min( length, strlen( str ) ) ), 
    m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    strncpy( m_arr, str, std::min( length, strlen( str ) ) );
}
 
mstring::~mstring()
{
    delete [] m_arr;
}
 
bool operator== ( const mstring& c1, const mstring& c2 )
{
    return strcmp( c1.m_arr, c2.m_arr ) == 0;
}
 
bool operator< ( const mstring& c1, const mstring& c2 )
{
    return strcmp( c1.m_arr, c2.m_arr ) < 0;
}
 
char& mstring::operator[] ( size_type index )
{
    return m_arr[index];
}
 
const char& mstring::operator[]( size_type index ) const
{
    return m_arr[index];
}
 
mstring& mstring::operator= ( const mstring& s )
{
    if ( this != &s )
        mstring( s ).swap( *this );  
    return *this;
}
 
mstring& mstring::operator= ( const char* s )
{
    mstring( s ).swap( *this );  
    return *this;
}
 
std::ostream& operator<< ( std::ostream& out, const mstring& s )
{
    out << s.m_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( m_len + append.m_len + 1 );
    strcat( m_arr, append.m_arr );
    return *this;
}
 
mstring& mstring::operator+= ( const char* append )
{
    resize( m_len + strlen( append ) + 1 );
    strcat( m_arr, 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+ ( const mstring& lhs, const char* rhs )
{
    mstring ret( lhs );
    ret += rhs;
    return ret;
}
 
void mstring::insert( char* p, size_t n, char c )
{
    size_type tmp = p - m_arr;
    if ( m_len + n > m_capacity )
        resize( m_len + n );
    else
        m_len += n;
    p = m_arr + tmp;
    for ( char * i = m_arr +  m_len; i != p + n - 1; --i )
        *i = *( i - n );
    for ( char * i = p; i != p + n; ++i )
        *i = c;
}
 
void mstring::insert( char* p, const char* first, const char* last )
{
    size_type tmp = p - m_arr;
    size_type n = last - first;
    if ( m_len + n > m_capacity )
        resize( m_len + n ); 
    else
        m_len += n;
    p = m_arr + tmp;
    for ( char * i = m_arr + m_len; i != p + n - 1; --i )
        *i = *( i - n );
    for ( char * i = p; i != p + n && first != last; ++i )
        *i = *first++;
}
 
mstring& mstring::insert ( size_t pos1, const char* s, size_t n)
{
    insert( m_arr + pos1, s, s + n );
    return *this;
}
 
mstring::size_type mstring::find( const mstring& str, size_type index ) const
{
    char * ptr = strstr( m_arr + index, str.m_arr );
    if (ptr != nullptr)
        return ptr - m_arr;
    else
        return npos;
}
 
mstring::size_type mstring::find( const char* str, size_type index ) const
{
    char *ptr = strstr( m_arr + index, str );
    if (ptr != nullptr)
        return ptr - m_arr;
    else
        return npos;
}
 
mstring::size_type mstring::find( char ch, size_type index ) const
{
    for ( size_type i = index; i != m_len; ++i )
    {
        if ( m_arr[i] == ch ) 
            return i;
    }
    return npos;
}
 
mstring mstring::substr( size_type index, size_type length ) const
{
    mstring res( this->m_arr + index, length );
    return res;
}
 
void mstring::resize( size_type new_len )
{
    m_capacity = 2 * new_len + 1;
    char *new_arr = new char[m_capacity]();
    strcpy( new_arr, m_arr );
    delete [] m_arr;
    m_len = new_len;
    m_arr = new_arr;
}
 
void mstring::swap( mstring& c ) 
{ 
    if ( this != &c )
    {
        std::swap( m_len, c.m_len );
        std::swap( m_capacity, c.m_capacity );
        std::swap( m_arr, c.m_arr );
    }
}
 
mstring::size_type mstring::size() const
{
    return m_len;
}
 
mstring::size_type mstring::capacity() const
{
    return m_capacity;
}

@Vlad-letchik · 22.05.2012, 20:24 **[ТС]**

2 ошибки выдает:

Ошибка 1 error LNK2019: ссылка на неразрешенный внешний символ _main в функции ___tmainCRTStartup C:\Users\Tower Controller\documents\visual studio 2010\Projects\oop+\oop+\MSVCRTD.lib(crtexe.obj)

Ошибка 2 error LNK1120: 1 неразрешенных внешних элементов C:\Users\Tower Controller\documents\visual studio 2010\Projects\oop+\Debug\oop+.exe

Добавлено через 1 минуту
softmob, 2 ошибки выдает:

Ошибка 1 error LNK2019: ссылка на неразрешенный внешний символ _main в функции ___tmainCRTStartup C:\Users\Tower Controller\documents\visual studio 2010\Projects\oop+\oop+\MSVCRTD.lib(crtexe.obj)

Ошибка 2 error LNK1120: 1 неразрешенных внешних элементов C:\Users\Tower Controller\documents\visual studio 2010\Projects\oop+\Debug\oop+.exe

@softmob · 22.05.2012, 20:55

Vlad-letchik, это только реализация строки, добавьте int main() и другие свои функции

@Vlad-letchik · 22.05.2012, 20:55 **[ТС]**

softmob, я ничего в этом не понимаю

@softmob · 22.05.2012, 21:00

например

C++

#include <iostream>
#include <utility>
#include <cstring>
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;
    static const size_type npos = -1;
    mstring();
    mstring( const mstring& );
    mstring( const char* );
    mstring( const char* str, size_type length );
    ~mstring(); 
    friend bool operator== ( const mstring&, const mstring& );
    friend bool operator< ( const mstring&, const mstring& );
    char& operator[] ( size_type );
    const char& operator[] ( size_type ) const;
    mstring& operator= ( const mstring& );
    mstring& operator= ( const char* );
    friend std::ostream& operator<< ( std::ostream&, const mstring& );
    friend std::istream& operator>> ( std::istream&, mstring& );
    mstring& operator+= ( const mstring& );
    mstring& operator+= ( const char* );
    friend mstring operator+ ( const mstring&, const mstring& );
    friend mstring operator+ ( const char*, const mstring& );
    friend mstring operator+ ( const mstring&, const char* );
    void insert( char*, size_t, char );
    void insert( char*, const char*, const char* );
    mstring& insert( size_type, const char*, size_type );
    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;
    void resize( size_type );
    mstring substr( size_type index = 0, size_type length = npos ) const;   
    void swap( mstring& );
    size_type size() const;
    size_type capacity() const; 
private:
    size_type m_len;
    size_type m_capacity;
    char *m_arr;
};
 
mstring::mstring():
m_len( 0 ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    *m_arr = '\0';
}
 
mstring::mstring( const mstring& s ):
m_len( s.m_len ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    strcpy( m_arr, s.m_arr );
}
 
mstring::mstring( const char* str ):
m_len( strlen( str ) ), m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    strcpy( m_arr, str );
}
 
mstring::mstring( const char* str, size_type length ):
m_len( std::min( length, strlen( str ) ) ), 
    m_capacity( 2*m_len+1 ), m_arr( new char[m_capacity]() )
{
    strncpy( m_arr, str, std::min( length, strlen( str ) ) );
}
 
mstring::~mstring()
{
    delete [] m_arr;
}
 
bool operator== ( const mstring& c1, const mstring& c2 )
{
    return strcmp( c1.m_arr, c2.m_arr ) == 0;
}
 
bool operator< ( const mstring& c1, const mstring& c2 )
{
    return strcmp( c1.m_arr, c2.m_arr ) < 0;
}
 
char& mstring::operator[] ( size_type index )
{
    return m_arr[index];
}
 
const char& mstring::operator[]( size_type index ) const
{
    return m_arr[index];
}
 
mstring& mstring::operator= ( const mstring& s )
{
    if ( this != &s )
        mstring( s ).swap( *this );  
    return *this;
}
 
mstring& mstring::operator= ( const char* s )
{
    mstring( s ).swap( *this );  
    return *this;
}
 
std::ostream& operator<< ( std::ostream& out, const mstring& s )
{
    out << s.m_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( m_len + append.m_len + 1 );
    strcat( m_arr, append.m_arr );
    return *this;
}
 
mstring& mstring::operator+= ( const char* append )
{
    resize( m_len + strlen( append ) + 1 );
    strcat( m_arr, 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+ ( const mstring& lhs, const char* rhs )
{
    mstring ret( lhs );
    ret += rhs;
    return ret;
}
 
void mstring::insert( char* p, size_t n, char c )
{
    size_type tmp = p - m_arr;
    if ( m_len + n > m_capacity )
        resize( m_len + n );
    else
        m_len += n;
    p = m_arr + tmp;
    for ( char * i = m_arr +  m_len; i != p + n - 1; --i )
        *i = *( i - n );
    for ( char * i = p; i != p + n; ++i )
        *i = c;
}
 
void mstring::insert( char* p, const char* first, const char* last )
{
    size_type tmp = p - m_arr;
    size_type n = last - first;
    if ( m_len + n > m_capacity )
        resize( m_len + n ); 
    else
        m_len += n;
    p = m_arr + tmp;
    for ( char * i = m_arr + m_len; i != p + n - 1; --i )
        *i = *( i - n );
    for ( char * i = p; i != p + n && first != last; ++i )
        *i = *first++;
}
 
mstring& mstring::insert ( size_t pos1, const char* s, size_t n)
{
    insert( m_arr + pos1, s, s + n );
    return *this;
}
 
mstring::size_type mstring::find( const mstring& str, size_type index ) const
{
    char * ptr = strstr( m_arr + index, str.m_arr );
    if (ptr != nullptr)
        return ptr - m_arr;
    else
        return npos;
}
 
mstring::size_type mstring::find( const char* str, size_type index ) const
{
    char *ptr = strstr( m_arr + index, str );
    if (ptr != nullptr)
        return ptr - m_arr;
    else
        return npos;
}
 
mstring::size_type mstring::find( char ch, size_type index ) const
{
    for ( size_type i = index; i != m_len; ++i )
    {
        if ( m_arr[i] == ch ) 
            return i;
    }
    return npos;
}
 
mstring mstring::substr( size_type index, size_type length ) const
{
    mstring res( this->m_arr + index, length );
    return res;
}
 
void mstring::resize( size_type new_len )
{
    m_capacity = 2 * new_len + 1;
    char *new_arr = new char[m_capacity]();
    strcpy( new_arr, m_arr );
    delete [] m_arr;
    m_len = new_len;
    m_arr = new_arr;
}
 
void mstring::swap( mstring& c ) 
{ 
    if ( this != &c )
    {
        std::swap( m_len, c.m_len );
        std::swap( m_capacity, c.m_capacity );
        std::swap( m_arr, c.m_arr );
    }
}
 
mstring::size_type mstring::size() const
{
    return m_len;
}
 
mstring::size_type mstring::capacity() const
{
    return m_capacity;
}
 
int main(void)
{
    mstring str1, str2;
    std::cout << "enter str1: ";
    std::cin >> str1;
    std::cout << "enter str2: ";
    std::cin >> str2;
    std::cout << str1 + str2;
    return 0;
}

@Vlad-letchik · 22.05.2012, 21:07 **[ТС]**

softmob, это надо добавлять, что нужно делать со строкой?

@Vlad-letchik 0 / 0 / 0 Регистрация: 08.04.2012 Сообщений: 38
	22.05.2012, 20:24 [ТС]	3
	2 ошибки выдает: Ошибка 1 error LNK2019: ссылка на неразрешенный внешний символ _main в функции ___tmainCRTStartup C:\Users\Tower Controller\documents\visual studio 2010\Projects\oop+\oop+\MSVCRTD.lib(crtexe.obj) Ошибка 2 error LNK1120: 1 неразрешенных внешних элементов C:\Users\Tower Controller\documents\visual studio 2010\Projects\oop+\Debug\oop+.exe Добавлено через 1 минуту softmob, 2 ошибки выдает: Ошибка 1 error LNK2019: ссылка на неразрешенный внешний символ _main в функции ___tmainCRTStartup C:\Users\Tower Controller\documents\visual studio 2010\Projects\oop+\oop+\MSVCRTD.lib(crtexe.obj) Ошибка 2 error LNK1120: 1 неразрешенных внешних элементов C:\Users\Tower Controller\documents\visual studio 2010\Projects\oop+\Debug\oop+.exe 0

@softmob 1255 / 705 / 359 Регистрация: 20.02.2010 Сообщений: 1,035
	22.05.2012, 20:55	4
	Vlad-letchik, это только реализация строки, добавьте int main() и другие свои функции 0

@Vlad-letchik 0 / 0 / 0 Регистрация: 08.04.2012 Сообщений: 38
	22.05.2012, 20:55 [ТС]	5
	softmob, я ничего в этом не понимаю 0

@Vlad-letchik 0 / 0 / 0 Регистрация: 08.04.2012 Сообщений: 38
	22.05.2012, 21:07 [ТС]	7
	softmob, это надо добавлять, что нужно делать со строкой? 0