实现stl string类——转自C++ how to program。

实现stl string类——转自C++ how to program。

//  String class definition with operator overloading.
#ifndef STRING_H
#define  STRING_H

#include  < iostream >
using  std::ostream;
using  std::istream;

class  String
{
   friend ostream &operator<<( ostream &, const String & );
   friend istream &operator>>( istream &, String & );
public:
   String( const char * = "" ); // conversion/default constructor
   String( const String & ); // copy constructor
   ~String(); // destructor

   const String &operator=( const String & ); // assignment operator
   const String &operator+=( const String & ); // concatenation operator

   bool operator!() const; // is String empty?
   bool operator==( const String & ) const; // test s1 == s2
   bool operator<( const String & ) const; // test s1 < s2

   // test s1 != s2
   bool operator!=( const String &right ) const
   { 
      return !( *this == right ); 
   } // end function operator!=

   // test s1 > s2
   bool operator>( const String &right ) const
   { 
      return right < *this; 
   } // end function operator>
 
   // test s1 <= s2
   bool operator<=( const String &right ) const
   { 
      return !( right < *this ); 
   } // end function operator <=

   // test s1 >= s2
   bool operator>=( const String &right ) const
   { 
      return !( *this < right ); 
   } // end function operator>=

   char &operator[]( int ); // subscript operator (modifiable lvalue)
   char operator[]( int ) const; // subscript operator (rvalue)
   String operator()( int, int = 0 ) const; // return a substring
   int getLength() const; // return string length
private:
   int length; // string length (not counting null terminator)
   char *sPtr; // pointer to start of pointer-based string

   void setString( const char * ); // utility function
} ;  //  end class String

#endif

源文件

//  String class member-function and friend-function definitions.
#include  < iostream >
using  std::cerr;
using  std::cout;
using  std::endl;

#include  < iomanip >
using  std::setw;

#include  < cstring >   //  strcpy and strcat prototypes
using  std::strcmp;
using  std::strcpy;
using  std::strcat;

#include  < cstdlib >   //  exit prototype
using  std::exit;

#include  " String.h "   //  String class definition

//  conversion (and default) constructor converts char * to String
String::String(  const   char   * s ) 
   : length( ( s  !=   0  )  ?  strlen( s ) :  0  )
{
   cout << "Conversion (and default) constructor: " << s << endl;
   setString( s ); // call utility function
}   //  end String conversion constructor

//  copy constructor
String::String(  const  String  & copy ) 
   : length( copy.length )
{
   cout << "Copy constructor: " << copy.sPtr << endl;
   setString( copy.sPtr ); // call utility function
}   //  end String copy constructor

//  Destructor
String:: ~ String()
{
   cout << "Destructor: " << sPtr << endl;
   delete [] sPtr; // release pointer-based string memory
}   //  end ~String destructor

//  overloaded = operator; avoids self assignment
const  String  & String:: operator = (  const  String  & right )
{
   cout << "operator= called" << endl;

   if ( &right != this ) // avoid self assignment
   {         
      delete [] sPtr; // prevents memory leak
      length = right.length; // new String length
      setString( right.sPtr ); // call utility function
   } // end if
   else
      cout << "Attempted assignment of a String to itself" << endl;

   return *this; // enables cascaded assignments
}   //  end function operator=

//  concatenate right operand to this object and store in this object
const  String  & String:: operator += (  const  String  & right )
{
   size_t newLength = length + right.length; // new length
   char *tempPtr = new char[ newLength + 1 ]; // create memory

   strcpy( tempPtr, sPtr ); // copy sPtr
   strcpy( tempPtr + length, right.sPtr ); // copy right.sPtr

   delete [] sPtr; // reclaim old space
   sPtr = tempPtr; // assign new array to sPtr
   length = newLength; // assign new length to length
   return *this; // enables cascaded calls
}   //  end function operator+=

//  is this String empty?
bool  String:: operator ! ()  const
{ 
   return length == 0; 
}   //  end function operator! 

//  Is this String equal to right String?
bool  String:: operator == (  const  String  & right )  const
{ 
   return strcmp( sPtr, right.sPtr ) == 0; 
}   //  end function operator==

//  Is this String less than right String?
bool  String:: operator < (  const  String  & right )  const
{ 
   return strcmp( sPtr, right.sPtr ) < 0; 
}   //  end function operator<

//  return reference to character in String as a modifiable lvalue
char   & String:: operator [](  int  subscript )
{
   // test for subscript out of range
   if ( subscript < 0 || subscript >= length )
   {
      cerr << "Error: Subscript " << subscript 
         << " out of range" << endl;
      exit( 1 ); // terminate program
   } // end if

   return sPtr[ subscript ]; // non-const return; modifiable lvalue
}   //  end function operator[]

//  return reference to character in String as rvalue
char  String:: operator [](  int  subscript )  const
{
   // test for subscript out of range
   if ( subscript < 0 || subscript >= length )
   {
      cerr << "Error: Subscript " << subscript 
           << " out of range" << endl;
      exit( 1 ); // terminate program
   } // end if

   return sPtr[ subscript ]; // returns copy of this element
}   //  end function operator[]

//  return a substring beginning at index and of length subLength
String String:: operator ()(  int  index,  int  subLength )  const
{
   // if index is out of range or substring length < 0, 
   // return an empty String object
   if ( index < 0 || index >= length || subLength < 0 )  
      return ""; // converted to a String object automatically

   // determine length of substring
   int len;

   if ( ( subLength == 0 ) || ( index + subLength > length ) )
      len = length - index;
   else
      len = subLength;

   // allocate temporary array for substring and 
   // terminating null character
   char *tempPtr = new char[ len + 1 ];

   // copy substring into char array and terminate string
   strncpy( tempPtr, &sPtr[ index ], len );
   tempPtr[ len ] = '\0';

   // create temporary String object containing the substring
   String tempString( tempPtr );
   delete [] tempPtr; // delete temporary array
   return tempString; // return copy of the temporary String
}   //  end function operator()

//  return string length
int  String::getLength()  const  
{ 
   return length; 
}   //  end function getLength

//  utility function called by constructors and operator=
void  String::setString(  const   char   * string2 )
{
   sPtr = new char[ length + 1 ]; // allocate memory

   if ( string2 != 0 ) // if string2 is not null pointer, copy contents
      strcpy( sPtr, string2 ); // copy literal to object
   else // if string2 is a null pointer, make this an empty string
      sPtr[ 0 ] = '\0'; // empty string
}   //  end function setString 

//  overloaded output operator
ostream  & operator << ( ostream  & output,  const  String  & s )
{
   output << s.sPtr;
   return output; // enables cascading
}   //  end function operator<<

//  overloaded input operator
istream  & operator >> ( istream  & input, String  & s )
{
   char temp[ 100 ]; // buffer to store input
   input >> setw( 100 ) >> temp;
   s = temp; // use String class assignment operator
   return input; // enables cascading
}   //  end function operator>>

***********************************测试的代码****************************************************

//  String class test program.
#include  < iostream >
using  std::cout;
using  std::endl;
using  std::boolalpha;

#include  " String.h "

int  main()
{
   String s1( "happy" );
   String s2( " birthday" );
   String s3;

   // test overloaded equality and relational operators
   cout << "s1 is \"" << s1 << "\"; s2 is \"" << s2
      << "\"; s3 is \"" << s3 << '\"' 
      << boolalpha << "\n\nThe results of comparing s2 and s1:"
      << "\ns2 == s1 yields " << ( s2 == s1 )
      << "\ns2 != s1 yields " << ( s2 != s1 )
      << "\ns2 >  s1 yields " << ( s2 > s1 )
      << "\ns2 <  s1 yields " << ( s2 < s1 )
      << "\ns2 >= s1 yields " << ( s2 >= s1 )
      << "\ns2 <= s1 yields " << ( s2 <= s1 );
      

   // test overloaded String empty (!) operator
   cout << "\n\nTesting !s3:" << endl;

   if ( !s3 )
   {
      cout << "s3 is empty; assigning s1 to s3;" << endl;
      s3 = s1; // test overloaded assignment
      cout << "s3 is \"" << s3 << "\"";
   } // end if

   // test overloaded String concatenation operator
   cout << "\n\ns1 += s2 yields s1 = ";
   s1 += s2; // test overloaded concatenation
   cout << s1;

   // test conversion constructor
   cout << "\n\ns1 += \" to you\" yields" << endl;
   s1 += " to you"; // test conversion constructor
   cout << "s1 = " << s1 << "\n\n";

   // test overloaded function call operator () for substring
   cout << "The substring of s1 starting at\n"
      << "location 0 for 14 characters, s1(0, 14), is:\n"
      << s1( 0, 14 ) << "\n\n";

   // test substring "to-end-of-String" option
   cout << "The substring of s1 starting at\n"
      << "location 15, s1(15), is: "
      << s1( 15 ) << "\n\n"; 

   // test copy constructor
   String *s4Ptr = new String( s1 );  
   cout << "\n*s4Ptr = " << *s4Ptr << "\n\n";

   // test assignment (=) operator with self-assignment
   cout << "assigning *s4Ptr to *s4Ptr" << endl;
   *s4Ptr = *s4Ptr; // test overloaded assignment
   cout << "*s4Ptr = " << *s4Ptr << endl;

   // test destructor
   delete s4Ptr;     

   // test using subscript operator to create a modifiable lvalue
   s1[ 0 ] = 'H';      
   s1[ 6 ] = 'B';
   cout << "\ns1 after s1[0] = 'H' and s1[6] = 'B' is: "
      << s1 << "\n\n";

   // test subscript out of range
   cout << "Attempt to assign 'd' to s1[30] yields:" << endl;
   s1[ 30 ] = 'd'; // ERROR: subscript out of range
   return 0;
}   //  end main