CharString

From Minor Miracle Software
Revision as of 22:20, 14 May 2016 by WikiSysop (talk | contribs) (Created page with "Character string class for C Plus Plus. <pre> // charString.cc // by Jesse B. Dooley 03-SEP-1996 #ifndef CHAR_STRING_CC #define CHAR_STRING_CC #include <ctype.h> #include <i...")
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Character string class for C Plus Plus.

// charString.cc
// by Jesse B. Dooley 03-SEP-1996

#ifndef CHAR_STRING_CC
#define CHAR_STRING_CC

#include <ctype.h>
#include <iostream.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>


class charString;

ostream& operator << ( ostream& outputStream, const charString& string );

istream& operator >> ( istream& IS, charString& string );

class charString {

char* theString;

friend ostream& operator << ( ostream& outputStream, const charString& string ) // check
{
     outputStream << string.theString;
     return outputStream;
}


friend istream& operator >> ( istream& IS, charString& string )
{
     char c_New;

     while( IS && IS.get( c_New ) && (c_New != '\n'))
            string.append( c_New );

     return IS;
}


int checkMatch ( char* text, char* pattern ) const
{
     int last, matched, reverses;
     char *t, *p;

     t = text;
     p = pattern;

     for( ; *p; t++, p++)
     {
          if( *t == '\0' && *p != '*')
              return 0;
          switch(  *p )
          {
                  case '\\':  p++; /* Literal match with following character. */

        /* FALLTHROUGH */
      default:
        if (*t != *p)
          return 0;
        continue;
      case '?':
        /* Match anything. */
        continue;
      case '*':
        while (*++p == '*')
          /* Consecutive stars act just like one. */
          continue;
        if (*p == '\0')
          /* Trailing star matches everything. */
          return 1;
        while (*t)
          if ((matched = checkMatch(t++, p)) != 0)
            return matched;
        return 0;
      case '[':
        reverses = p[1] == 1 ? 1 : 0;
        if (reverses)
          /* Inverted character class. */
          p++;
        for (last = 0400, matched = 0; *++p && *p != ']'; last = *p)
          if (*p == '-' ? *t <= *++p && *t >= last : *t == *p)
            matched = 1;
        if (matched == reverses)
          return 0;
        continue;
    }
  }
     return *t == '\0';
} // checkMatch


charString soundexCodeOf ( const char* string ) const
{
// The Soundex code is an indexing system which translates names into
// a 4 digit code consisting of 1 letter and 3 numbers. The advantage
// of Soundex is its ability to group names by sound rather than the
// exact spelling.
//
//                              Soundex Rules
//
//  1. All Soundex codes have 4 alphanumeric characters [no more, no less]
//        o 1 Letter
//        o 3 Digits
//  2. The Letter of the name is the first character of the Soundex code.
//  3. The 3 digits are defined sequentially from the name using the Soundex
//     Key below.
//        o Adjacent letters in the name which belong to the same Soundex Key
//          code number are assigned a single digit.
//        o If the end of the name is reached prior to filling 3 digits, use
//          zeroes to complete the code.
//        o All codes have only 4 characters, even if the name is long enough
//          to yield more.
//
     int value, previous;
     charString code;

// error checking for null pointers and strings of length zero
//
     if( string == '\0' )
         return code;

     if( !isalpha (string[0]) )
         return code;

     code.append (string[0]);
     code.uppercase();

     value = 0;
     for( unsigned long i = 1; string[i]!= '\0' && (code.length() < 4); i++)
     {
          previous = value;
          value = soundexNumericOf (string[i]);
          if( (value != 0) && (value != previous))
              code.append (value);
     }

     while( code.length() < 4 )
            code.append ('0');

     return code;
}


int soundexNumericOf( const char c ) const
{
// The Soundex Key
//
//   1           B P F V
//   2       C S K G J Q X Z
//   3             D T
//   4              L
//   5             M N
//   6              R
//   no code  A E H I O U Y W
//
     int result = 0;
     char temp = toupper (c);

     switch( temp )
     {
             case 'B':
             case 'P':
             case 'F':
             case 'V': result = 1;
                       break;
             case 'C':
             case 'S':
             case 'K':
             case 'G':
             case 'J':
             case 'Q':
             case 'X':
             case 'Z': result = 2;
                       break;
             case 'D':
             case 'T': result = 3;
                       break;
             case 'L': result = 4;
                       break;
             case 'M':
             case 'N': result = 5;
                       break;
             case 'R': result = 6;
                       break;
     default:
             break;
     }
     return result;
} // soundexNumericOf ( const char c) const



public:

charString() // check
{
     theString = new char [1];
     theString[0] = '\0';
} // charString()


charString( char character ) // check
{
     theString = new char [2];
     theString [0] = character;
     theString [1] = '\0';
} // charString (char character)


charString( const char* string ) // check
{
     if( string[0] != '\0' )
     {
         theString = new char [ strlen( string ) + 1];
         strcpy (theString, string );
     }
} // charString ( const char* string )


charString ( const charString& string ) // check
{
     theString = new char [strlen( string.theString ) + 1];
     strcpy (theString, string );
} // charString ( const charString& string )


virtual ~charString() // check
{
     delete [] theString;
} // virtual ~charString()


operator char*() const // check
{
    return theString;
}  // operator char*() const


charString& operator = ( char character ) // check
{
     delete [] theString;
     theString = new char [2];
     theString [0] = character;
     theString [1] = '\0';
     return *this;
} // = (char character)


charString& operator = ( const char* string ) // check
{
     if( string[0] != '\0' )
     {
         delete [] theString;
         theString = new char [ strlen( string ) + 1];
         strcpy( theString, string );
     }

     return *this;
} //  = ( const char* string )


charString& operator = ( const charString& string ) // check
{
     delete [] theString;
     theString = new char [ strlen( string.theString ) + 1];
     strcpy( theString, string.theString );
     return *this;
} // charString& operator = ( const charString& string )


int operator != ( const charString& string ) const // check
{
     return ( strcmp( theString, string.theString ) != 0 );
} // int operator != ( const charString& string ) const


int operator != ( const char* string ) const // check
{
     return ( strcmp (theString, string ) != 0 );
} // int operator != ( const char* string ) const


int operator < ( const charString& string ) const // check
{
     return ( strcmp ( theString, string.theString ) < 0 );
} // int operator < ( const charString& string ) const


int operator < ( const char* string ) const // check
{
     return ( strcmp( theString, string ) < 0 );
} // int operator < ( const char* string ) const


int operator > ( const charString& string ) const // check
{
     return ( strcmp( theString, string.theString ) > 0 );
} // int operator > ( const charString& string ) const


int operator > ( const char* string ) const // check
{
     return ( strcmp( theString, string ) > 0 );
} // int operator > ( const char* string ) const


int operator <= ( const charString& string ) const // check
{
     return ( strcmp( theString, string.theString ) <= 0 );
} // int operator <= ( const charString& string ) const


int operator <= ( const char* string ) const // check
{
     return ( strcmp( theString, string ) <= 0 );
} // int operator <= ( const char* string ) const


int operator == ( const charString& string ) const // check
{
     return ( strcmp( theString, string.theString ) == 0 );
} // int operator == ( const charString& string ) const


int operator == ( const char* string ) const // check
{
     return ( strcmp( theString, string ) == 0 );
} // int operator == ( const char* string ) const


int operator >= ( const charString& string ) const // check
{
     return ( strcmp( theString, string.theString ) >= 0 );
} // int operator >= ( const charString& string ) const


int operator >= ( const char* string ) const // check
{
     return ( strcmp( theString, string ) >= 0 );
} // int operator >= ( const char* string ) const


const char& operator [] (const unsigned int index) const // check
{
      if( index < 0 || index > length() )
          return theString[ length() ];
      else
          return theString[ index ];
} // const char& operator [] (const unsigned int index) const


void append( char character ) // check
{
     char *temp;
     unsigned long ul_Length = strlen( theString );

     temp = new char [ ul_Length ];
     strcpy( temp, theString );

     delete [] theString;
     theString = new char [ ul_Length +  1 ];

     strcpy( theString, temp );
     theString[ ul_Length ] = character;
     theString[ ul_Length + 1 ] = '\0';
     delete [] temp;
} // void append( char character )


void append( const char* string ) // check
{
     if( string != '\0')
     {
         char* temp;

         temp = new char [ strlen( theString ) ];
         strcpy( temp, theString );

         delete [] theString;
         theString = new char [ strlen( temp ) + strlen( string ) ];

         strcpy( theString, temp );
         strcat( theString, string );

         delete [] temp;
     }
} // void append ( const char* string )


void append( const int integer ) // check
{
// decimal number is assumed
     char number[20];

     sprintf( number, "%d", integer );
     append( number );
} // void append( const int integer )


void append ( const charString& string ) // check
{
     char* temp;

     temp = new char [ strlen( theString )];
     strcpy( temp, theString );

     delete [] theString;
     theString = new char [ strlen( temp ) + strlen( string.theString )];

     strcpy( theString, temp );
     strcat( theString, string.theString );

     delete [] temp;
} // void append ( const charString& string )


int beginsWith( char* cp_string ) // check
{
// Checks for NULL and length.
     int i_cp_stringLength = strlen( cp_string );
     short s_Return = 0;

     if( cp_string == '\0' || theString[0] == '\0' )
         return 0;

     if( strlen( theString ) < i_cp_stringLength )
         return 0;

     while( s_Return < i_cp_stringLength )
     {

          if( cp_string[s_Return] == theString[s_Return] )
          {
              s_Return++;
          }
          else
              break;
     }

     return (s_Return == i_cp_stringLength);
} // int beginsWith ( const char* cp_string ) const


unsigned long count( const char c) const // check
{
// Tally char c occurances in theString
     unsigned long ul_theCount = 0;

     while( theString[0] != '\0' )
     {
          if( theString[ ul_theCount ] == c )
              ul_theCount++;
     }
     return ul_theCount;
} // count


int isempty() const // check
{
     return ( theString[0] == '\0' );
} // isempty()


int endsWith ( const char* string ) const // check
{
     int result = 0;

     if( string == '\0' )
         return result;
     else
     {
         unsigned long ul_theLength = strlen( theString );
         unsigned long ul_stringLength = strlen( string );
         if( ul_theLength < ul_stringLength )
         {
             return result;
         }

         result = ul_stringLength;
         while( result )
         {
            if( theString[ ul_theLength -1 ] == string[ ul_stringLength -1 ])
            {
                ul_theLength--;
                ul_stringLength--;
            }
            else
               break;
         }
         return !(ul_stringLength);
     }
} // int endsWith ( const char* string ) const


void erase() // check
{
     delete [] theString;
     theString = new char [1];
     theString[0] = '\0';
} // erase()


unsigned long length() const // check
{
     return strlen( theString );
} // length()


void lowercase() // check
{
     unsigned long ul_length = strlen( theString );
     for( unsigned long i=0; i <= ul_length; i++ )
          theString[i] = tolower( theString[i] );
} // lowercase()


void prepend( char character ) // check
{
     char *ctemp;
     char *temp;
     temp = new char [ strlen( theString ) ];
     strcpy( temp, theString );

     ctemp = new char [2];
     ctemp [0] = character;
     ctemp [1] = '\0';

     delete [] theString;
     theString = new char [ strlen( temp ) + strlen( ctemp ) ];

     strcpy( theString, ctemp );
     strcat( theString, temp );

     delete [] ctemp;
     delete [] temp;
} // void prepend( char character )


void prepend( const char* string ) // check
{
     if( string != '\0' )
     {
         char* temp;

         temp = new char [ strlen( theString ) ];
         strcpy( temp, theString );

         delete [] theString;
         theString = new char [strlen( temp ) + strlen( string ) ];

         strcpy( theString, string );
         strcat( theString, temp );

         delete [] temp;
     }
} // void prepend( const char* string )


void prepend ( const charString& string ) // check
{
     char* temp;

     temp = new char [ strlen( theString ) ];
     strcpy (temp, theString);

     delete [] theString;
     theString = new char [ strlen( temp ) + strlen( string.theString ) ];

     strcpy( theString, string.theString );
     strcat( theString, temp );

     delete [] temp;
} // void prepend ( const charString& string )


void prepend ( const int integer) // check
{
     char number[20];

     sprintf (number, "%d", integer);
     prepend (number);
} // void prepend ( const int integer)


void remove( const char c ) // check
{
     char *newString;
     char *ptr = theString;
     unsigned long ul_Length = strlen( theString );

     newString = new char [ strlen( theString ) ];
     newString[0] = '\0';

     for( unsigned long i=0; i< ul_Length ; i++ )
     {
          if( theString[i] != c )
              strncat( newString, ptr, 1 );
          ptr++;
     }

     delete[] theString;
     theString = newString;
} // void remove( const char c )


void replace ( const char oldChar, const char newChar) // check
{
     unsigned long ul_Length = strlen( theString );
     for( unsigned long i=0; i<= ul_Length; i++ )
     {
          if( theString[i] == oldChar)
              theString[i] = newChar;
     }
} // void replace ( const char oldChar, const char newChar)


int replace (int i_Place, const char c_NewChar ) // check
{
     if( strlen( theString ) > i_Place)
     {
         theString[i_Place] = c_NewChar;
         return 1;
     }
     else
         return 0;
}


int reverse() // check
{
// test for empty string
     if( theString[0] == '\0' )
         return 0;

     unsigned long ul_length = strlen( theString );
     charString newString;

     for( unsigned long i= ul_length; i != -1 ;i--)
     {
          newString.append( theString[i] );
     }

     delete [] theString;
     theString = newString;

     return 1;
} // reverse()


void sliceFrontAndBack( unsigned long num ) // check
{
     sliceFront( num );
     sliceBack( num );
} // sliceFrontAndBack


void sliceFront (charString& string, unsigned long num) // ??
{
     char *newString;

     newString = new char [strlen (theString) + 1];
     strcpy (newString, theString);

     for( unsigned long i=0; newString[i] && i != num; i++ )
     newString[i] = '\0';

     delete[] string.theString;
     string.theString = newString;
     sliceFront (num);
} // sliceFront


int sliceFront( unsigned long num ) // check
{
// Modified by JBD 11-OCT-1996
// test for zero length slice
     if( num == 0 )
         return 0;

// test for empty string
     if( theString[0] == '\0' )
         return 0;

// test for num longer or equal to theString
     unsigned long ul_length = strlen( theString );
     if( ul_length <= num )
         return 0;

// Allocate the holding string
     char *newcharString = theString;
     charString charString_newString;
     for( unsigned long i = 0; i < num; i++)
          newcharString++;

     charString_newString = newcharString;

     delete [] theString;
     theString = newcharString;
     return 1;
} // sliceFront( unsigned long num )


int sliceFront( char c_charhold )
{
// Slice off the front until c_charhold or
// the end is found.

// test for empty string
     if( theString[0] == '\0' )
         return 0;

// Allocate the holding string
// and counting variable
     charString newString;
     unsigned long ul_Count = 0;

// find first occurance of c_charhold
     while( theString[ul_Count] != '\0' &&
            theString[ul_Count] != c_charhold )
     {
            ul_Count++;
     }

     while( theString[ul_Count] != '\0' )
     {
            newString.append( theString[ul_Count] );
            ul_Count++;
     }


     delete [] theString;
     theString = newString;
     return 1;
} // sliceFront( unsigned long num )


void sliceBack (unsigned long num)
{
     unsigned long i = 0;
     unsigned long j = 0;

     i = strlen (theString) - 1;
     if( i > 0 )
         while( (i >= 0) && num != j++)
                theString[i--] = '\0';
} // sliceBack( unsigned long )


int sliceBack ( char c_charhold )
{
// Search theString from front to back,
// adding to newstring and stop at c_charhold
// thecharString' end.

     if( theString[0] == '\0' )
         return 1;

     charString newcharString;      // the new string
     unsigned long ul_Counter = 0;  // counter

     while( theString[ul_Counter] != c_charhold &&
            theString[ul_Counter] != '\0')
     {
            newcharString.append( theString[ul_Counter] );
            ul_Counter++;
     }

     delete [] theString;
     theString = newcharString;

     return 1;
} // sliceBack( const char )


charString sliceToken() // check
{
     charString charString_token = token ();

     unsigned long ui_token_length = charString_token.length();

     if( !charString_token.isempty() )
     {
          sliceFront( ui_token_length );
     }

     return charString_token;
} // sliceToken()


void sliceToken ( const unsigned long tokensToSlice )
{
     charString token;

     for( unsigned long i=0; i<tokensToSlice; i++)
          sliceToken (token);
} // sliceToken


charString sliceToken ( const char c_charhold )
{
// Slices from fron to first instance of c_charhold.
// returns that token.

// Allocate return string and counter
     charString token;
     unsigned long ul_Counter = 0;
     int i_Found = 0;

// Check for empty string
     if( theString[0] == '\0' )
     {
     cout << "charString: sliceToken: 0 " << theString << endl;
         return token;
     }
     
// Populate the slice token
     while( theString[ul_Counter] != c_charhold &&
            theString[ul_Counter] != '\0' )
     {
     cout << "charString: sliceToken: 1 " << theString << endl;
            token.append( theString[ul_Counter] );
            ul_Counter++;
            if ( theString[ul_Counter] == c_charhold )
                 i_Found = 1;
     }

// Check if c_charhold was found
     if( i_Found )
     {
     cout << "charString: sliceToken: 2 " << theString << endl;
         // Slice theString
         charString newString;

         while( theString[ul_Counter] != '\0' )
         {
     cout << "charString: sliceToken: 3 " << theString << endl;
                newString.append( theString[ul_Counter] );
                ul_Counter++;
         }

         delete [] theString;
         theString = newString;
     }
     cout << "charString: sliceToken: 4 " << theString << endl;
     return token;
} // sliceToken


void sliceToken ( const char delimitor, int removeDelimitor)
{
     charString token;
     sliceToken (token, delimitor, removeDelimitor);
} // sliceToken


void sliceToken (charString& theToken)
{
     trimFront();
     theToken = token();
     sliceFront( theToken.length() );
     trimFront();
} // sliceToken


void sliceToken( charString& theToken, const char delimitor, int removeDelimitor)
{
     trimFront();
     theToken = token( delimitor );
     sliceFront( theToken.length());
     theToken.trimBack();
     if( removeDelimitor )
     {
         sliceFront( (unsigned long) 1);
         trimFront();
     }
} // sliceToken


int soundsLike ( const char* string ) const
{
     charString str_Front, str_Back;

     if( string == '\0')
         return 0;
     else
     {
         str_Front = soundexCodeOf (theString);
         str_Back = soundexCodeOf (string );
// determine if the soundex code could be determined by checking
// for the empty string
//
         if( str_Front.isempty() || str_Back.isempty())
             return 0;
         else
             return (str_Front == str_Back);
     }
} // soundsLike


int soundsLike ( const charString& string ) const
{
     return ( soundsLike( string.theString ));
} // soundsLike


int subStringSearch( char* p_String )
{
// search for occurance of p_String in theString
      unsigned int ui_theString = strlen( theString );
      unsigned int ui_String    = strlen( p_String );
      unsigned int ui_One = 0;
      unsigned int ui_Two = 0;
      int ui_Result = 0;

      if( p_String == '\0' || theString == '\0' )
          return 0;

      if( ui_theString < ui_String )
          return 0;
      for( ui_One = 0; ui_One < ui_theString; ui_One++ ) // main loop
      {
             if( theString[ui_One] == p_String[ui_Two] ) // find 1st instance of p_String
             {
                 while( ui_Two < ui_String )
                 {
                        if( theString[ui_One] == p_String[ui_Two] )
                        {
                            ui_One++;
                            ui_Two++;
                        }
                        else
                        {
                            ui_Two = 0;
                            break;
                        }
                 }

                 if( ui_Two == ui_String )
                     ui_Result++;
             }
      }
      return ui_Result;
}

double toDouble() const // check
{
     return atof( theString );
} // toDouble()


int toInt() const // check
{
     return atoi( theString );
} // toInt()


long toLongDEC( charString &charString_A ) const // check
{
     return strtol( theString, &charString_A.theString, 10 );
} // toLongDEC


long toLongHEX( charString &charString_A ) const // check
{
     return strtol( theString, &charString_A.theString, 16 );
} // toLongHEX


long toLongOCT( charString &charString_A ) const // check
{
     return strtol( theString, &charString_A.theString, 8 );
} // toLongOCT


charString token () const // check
{
// token() : Returns the first non-space sequence of characters.
//
//   Example: token() on "  hello world!"  returns "hello"
//   Example: token() on "hello"           returns "hello"
//   Example: token() on "  hello   "      returns "hello"
//

     unsigned long ul_length = 0;
     charString theToken;

// skip over the preceeding spaces and set a pointer
     while(  !isspace( theString[ ul_length ] ))
     {
            theToken.append( theString[ ul_length ] );
            ul_length++;
     }

     return theToken;
} // token()

charString token ( const char c_delimitor) const // check
{
// token ( const char) : Returns the sequence of characters up to
// the delimitor. If the delimitor is not found, the original string,
// less any preceeding blank spaces, is returned.
//
//   Example: token (",") on "  hello world, how"  returns "hello world"
//   Example: token (",") on "hello world"         returns "hello world"
//   Example: token (",") on "   hello world,,, "  returns "hello world"
     unsigned long ul_length = 0;
     charString theToken;

// skip over the preceeding characters
     while( theString[ ul_length ] != c_delimitor )
     {
            theToken.append( theString[ ul_length ] );
            ul_length++;
     }

     return theToken;
} // token ( const char c_delimitor)


void trim ()
{
     trimFront();
     trimBack();
} // trim ()


void trim ( const char c)
{
     trimFront( c );
     trimBack( c );
} // trim ( const char c)


unsigned long trimBack() // check
{
     unsigned long ul_index = strlen (theString) - 1;
     unsigned long ul_count = 0;

     if( theString[0] == '\0' )
         return ul_count;

     while( isspace( theString[ul_index] ))
            ul_index--;

     if( ul_index )
     {
         charString c_Newchar;
         while( ul_count < ul_index )
         {
             c_Newchar.append( theString[ul_count] );
             ul_count++;
         }
         delete [] theString;
         theString = c_Newchar;
     }
     return ul_count;
} //trimBack ()


unsigned long trimBack( const char c) // check
{
     if( theString[0] == '\0' )
         return 0;

     unsigned long ul_index = strlen (theString) - 1;
     unsigned long ul_count = 0;

     while( (ul_index >= 0) && c == theString[ul_index])
     {
            theString[ul_index--] = '\0';
            ul_count++;
     }

     if( ul_count )
     {
         char* c_Newchar = new char [ul_index - ul_count];
         strcpy( c_Newchar, theString );
         theString = c_Newchar;
     }
     return ul_count;
} // trimBack ( const char c)


unsigned long trimFront() // check
{
     if( theString[0] == '\0' )
         return 0;


     if( !isspace( theString[0] ) )
         return 0;

     unsigned long ul_marker = 0;

// count white space
     while( isspace( theString[ul_marker] ))
     {
           ul_marker++;
     }

     if( ul_marker ) // if white space found
     {
         charString newString;

         while( theString[ ul_marker - 1 ] != '\0' )
         {
                newString.append( theString[ ul_marker - 1 ] );
                ul_marker++;
         }

         newString.append( theString[ ul_marker - 1 ] );
         
         delete [] theString;
         theString = newString;
         return 1;
     }
     return 0;
} // trimFront()


unsigned long trimFront ( const char c) // check
{
     unsigned long ul_marker = 0;
     unsigned long ul_index = strlen( theString );

     if( theString[0] == '\0' )
         return ul_marker;

     while( (theString[ul_marker] != c) && (ul_marker != ul_index ))
           ul_marker++;

     if( ul_marker == ul_index )
         return 0;
         
     if( ul_marker )
     {
         charString newString;

         while( theString[ul_marker ] != '\0' )
         {
                newString.append( theString[ul_marker ] );
                ul_marker++;
         }

         newString = theString[ul_marker];
         delete [] theString;
         theString = newString;
         return 1;
     }
     return 0;
} // trimFront ( const char c)


void uppercase() // check
{
// Convert theString to all uppercase.
     unsigned long ul_theStringLength = strlen( theString );
     for( unsigned long int i=0; i <= ul_theStringLength; i++)
          theString[i] = toupper( theString[i] );
} // uppercase
};
#endif // charString.cc

Internal Links

Parent Article: Programming Portfolio