Can someone impliment the toReverse() function as well as the ++ operator?

On the foundation of the previous Text ADT homework, add the following methods to the Text class: 1. Implement the function toReverse() to reverse recursively the order of letters of the given Text object. Test your implementation by activating LAB2_TEST1. (15 pts) Function prototype: Text toReverse(Text obj, int position) const; 2. Implement the operators +=. Test it by activating LAB2_TEST2. (15 pts) Function prototype: Text operator += (const Text &input2);

textio.cpp

//--------------------------------------------------------------------

//

// Laboratory 1, In-lab Exercise 1 textio.cpp

//

// String input/output operations

//

//--------------------------------------------------------------------

#include

#include

#include "Text.h"

//--------------------------------------------------------------------

istream & operator >> ( istream &input, Text &inputText )

// Text input function. Extracts a string from istream input and

// returns it in inputText. Returns the state of the input stream.

{

const int textBufferSize = 256; // Large (but finite)

char textBuffer [textBufferSize]; // text buffer

// Read a string into textBuffer, setw is used to prevent buffer

// overflow.

input >> setw(textBufferSize) >> textBuffer;

// Apply the Text(char*) constructor to convert textBuffer to

// a string. Assign the resulting string to inputText using the

// assignment operator.

inputText = textBuffer;

// Return the state of the input stream.

return input;

}

//--------------------------------------------------------------------

ostream & operator << ( ostream &output, const Text &outputText )

// Text output function. Inserts outputText in ostream output.

// Returns the state of the output stream.

{

output << outputText.buffer;

return output;

}

***************************************************************

text.h

//--------------------------------------------------------------------

//

// Laboratory 1 Text.h

// **Instructor's Solution**

// Class declaration for the array implementation of the Text ADT

//

//--------------------------------------------------------------------

#ifndef TEXT_H

#define TEXT_H

#include

#include

using namespace std;

class Text

{

public:

// Constructors and operator=

Text ( const char *charSeq = "" ); // Initialize using char*

Text ( const Text &other ); // Copy constructor

void operator = ( const Text &other ); // Assignment

// Destructor

~Text ();

// **** Lab 2 ****

Text operator += (const Text &input2);

char toReverse(Text t1, int t) const;

// ***************

// Text operations

int getLength () const; // # characters

char operator [] ( int n ) const; // Subscript

void clear (); // Clear string

// Output the string structure -- used in testing/debugging

void showStructure () const;

//--------------------------------------------------------------------

// In-lab operations

// toUpper/toLower operations (Programming Exercise 2)

Text toUpper( ) const; // Create upper-case copy

Text toLower( ) const; // Create lower-case copy

// Relational operations (Programming Exercise 3)

bool operator == ( const Text& other ) const;

bool operator < ( const Text& other ) const;

bool operator > ( const Text& other ) const;

private:

// Data members

int bufferSize; // Size of the string buffer

char *buffer; // Text buffer containing a null-terminated sequence of characters

// Friends

// Text input/output operations (In-lab Exercise 1)

friend istream & operator >> ( istream& input, Text& inputText );

friend ostream & operator << ( ostream& output, const Text& outputText );

};

#endif

**********************************************************************

test1.cpp

//--------------------------------------------------------------------

//

// Laboratory 1 test1.cpp

//

// Test program for the operations in the Text ADT

//

//--------------------------------------------------------------------

#include

#include "Text.h"

#include "config.h"

//--------------------------------------------------------------------

//

// Function prototype

void copyTester ( Text copyText ); // copyText is passed by value

void print_help ( );

//--------------------------------------------------------------------

int main()

{

Text a("a"), // Predefined test text objects

alp("alp"),

alpha("alpha"),

epsilon("epsilon"),

empty,

assignText, // Destination for assignment

inputText, // Input text object

inputText2;

int n; // Input subscript

char ch, // Character specified by subscript

selection; // Input test selection

// Get user test selection.

print_help();

// Execute the selected test.

cin >> selection;

cout << endl;

switch ( selection )

{

case '1' :

// Test 1 : Tests the constructors.

cout << "Structure of various text objects: " << endl;

cout << "text object: alpha" << endl;

alpha.showStructure();

cout << "text object: epsilon" << endl;

epsilon.showStructure();

cout << "text object: a" << endl;

a.showStructure();

cout << "empty text object" << endl;

empty.showStructure();

break;

case '2' :

// Test 2 : Tests the length operation.

cout << "Lengths of various text object:" << endl;

cout << " alpha : " << alpha.getLength() << endl;

cout << " epsilon : " << epsilon.getLength() << endl;

cout << " a : " << a.getLength() << endl;

cout << " empty : " << empty.getLength() << endl;

break;

case '3' :

// Test 3 : Tests the subscript operation.

cout << "Enter a subscript : ";

cin >> n;

ch = alpha[n];

cout << " alpha[" << n << "] : ";

if ( ch == '\0' )

cout << "\\0" << endl;

else

cout << ch << endl;

break;

case '4' :

// Test 4 : Tests the assignment and clear operations.

cout << "Assignments:" << endl;

cout << "assignText = alpha" << endl;

assignText = alpha;

assignText.showStructure();

cout << "assignText = a" << endl;

assignText = a;

assignText.showStructure();

cout << "assignText = empty" << endl;

assignText = empty;

assignText.showStructure();

cout << "assignText = epsilon" << endl;

assignText = epsilon;

assignText.showStructure();

cout << "assignText = assignText" << endl;

assignText = assignText;

assignText.showStructure();

cout << "assignText = alpha" << endl;

assignText = alpha;

assignText.showStructure();

cout << "Clear assignText" << endl;

assignText.clear();

assignText.showStructure();

cout << "Confirm that alpha has not been cleared" << endl;

alpha.showStructure();

break;

case '5' :

// Test 5 : Tests the copy constructor and operator= operations.

cout << "Calls by value:" << endl;

cout << "alpha before call" << endl;

alpha.showStructure();

copyTester(alpha);

cout << "alpha after call" << endl;

alpha.showStructure();

cout << "a before call" << endl;

a.showStructure();

a = epsilon;

cout << "a after call" << endl;

a.showStructure();

cout << "epsilon after call" << endl;

epsilon.showStructure();

break;

#if LAB1_TEST1

case '6' : // In-lab Exercise 2

// Test 6 : Tests toUpper and toLower

cout << "Testing toUpper and toLower."

<< "Enter a mixed case string: " << endl;

cin >> inputText;

cout << "Input string:" << endl;

inputText.showStructure();

cout << "Upper case copy: " << endl;

inputText.toUpper().showStructure();

cout << "Lower case copy: " << endl;

inputText.toLower().showStructure();

break;

#endif // LAB1_TEST1

#if LAB1_TEST2

case '7' : // In-lab Exercise 3

// Test 7 : Tests the relational operations.

cout << " left right < == > " << endl;

cout << "--------------------------------" << endl;

cout << " alpha epsilon " << (alpha

<< " " << (alpha==epsilon) << " "

<< (alpha>epsilon) << endl;

cout << " epsilon alpha " << (epsilon

<< " " << (epsilon==alpha) << " "

<< (epsilon>alpha) << endl;

cout << " alpha alpha " << (alpha

<< (alpha==alpha) << " " << (alpha>alpha) << endl;

cout << " alp alpha " << (alp

<< (alp==alpha) << " " << (alp>alpha) << endl;

cout << " alpha alp " << (alpha

<< (alpha==alp) << " " << (alpha>alp) << endl;

cout << " a alpha " << (a

<< (a==alpha) << " " << (a>alpha) << endl;

cout << " alpha a " << (alpha

<< (alpha==a) << " " << (alpha>a) << endl;

cout << " empty alpha " << (empty

<< (empty==alpha) << " " << (empty>alpha) << endl;

cout << " alpha empty " << (alpha

<< (alpha==empty) << " " << (alpha>empty) << endl;

cout << " empty empty " << (empty

<< (empty==empty) << " " << (empty>empty) << endl;

break;

#endif // LAB1_TEST2

#if LAB2_TEST1

case '8' :

cout << "Input text to be reversed: ";

cin >> inputText;

inputText.toReverse(inputText, 0);

//inputText.showStructure();

break;

#endif // LAB2_TEST1

#if LAB2_TEST2

case '9':

cout << "Input text1 to be reversed: ";

cin >> inputText;

cout << "Input text2 to be reversed: ";

cin >> inputText2;

inputText += inputText2;

inputText.toReverse(inputText, 0);

break;

#endif // LAB2_TEST2

default :

cout << "'" << selection << "' specifies an inactive or invalid test" << endl;

}

system("PAUSE");

return 0;

}

//--------------------------------------------------------------------

void copyTester ( Text copyText )

// Dummy routine that is passed a text object using call by value. Outputs

// copyText and clears it.

{

cout << "Copy of text object" << endl;

copyText.showStructure();

cout << "Clear copy" << endl;

copyText.clear();

copyText.showStructure();

}

//--------------------------------------------------------------------

void print_help()

{

cout << endl << "Tests:" << endl;

cout << " 1 Tests the constructors" << endl;

cout << " 2 Tests the length operation" << endl;

cout << " 3 Tests the subscript operation" << endl;

cout << " 4 Tests the assignment and clear operations" << endl;

cout << " 5 Tests the copy constructor and operator= operations" << endl;

cout << " 6 Tests the toUpper and toLower operations "

#if LAB1_TEST1

<< "(Active : "

#else

<< "(Inactive : "

#endif // LAB1_TEST1

<< "In-lab Exercise 2)" << endl;

cout << " 7 Tests the relational operations "

#if LAB1_TEST2

<< " (Active : "

#else

<< " (Inactive : "

#endif // LAB1_TEST2

<< "In-lab Exercise 3)" << endl;

cout << " 8 Tests the reverse operations" << endl;

cout << " 9 Tests the reverse and operator+= operations" << endl;

cout << "Select the test to run : ";

}

***********************************************************************

config.h

/**

* Text class (Lab 1) configuration file.

* Activate test 'N' by defining the corresponding LAB1_TESTN to have the value 1.

*/

#define LAB1_TEST1 0 // Programming exercise 2: toUpper and toLower

#define LAB1_TEST2 0 // Programming exercise 3: ==, <, and >

#define LAB2_TEST1 1 // Programming recursion

#define LAB2_TEST2 1 // Programming operation + and recursion

***************************************************************

text.cpp

#include

#include

#include

#include

#include "Text.h"

Text::Text ( const char *charSeq )

{

bufferSize=strlen(charSeq)+1;

buffer=new char[bufferSize];

strcpy(buffer,charSeq);

}

Text::Text ( const Text &other )

{

bufferSize=other.bufferSize;

buffer=new char[bufferChar];

strncpy(buffer,other.buffer,bufferSize);

}

void Text::operator = ( const Text &other )

{

clear();

bufferSize=other.bufferSize;

buffer=new char[bufferSize];

strncpy(buffer,other.buffer,bufferSize);

}

Text::~Text ()

{

clear();

}

int Text::getLength () const

{

if(buffersize==0)

return -1;

return strlen(buffer);

}

char Text::operator [] ( int n ) const

{

if(n

return buffer[n];

else

return 0;

}

void Text::clear ()

{

if(bufferSize>0)

{

delete[]buffer;

buffer=0;

}

bufferSize=0;

}

void Text::showStructure() const

void Text::showStructure () const

{

cout << "bufferSize: " << bufferSize << ", buffer: [ ";

int i;

for(i = 0; i < getLength(); i++)

cout << buffer[i] << " ";

for(; i < bufferSize; i++)

cout << "_ ";

cout << "] ";

}

Text Text::toUpper( ) const

{

Text upper(*this);

for(int i = 0; i < upper.getLength(); i++)

{

if(islower(upper[i]))

{

upper.buffer[i] = toupper(upper[i]);

}

}

return upper;

}

Text Text::toLower( ) const

{

Text lower(*this);

for(int i = 0; i < lower.getLength(); i++)

{

if(isupper(lower[i]))

{

lower.buffer[i] = tolower(lower[i]);

}

}

return lower;

}

char Text::toReverse(Text obj, int position) const

{

if(position < getLength())

{

toReverse(obj, position + 1);

cout << buffer[position];

}

return buffer[position];

}

// ********** Lab 2 *************

Text Text::operator += (const Text &input2)

{

int spaceReqd = getLength() + input2.getLength() + 1;

if(bufferSize >= spaceReqd)

{

strcat(buffer, input2.buffer);

}

else

{

char *buff = new char[spaceReqd];

strcpy(buff, buffer);

strcat(buff, input2.buffer);

clear();

buffer = buff;

bufferSize = spaceReqd;

}

}

istream & operator >> ( istream& input, Text& inputText )

{

char buff[1000];

input >> buff;

inputText.clear();

inputText.bufferSize = strlen(buff) + 1;

inputText.buffer = new char[inputText.bufferSize];

strcpy(inputText.buffer, buff);

return input;

}

ostream & operator << ( ostream& output, const Text& outputText )

{

if(outputText.getLength())

output << outputText.buffer;

return output;

}

// *******************************