CharString
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