Question

2. (50 marks) A string in C++ is simply an array of characters with the null character(\0)

used to mark the end of the string. C++ provides a set of string handling function in

<string.h> as well as I/O functions in <iostream>. With the addition of the STL (Standard

Template Library), C++ now provides a string class.

But for this assignment, you are to develop your own string class. This will give you a

chance to develop and work with a C++ class, define constructors and destructors, define

member functions outside of the class body, develop a copy constructor and assignment

operator (and understand why!), work with C-Style strings and pointers, dynamically

allocate memory and free it when done.

Of course, you must also do suitable testing which implies writing a main function that

uses your new string class. Submit your assignment under URCourses.The following is the skeleton of the Mystring class declaration. Mystring.h file is

provided. You must produce the Mystring.cpp and main.cpp files.

class Mystring

{

private:

char *pData;

//pointer to simple C-style representation of the string

//(i.e., sequence of characters terminated by null)

//pData is only a pointer. You must allocate space for

//the actual character data

int length;

//length of the string

//…

//possibly other private data

public:

MyString();

//constructor --- create empty string

MyString(char *cString); //constructor --- create a string whose data is a copy of

//cString

~MyString();

//destructor -- don't forget to free space allocated by the constructor

//i.e., the space allocated for the character data

MyString(MyString const& s); //override the default copy constructor --- why?

//important -- think about it -- possible test question

MyString operator = (MyString const& s); //override default assignment operator

void Put();

//output string

void Reverse();

//reverse the string

MyString operator + (MyString const& s); //concatenation operator

// …

//other useful member functions

//as you wish

};

In addition, prepare a graphical explanation of each of your member functions. (Pseudo

code or flowchart or some diagram to show your design.)#ifndef MYSTRING_H

#define MYSTRING_H

class MyString

{

private:

char *pData;

//pointer to simple C-style representation of the string

//(i.e., sequence of characters terminated by null)

//pData is only a pointer. You must allocate space for

//the actual character data

int length;

//length of the string

// …

//possible other private data

public:

MyString();

//constructor --- create empty string

MyString(char *cString); //constructor --- create a string whose data is a copy of

//cString

~MyString();

//destructor -- don't forget to free space allocated by the constructor

//i.e., the space allocated for the character data

MyString(MyString const& s); //override the default copy constructor --- why?

//important -- think about it -- possible test question

MyString operator = (MyString const& s); //override default assignment operator

void Put();

//output string

void Reverse();

//reverse the string

MyString operator + (MyString const& s); //concatenation operator

// …

//other useful member functions

//as you wish

};

#endif // MYSTRING_H

Answer 1

Pseudocode for the functions of MyString class:

MyString():
   pData -> NULL
   length -> 0

MyString(char* cString):
   len -> length(cString)
   Allocate memory to pData
   pData -> cString
   length -> len

MyString(MyString const& s):
   len -> s.length
   Allocate memory to pData
   pData -> s.pData
   length -> len

operator=(MyString const& s):
   Free previously allocated string memory
   len -> s.length
   Allocate memory to pData
   pData -> s.pData
   length -> len
   Return this pointer

operator+(MyString const& s):
   len -> length + s.length
   Reallocate memory to pData
   pData[this.length:] -> s.length
   length ->len
   Return this pointer

Put():
   Display pData to console

Reverse():
   low -> 0
   high -> length - 1
   while low < high:
       swap (pData[low], pData[high])
       low = low + 1
       high = high - 1

~MyString():
   Free memory allocated to pData

Declaration of MyString class (mystring.h):

#ifndef MYSTRING_H
#define MYSTRING_H

class MyString
{
private:
   char *pData;   //   Contains the string
   int length;       //   Length of the string
public:
   MyString();       //   Default constructor
   MyString(char *cString);       //   Parameterized constructor
   MyString(MyString const& s);   //   Copy constructor
  
   MyString operator=(MyString const& s);   //   Assginment operator
   MyString operator+(MyString const& s);   //   Concatenation operator
   void Put();       //   Display the string
   void Reverse();   //   Reverse the string
  
   ~MyString();   //   Destructor
};

#endif   //   MYSTRING_H

Definitions of member functions of MyString class (mystring.cpp):

#include <iostream>
#include <string.h>
#include "mystring.h"

MyString::MyString()
{
   this->pData = NULL;   //   Initializing pointer to NULL
   this->length = 0;   //   Current length of string is zero
}

MyString::MyString(char *cString)
{
   int len = strlen(cString);
   this->pData = (char*)malloc(sizeof(char) * len);   //   Allocate memory to string
   strcpy(this->pData, cString);   //   Copy cString to pData
   this->length = len;               //   Update length
}

MyString::MyString(MyString const& s)
{
   this->pData = (char*)malloc(sizeof(char) * s.length);   //   Allocate memory to string
   strcpy(this->pData, s.pData);   //   Copy string in s to pData
   this->length = s.length;       //   Update length
}

MyString MyString::operator=(MyString const& s)
{
   int len = s.length;               // Calculate length of new string
   this->pData = (char*)realloc(this->pData, sizeof(char) * len);   //   Reallocate memory for the new string
   strcpy(this->pData, s.pData);   //   Copy string in s to pData
   this->length = s.length;       //   Update length
   return *this;
}

MyString MyString::operator+(MyString const& s)
{
   int len = this->length + s.length;   //   Calculate length of new string
   this->pData = (char*)realloc(this->pData, sizeof(char) * len);   //   Reallocate memory to occupy the new string
   strcpy(this->pData + this->length, s.pData);   //   Append string in s behind the string already in pData
   this->length = len;                   //   Update length
   return *this;
}

void MyString::Put()
{
   std::cout << pData;
}

void MyString::Reverse()
{
   int low = 0, high = this->length-1;
   while(low < high)
   {
       //   Swap the two ends
       char temp = pData[low];
       pData[low] = pData[high];
       pData[high] = temp;
      
       //   Update the indexes
       ++low, --high;
   }
}

MyString::~MyString()
{
   free(this->pData);       //   Free memory allocateed to pData
}

Driver function (main.cpp):

#include <iostream>
#include "mystring.h"

using namespace std;

int main()
{
   MyString str = "Hello";
   MyString str1;   //   Default Constructor
   MyString str2("Hello");   //   Parameterized constructor
   MyString str3 = str;   //   Copy constructor
   str1 = str;

   str.Reverse();
   str.Put();
   cout << endl;
  
   str1.Put();
   cout << endl;

   str2 = str2 + str;
   str2.Put();
   cout << endl;

   str3.Put();
   cout << endl;
   return 0;
}