Introduction Here is a code in which i have created for the string class. This article tells how we can implement the functions of a string through making it a class. Code: //Header Files # include "classfile.h" /** * main () this is used to receive the choice of the user and perform the string operations as desired by the user. * */ int main() { int choice,length=0,position; //variable declaration. String s,s1,s2; //object declaration for the class String. char str[80]; //char array declaration. while(1){ menu(); //call to the function menu to display the options for the user. cin>>choice; //to take the input from the user i.e. his choice. fflush(stdin); //to flush the memory. switch(choice){ //this is to input a new string from the user and store this string string in the string class. case STRING_INSERT: cout<<"\n ENTER A STRING \n "; gets(str); //inputs a string from the user. s.Put(str); //calls the function Put to save this string into the string class. system("cls"); //clears the screen. Display(s); //displays the stored string,its length and memory allocated for it. break; //this is to reverse the string stored in the String class. case STRING_REVERSE: s.StrReverse(); //calls the function Reverse to reverse the string stored in the String class. system("cls"); //clears the screen. Display(s); //displays the stored string,its length and memory allocated for it. break; //this is to remove the starting and ending spaces from the stored string. case STRING_TRIM: s.Trim(); //calls the function Trim to remove the spaces from the starting and ending of the string stored in the String class. system("cls"); //clears the screen. Display(s); //displays the stored string,its length and memory allocated for it. break; //this is to add a new string to the existing string and store it in the class. case STRING_ADD: cout<<"\n ENTER A STRING TO ADD TO THE EXISTING ONE \n"; gets(str); //inputs a string from the user to add to the existing string. s.ConcatString(str);//calls the function ConcatString to add the two strings. system("cls"); //clears the screen. Display(s); //displays the stored string,its length and memory allocated for it. break; //this is to search where a given substring is present in the stored string and to return its position. case STRING_SUBSTRING_FIND: cout<<"\n Enter the string to find \n"; gets(str); //inputs a string from the user to find that substring in the stored string. position=s.Find(str); //calls the function Find to find the substring in the stored string. if(position==0){ cout<<"\n the search string does not exist"<<str; }else { system("cls"); //clears the screen. cout<<"\n the search string \t"<<str<<"exists at position \t\t"<<position; } break; //this is to search where a given substring is present in the stored string and to delete it from the string. case STRING_SUBSTRING_FIND_DELETE: cout<<"\n Enter the string to delete \n"; gets(str); //inputs a string from the user to find that substring in the stored string and delete it. position=s.Find(str);//calls the function Find to find the substring in the stored string. if(position==0){ cout<<"\n the search string does not exist hence cannot be deleted"<<str; }else { s.Delete(position,str);//calls the function Delete to delete the substring from the specified position. system("cls"); //clears the screen. Display(s); //displays the stored string,its length and memory allocated for it. } break; //this is to add a new string to the existing by use of operator overloading. case OPERATOR_PLUS_OVERLOADING: cout<<"\n ENTER A STRING \n "; gets(str); //inputs a string from the user. system("cls"); //clears the screen. cout<<"\n operator overloading for single object"; s=s+str; //calls the overloaded operator + for addition of a string to the same string object. Display(s); //displays the stored string,its length and memory allocated for it. cout<<"\n operator overloading for different objects"; s1=str; s2=s+s1; //calls the overloaded operator + for addition of a string object to the previous string object and stores into a new string object. Display(s2); //displays the stored string,its length and memory allocated for it. break; //this is to delete a sub string from a string by use of operator overloading. case OPERATOR_MINUS_OVERLOADING: cout<<"\n Enter the string to delete \n"; gets(str); //inputs a string from the user which is to be deleted. system("cls"); //clears the screen. cout<<"\n operator overloading for single object"; s=s-str; //calls the overloaded operator - to delete a sub string from the same string object. Display(s); //displays the stored string,its length and memory allocated for it. cout<<"\n operator overloading for different objects"; s=s-s1; //calls the overloaded operator - to delete a new string object from the previous string object and stores into the previous string object. Display(s); //displays the stored string,its length and memory allocated for it. break; //this is to enter a new string by use of the operator overloading. case OPERATOR_EQUALS_OVERLOADING: cout<<"\n Enter the String \n"; gets(str); //inputs a string from the user. system("cls"); //clears the screen. cout<<"overloading operator for string assignment"; s=str; //calls the overloaded operator = to assign the string to the s string object. Display(s); //displays the stored string,its length and memory allocated for it. cout<<"after overloading for string object"; s2=s; //calls the overloaded operator = to assign the s string object to s2 string object. Display(s2); //displays the stored string,its length and memory allocated for it. break; //this is to display the details of the class members. case DISPLAY: system("cls"); //clears the screen. Display(s); //displays the stored string,its length and memory allocated for it. break; //this is to exit from the application. case EXIT: s.Free(); //used to free the memory allocated for string object s. s1.Free(); //used to free the memory allocated for string object s1. s2.Free(); //used to free the memory allocated for string object s2. return 0; //exists from the application. } } _getch(); } /** * String(void) () is the constructor for the class * * @note * <ul> * <li>it allocates some values to the private members of the class. * </ul> * */ String::String(void) { vString=NULL; //initializes the string. vLength=0; //initializes the length of the string with 0. vSize=0; //initializes the size of the string with 0. } /** * String(void) () is the destructor for the class * * @note * <ul> * <li>it frees the memory allocated for the members of the class. * </ul> * */ String::~String(void) { Free(); } /** * Put () used to receive a new string from the user * */ void String::Put( char* pString ) { unsigned int length=0; length=StringLength(pString); if( vLength==0 || length > vLength){ vString=(char*)calloc((StringLength(pString) + 1),sizeof(char)); //allocates memory for the string. } StrCpy(vString,pString); //calls the function StrCpy to copy the string. vLength=length; //to calculate the length of the string stored in the class. vSize=vLength+1; //to calculate the size of the string. } /** * Display() used to display the string stored in the class. * * @note * <ul> * <li>it also displays the length of the string stored. * <li>it also displays the memory allocated for the string to be stored. * </ul> * */ void Display(String& pString) { cout<<"\n The String Is "<<pString.vString; //displays the string stored in the class. cout<<"\n The Length Of the String Is:- "<<pString.vLength; //displays the length of the stored string. cout<<"\n The Size Of The String Is:- "<<pString.vSize; //displays the size of the stored string. } /** * StrReverse () used to reverse the string stored in the class * */ void String::StrReverse() { char c; //variable initialization. char *tail,*head; //pointer to a char initializations. if(vString!=NULL) { head=vString; //allocates the starting address of the string to head. tail=vString+StringLength(vString)-1; //allocates the ending address of the string to head. //used to reverse the string . while( head < tail ) { c = *tail; *(tail--) = *head; *(head++) = c; } }else{ cout<<"REVERSING NOT POSSIBLE.N0 STRING PRESENT"; } } /** * Trim () used to remove the spaces at the starting and ending of the string of the class. * * @note * <ul> * <li>it makes use of the lTrim to remove the starting spaces. * <li>it makes use of the rTrim to remove the ending spaces. * </ul> * */ void String::Trim() { //checks whether there is a space at the starting or not ,if present calls Ltrim. if(vString[0]==char(32)) Ltrim(vString); //calls the Ltrim function to remove the starting spaces. //checks whether there is a space at the end or not ,if present calls Rtrim. if(vString[vLength-1]==char(32)) Rtrim(vString); //calls the Rtrim function to remove the ending spaces. vLength=StringLength(vString); //calls the function StringLength to calculate the length of the string. vSize=vLength+1; //to calculate the size of the string. } /** * ConcatString () used to add a string into an existing string. * */ void String:: ConcatString(char *pString) { char str[80]; //variable initialisation. int length; //variable initialisation. int len; //variable initialisation. len=StringLength(vString); //calls the function StringLength to calculate the length of the string. StrCpy(str,vString); //calls the StrCpy function to copy the string. length=len+StringLength(pString);//calls the function StringLength to calculate the total length of the string. (char*)realloc(vString,(length+1)*sizeof(char)); //used to reallocate the memory for the string. StrCpy(vString,str); //calls the StrCpy function to copy the string. //adds the new string at the end of the old string. while(*pString!=NULL) { vString[len++]=*pString; pString++; } vString[len]='\0'; //adds a terminating null to the new string. vLength=length; //used to get the length of the string stored. vSize=length+1; //used to get the size of the string stored. } /** * Find() used to find a substring of the string. * */ int String::Find(char *pString) { int plength,vLength,k,count=0,i; //variable initialization. plength=StringLength(pString); //calls the function StringLength to calculate the length of the string pLength. vLength=StringLength(vString); //calls the function StringLength to calculate the length of the string vLength. //checks whether the substring length is greater than the original string length. if(plength>vLength) return 0; //checks whether the substring is equal to the original string if their lengths are same. if(plength==vLength && strcmp(pString,vString)==0) return 1; //checks whether the substring is present in the original string when substring length is smaller than the original string length. for(k=0;k<=vLength;k++){ for(i=0;i<plength;i++){ if(vString[k+i]!=pString[i]){ break; }else{ count++; }if(count==plength){ return k+1; break; } } } return 0; } /** * Delete () used to delete a part of the string stored in the class. * * @note * <ul> * <li>it searches a substring of the string and if found it deletes it. * <ul> * */ void String::Delete(int pPos,char *pString) { int plength; //variable initialization. plength=StringLength(pString); //calls the function StringLength to calculate the length of the string pLength. //checks whether the position is less than or equal to the length of the stored string. while(pPos<=StringLength(vString)){ vString[pPos-1]=vString[pPos+plength-1]; //shifts the characters of the string to delete the substring. pPos++; //increments the position. } vLength=StringLength(vString); //calls the function StringLength to calculate the length of the string vLength. vSize=vLength+1; //to calculate the size of the string. } /** * Get() used to retrieve the string stored in the class. * */ char* String::Get ( void ) { return vString; //returns the string stored in the String class. } /** * Free() used to free the memory allocated for the string stored in the class. * */ void String::Free() { vString=NULL; free(vString); } /** * String& operator+ () used to overload the operator + for adding a new string to the existing string. * */ String& String::operator+(char* pStr) { int len; //variable initialisation. len=StringLength(pStr)+vLength+1; //calculates the total length of the two strings. //String *result=new String[]; //allocates memory for the string class. //this->vString=new char[len+1]; //allocates memory for the variable result. //StrCpy(result->vString, vString); //calls the StrCpy function to copy the string. this->ConcatString(pStr); //calls the ConcatString function to concat the string. this->vLength=StringLength(this->vString); //calls the function StringLength to calculate the length of the string vLength. this->vSize=this->vLength+1; //to calculate the size of the string. return *this; } /** * String& operator- () used to overload the operator - for deletion of a string. * */ String& String::operator-(char* pStr) { int position,len; //variable initialisation. String *result=new String[]; //allocates memory for the string class. len=StringLength(vString); //calls the function StringLength to calculate the length of the string vLength. result->vString=new char[len+1]; //allocates memory for the variable result. StrCpy(result->vString,vString); //calls the StrCpy function to copy the string. position=result->Find(pStr); //calls the function find to find the position of occurence of substring. //calls the delete function to delete the substring at the specified position. if(position!=0){ result->Delete(position,pStr); }else{ cout<<"\n deletion not possible"; } return *result; //returns the new string to be stored in the String class. } /** * String& operator= () used to overload the operator = for assignment of a new string. * */ String& String::operator=(char* pStr) { this->Put(pStr); //calls the Put function to receive a completely new string. return *this; //we retutn the string to store it in the String class. } /** * String& operator+ () used to overload the operator + for adding a new string object to the existing string object. * */ String& String::operator+(String& pStr) { String *temp; temp=new String[]; temp->vString=new char[vLength+1]; //allocates memory for the variable temp. StrCpy(temp->vString,vString); //calls the StrCpy function to copy the string. temp->ConcatString(pStr.vString); //calls the ConcatString function to concat the string. return *temp; //we return the string to store it in the String class. } /** * String& operator- () used to overload the operator - for deletion of a string object. * */ String& String::operator-(String& pStr) { int position,len; //variable initialisation. String *result=new String[]; //allocates memory for the string class. len=StringLength(vString); //calls the function StringLength to calculate the length of the string vLength. result->vString=new char[len+1]; //allocates memory for the variable result. StrCpy(result->vString,vString); //calls the StrCpy function to copy the string. position=result->Find(pStr.vString); //calls the function find to find the position of occurence of substring. //calls the delete function to delete the substring at the specified position. if(position!=0){ result->Delete(position,pStr.vString); }else{ cout<<"\n deletion not possible"; } return *result; } /** * String& operator= () used to overload the operator = for assignment of a new string object. * */ String& String::operator=(String& pStr) { this->Put(pStr.vString); //calls the Put function to receive a completely new string. return *this; //we retutn the string to store it in the String class. } /** * String(const String& Str) used to implement the working of the copy constructor. * */ String::String(const String& pStr) { int len; //variable initialisation. len=StringLength(pStr.vString); //calls the function StringLength to calculate the length of the string vLength. this->vString = new char[len+1]; //allocates memory . StrCpy(this->vString,vString); //calls the StrCpy function to copy the string. } /** * menu() used to create the menu. * * @note * <ul> * <li> this function is called whenever the menu is to be displyed. * <ul> * */ void menu() { cout<<"\n ENTER THE CHOICE FROM THE BELOW LIST\n\n\t" <<"\n *****************************************************************************\n\n\t" <<"\n\n 1 to insert any new string" <<"\n\n 2 to reverse the existing string" <<"\n\n 3 to trim the existing string from both sides i.e. left and right" <<"\n\n 4 to add another string to the existing string" <<"\n\n 5 to find particular string in the existing string" <<"\n\n 6 to find and remove a particular string from within the existing string" <<"\n\n 7 to overload the operator +" <<"\n\n 8 to overload the operator -" <<"\n\n 9 to overload the operator =" <<"\n\n 10 to display the stored string" <<"\n\n 11 to terminate application " <<"\n\n ****************************************************************************\n\n" <<"My Choice Is: "; } /** * StringLength () used to find the length of the string. * * @note * <ul> * <li>it receives the string whose length is to be found. * </ul> * */ int StringLength(char* pString) { int length=0; //variable initialisation. //calculates the no of characters in the string until a NULL is encountered. while(*pString!='\0'){ pString++; length++; } return length; //returns the length of the string. } /** * rTrim () used to remove all the spaces at the end of the String. * * @note * <ul> * <li>it receives the string whose end spaces are to be removed from the trim function. * </ul> * */ void Rtrim(char *pString) { int length; //variable initialisation. length=StringLength(pString); //calls the function StringLength to calculate the length of the string. //checks for the spaces from the end of the string and removes them accoringly. while(length>0) { if(*(pString+(--length))==char(32)) { } else { break; } } *(pString+length+1)='\0'; //allocates a null at the point before which a character other than space is found. } /** * lTrim () used to remove all the spaces at the starting of the String. * * @note * <ul> * <li>it receives the string whose starting spaces are to be removed from the trim function. * </ul> * */ void Ltrim(char *pString) { int index=0,i; //variable initialisation. //checks for the spaces from the starting of the string and counts the number. while(pString!=NULL) { if(*(pString+index)==char(32)) { index++; } else { break; } } //removes teh spaces by shifting the string. for(i=0;i<StringLength(pString);i++) { pString[i]=pString[i+index]; } } /** * StrCpy () used to display copy a given string into another. * */ void StrCpy(char *pSource, char *pTarget) { //copies char by char from one loction to another. while (*pSource++ = *pTarget++); }
Code: //Header Files #include <iostream> #include<conio.h> #include<string.h> #include<iomanip> using namespace std; /** * This is the class String. * */ class String{ public : // constructors and destructors String ( void ) ; ///< default constructor String (const String& pStr); ///<copy constructor ~String ( void ) ; ///< default destructor char* Get ( void ) ; ///<function used to get the value stored in vString. void Put ( char* pString ) ; ///<function used to insert any new string. friend void Display (String& pString); ///<function used to display the stored string. void StrReverse (); ///<function used to reverse the existing string. void Trim (); ///<function used to trim the existing string from both sides . void ConcatString ( char *pSource); ///<function used to add another string to the existing string. int Find (char *pString); ///< function used to find particular string in the existing string. void Delete (int pPos,char *pString); ///< function used to find and remove a particular string from within the existing string void Free (); ///<used to free the memory. // operator overload functions String& operator+ (char* pStr ) ; ///< + operator overloaded for string String& operator- (char* pStr ) ; ///< - operator overloaded for string String& operator= (char* pStr); ///< = operator overloaded for string String& operator+ (String& pStr); ///< + operator overloaded for class objects String& operator- (String& pStr); ///< - operator overloaded for class objects String& operator= (String& pStr); ///< = operator overloaded for class objects private: char* vString ; ///< pointer to char string unsigned int vLength ; ///< length of stored string unsigned int vSize; ; ///< memory allocated } ;
i tried your article ,its a nice one . i feel the class is of much more use thanusing normal string functions