Please help me to solve this problem. C++ code please.

Using the mystring.h and mystring.cpp (instead of including the standard library)

1) implement a text file formatting program. It takes a text file data.txt as an input file. The file has a few lines of text but the length(column) of the line is arbitrary. One line could have anywhere between 1 to 200 characters before a new line (carriage return). Your program should ask the number of column to the user and format the text file accordingly. For example, if a user types 65, every line should be aligned 65 long. You may have to combine two lines to one to eliminate the white spaces and blank lines, or split one to two.

2) in cases you need to change line in the middle of a word, you need to use a hyphen (- ) to connect a word between two lines.

3) There should be no more than one white space between two words. Multiple spaces, newlinesor tabs must be replaced with a space.

You can assume that a hyphen can be added after the maximum column. So if you're formatting a text to 60 columns and a word is starting at the 60th column, you can add hyphen at 61st. Only the hyphen can come at 61st. For the output, display the formatted text on screen and save it to data.out.

Hint: read Appendix F for the file I/O and string handling. You may find eat_white( ) function useful for removing white spaces. Read Standard C String & Character (Links to an external site.)and use appropriate functions like strcpy, strcat, memcmp etc.

/////////// Mystring.h///////////////////

// FILE: mystring.h

// CLASS PROVIDED: my_string

// This is a simple version of the Standard Library string.

// It is part of the namespace main_savitch_4, from the textbook

// "Data Structures and Other Objects Using C++"

// by Michal Main and Walter Savitch

//

// CONSTRUCTOR for the my_string class:

// string(const char str[ ] = "") -- default argument is the empty string.

// Precondition: str is an ordinary null-terminated string.

// Postcondition: The string contains the sequence of chars from str.

//

// CONSTANT MEMBER FUNCTIONS for the my_string class:

// size_t length( ) const

// Postcondition: The return value is the number of characters in the

// string.

//

// char operator [ ](size_t position) const

// Precondition: position < length( ).

// Postcondition: The value returned is the character at the specified

// position of the string. A string's positions start from 0 at the start

// of the sequence and go up to length( )-1 at the right end.

//

// MODIFICATION MEMBER FUNCTIONS for the my_string class:

// void operator +=(const string& addend)

// Postcondition: addend has been catenated to the end of the string.

//

// void operator +=(const char addend[ ])

// Precondition: addend is an ordinary null-terminated string.

// Postcondition: addend has been catenated to the end of the string.

//

// void operator +=(char addend)

// Postcondition: The single character addend has been catenated to the

// end of the string.

//

// void reserve(size_t n)

// Postcondition: All functions will now work efficiently (without

// allocating new memory) until n characters are in the string.

//

// void insert(size_t n)

// Postcondition: A hyphen is added to a string at position n or n+1

// depending on where n is in a string.

//

// void operator =(const my_string& source)

// Postcondition: The string has been set to be equal to source.

//

// NON-MEMBER FUNCTIONS for the my_string class:

// string operator +(const string& s1, const string& s2)

// Postcondition: The string returned is the catenation of s1 and s2.

//

// istream& operator >>(istream& ins, string& target)

// Postcondition: A string has been read from the istream ins, and the

// istream ins is then returned by the function. The reading operation

// skips white space (i.e., blanks, newlines, tabs) at the start of ins.

// Then the string is read up to the next white space or the end of the

// file. The white space character that terminates the string has not

// been read.

//

// ostream& operator <<(ostream& outs, const string& source)

// Postcondition: The sequence of characters in source has been written

// to outs. The return value is the ostream outs.

//

// void getline(istream& ins, string& target)

// Postcondition: A string has been read from the istream ins. The reading

// operation starts by skipping any white space, then reading all characters

// (skipping any additional whitespace, leaves only one space between

// words) until the newline character is read and discarded (but not

// added to the end of the string). The return value is ins.

//

// VALUE SEMANTICS for the my_string class:

// Assignments and the copy constructor may be used with string objects.

//

// TOTAL ORDER SEMANTICS for the string class:

// The six comparison operators (==, !=, >=, <=, >, and <) are implemented

// for the string class, forming a total order semantics, using the usual

// lexicographic order on strings.

//

// DYNAMIC MEMORY usage by the string class:

// If there is insufficient dynamic memory then the following functions call

// new_handler: The constructors, resize, operator +=, operator +, and the

// assignment operator.

#ifndef MYSTRING_H

#define MYSTRING_H

#include // Provides size_t

namespace hw4

{

class my_string

{

public:

// CONSTRUCTORS and DESTRUCTOR

my_string(const char str[ ] = "");

my_string(const my_string& source);

~my_string( );

// MODIFICATION MEMBER FUNCTIONS

void operator +=(const my_string& addend);

void operator +=(const char addend[ ]);

void operator +=(char addend);

void reserve(size_t n);

void operator =(const my_string& source);

void insert(size_t n);

// CONSTANT MEMBER FUNCTIONS

size_t length( ) const { return current_length; }

char operator [ ](size_t position) const;

// FRIEND FUNCTIONS

friend std::ostream& operator <<(std::ostream& outs, const my_string& source);

friend bool operator ==(const my_string& s1, const my_string& s2);

friend bool operator !=(const my_string& s1, const my_string& s2);

friend bool operator >=(const my_string& s1, const my_string& s2);

friend bool operator <=(const my_string& s1, const my_string& s2);

friend bool operator > (const my_string& s1, const my_string& s2);

friend bool operator < (const my_string& s1, const my_string& s2);

private:

char *sequence;

size_t allocated;

size_t current_length;

};

// NON-MEMBER FUNCTIONS for the string class

my_string operator +(const my_string& s1, const my_string& s2);

std::istream& operator >>(std::istream& ins, my_string& target);

void getline(std::istream& ins, my_string& target);

void eat_white(std::istream& ins, my_string& target);

}

#endif

//////////////mystring.cpp///////////////

// CLASS IMPLEMENTED: my_string (see mystring.h for documentation)

// INVARIANT for the my_string class:

// 1. The string is stored as a null-terminated string in the dynamic array

// that characters points to.

// 2. The total length of the dynamic array is stored in the member variable

// allocated.

// 3. The total number of characters prior to the null character is stored in

// current_length, which is always less than allocated.

#include // Provides stream tools

#include // Provides assert()

#include // Provides strcpy(), strcat(), strlen(), strcmp()

#include // Provides size_t, NULL

#include // Provides stream types

#include "mystring.h"

using namespace std;

namespace hw4

{

// CONSTRUCTORS and DESTRUCTOR

my_string::my_string(const char str[ ])

// Library facilities used: string.h

{

current_length = strlen(str);

allocated = current_length + 1;

sequence = new char[allocated];

strcpy(sequence, str);

}

my_string::my_string(const my_string& source)

// Library facilities used: string.h

{

sequence = new char[source.allocated];

current_length = source.current_length;

allocated = source.allocated;

strcpy(sequence, source.sequence);

}

my_string::~my_string( )

{

delete [ ] sequence;

}

// MODIFICATION MEMBER FUNCTIONS

// CONSTANT MEMBER FUNCTIONS

// In-lined: size_t length( ) const;

char my_string::operator [ ](size_t position) const

// Library facilities used: assert.h

{

assert(position < current_length);

return sequence[position];

}

// += Operator overloading.

void my_string::operator +=(const my_string& addend)

// Library facilities used: string.h

{

size_t totalLength;

totalLength = (current_length+1+addend.current_length);

if (allocated < totalLength)

reserve(totalLength);

strcat(sequence, addend.sequence);

current_length = totalLength - 1;

}

// += Operator overloading.

void my_string::operator +=(const char addend[ ])

// Library facilities used: string.h

{

size_t totalLength;

totalLength = current_length+1+strlen(addend);

if (allocated < totalLength)

reserve(totalLength);

strcat(sequence, addend);

current_length = totalLength - 1;

}

// += Operator overloading.

void my_string::operator +=(char addend)

// Library facilities used: string.h

{

char addstring[2];

addstring[0]=addend;

addstring[1]='\0';

size_t totalLength;

totalLength = (current_length+2);

if (allocated < totalLength)

reserve(totalLength);

strcat(sequence, addstring);

current_length = totalLength - 1;

}

void my_string::reserve(size_t n)

{

size_t i;

char *larger_string;

if (n == allocated)

return; // The allocated memory is already the right size

if (n < current_length+1)

n = current_length+1; // Can't allocate less than is being used

larger_string = new char[n];

for(i=0; i < current_length+1; i++)

larger_string[i] = sequence[i];

delete [ ] sequence;

sequence = larger_string;

allocated = n;

}

void my_string::insert(size_t n)

// Function to insert a hyphen between words in a string

{

size_t totalLength;

totalLength = current_length+2;

reserve(totalLength);

current_length = totalLength-1;

// Insert necessary hyphen at appropriate position

if ((sequence[n-1] == ' ') && (sequence[n+1] != ' '))

// Insert hyphen at column + 1 position

{

for (int i=current_length; i>n+1; --i)

sequence[i] = sequence[i-1];

sequence[n+1] = '-';

}

else

// Insert hyphen at column position

{

for (int i=current_length; i>n; --i)

sequence[i] = sequence[i-1];

sequence[n] = '-';

}

}

// = Operator overloading.

void my_string::operator =(const my_string& source)

{

size_t i;

char *new_string;

if (allocated != source.allocated)

{

new_string = new char[source.allocated];

delete [ ] sequence;

sequence = new_string;

allocated = source.allocated;

}

current_length = source.current_length;

for (i=0; i < current_length+1; i++)

sequence[i] = source.sequence[i];

}

// FRIEND FUNCTIONS

// << Operator overloading.

ostream& operator <<(ostream& outs, const my_string& source)

{

size_t i;

for (i=0; i < source.current_length; i++)

outs << source.sequence[i];

return outs;

}

// == Operator overloading.

bool operator ==(const my_string& s1, const my_string& s2)

// Library facilities used: string.h

{

int comp = strcmp(s1.sequence, s2.sequence);

return (comp==0);

}

// != Operator overloading.

bool operator !=(const my_string& s1, const my_string& s2)

// Library facilities used: string.h

{

int comp = strcmp(s1.sequence, s2.sequence);

return (comp!=0);

}

// >= Operator overloading.

bool operator >=(const my_string& s1, const my_string& s2)

// Library facilities used: string.h

{

int comp = strcmp(s1.sequence, s2.sequence);

return ((comp>0)||(comp==0));

}

// <= Operator overloading.

bool operator <=(const my_string& s1, const my_string& s2)

// Library facilities used: string.h

{

int comp = strcmp(s1.sequence, s2.sequence);

return ((comp<0)||(comp==0));

}

// > Operator overloading.

bool operator > (const my_string& s1, const my_string& s2)

// Library facilities used: string.h

{

int comp = strcmp(s1.sequence, s2.sequence);

return (comp>0);

}

// < Operator overloading.

bool operator < (const my_string& s1, const my_string& s2)

// Library facilities used: string.h

{

int comp = strcmp(s1.sequence, s2.sequence);

return (comp<0);

}

// + Operator overloading.

// NON-MEMBER FUNCTIONS for the String class

my_string operator +(const my_string& s1, const my_string& s2)

{

my_string combinedString;

combinedString += s1;

combinedString += s2;

return combinedString;

}

// >> Operator overloading.

istream& operator >>(istream& ins, my_string& target)

{

char c;

while (ins && isspace(ins.peek()))

ins.ignore();

target=""; // Set the target to the empty string.

while (ins && !isspace(ins.peek()))

{

ins >> c;

target += c; // Call the operator += with a char argument.

}

return ins;

}

void getline(istream& ins, my_string& target)

{

char c;

eat_white(ins, target); // Removes initial whitespace

target="";

ins.get(c);

while (ins && (c!=' '))

{

target += c;

if (ins && isspace(ins.peek()) && ins.peek()!=' ')

{

eat_white(ins, target); // Removes additional

// whitespace between words

target += ' ';

}

ins.get(c);

}

}

void eat_white(istream& ins, my_string& target)

{

while (ins && isspace(ins.peek()))

ins.ignore();

}

}