Question

Please help! Comments added in would be a great help. Thank you!

T-Mobile Wi-Fi 10:33 AM * 85% Objectives: The main objectives of this project are to test your ability to create and use dynamic memory, and to review your knowledge to manipulate classes, pointers and iostream to all extents For this project you will create your own String class. You may use square bracket-indexing pointers, references, all operators, as well as the <string.h> or <estring library functions however the std::atring type is still not allowed) The following header file extract gives the required specifications for the class: /Necessary preprocessoe Idefine(s) / /Necessary include(s) You can include ccstring> or <string.h //class specification class Hystringt publicr 1(3) 1(2) Mystring (const char* str) Mystring (const Mystring& other)i HystringO 143) sise t siseo const size t lengtho const const charstro const /F(s) 1(6) 1167) bool operator(const Mystring& other) const MyString& operators (const Hystrin 96 ) Mystring operators (const Hystringi otber ryStr) const 10) char& operatorl1 (size t index) const ehars operatorll (size t index) comst 748) 749) (31a) 1/(11b) friend ostreans operatorce(ostreams os, const Hystring& ystr) 12) private void buffer deallocateO void buffer allocate(size t size) char buffer size t size 7(33) 7(a4) The MyString Class will contain the following private data members m beffer, a chan-type pointer, pointing to the Dynamically Allocated data. Note: This is no longer a static array. Dynamie Memory management has to guarantee that it points to a properly allocated memory region, otherwise Segmentation Faults will occur in your program. Also, Dynamic Memory management has to guarantce that it is properly deallocated when appropriate, and when its size has to chamge r m size,asize t member, denoting how many characters are currently allocated for m buffer. Noe that this has to be properly initialized and updated each time the dynamically allocated tmemoy is changad will have the folowing private helper methodsa (13) buffer deallocate - will deallocate the dynamic memory pointed to by m buffet Note: The m size which keeps track of m buffer has to be updated too. (14) buffer allocate-will allocate the required size t size number of char elements and point m buffer to it. It also has to check whether there is an already allocated space foe m buffer, and properly deallocate it prior to reallocating the new memory required Nole The m size which keeps track of m buffer has so be updated too. Also you should at least be checking whether the nev expression used to allocate data succeded or failed (you can check if it evaluated to & NULL valac).(Hin: You may also want to try implementing the "correct" way via exception handling for the dynamic memory allocation) and will have the following publik member functions

Input file

Answer 1

main.cpp

#include <iostream>

#include "MyString.h"

using namespace std;

int main(){

//(1) tested
cout << endl << "Testing Default ctor" << endl;
MyString ms_default;
cout << "Value: " << ms_default << endl;

//(2) tested
cout << endl << "Testing Parametrized ctor" << endl;
MyString ms_parametrized("MyString parametrized constructor!");
cout << "Value: " << ms_parametrized << endl;

//(3)
cout << endl << "Testing Copy ctor" << endl;
MyString ms_copy(ms_parametrized);
cout << "Value: " << ms_copy << endl;

//(4)
cout << endl << "Testing Dynamic Allocation with new / Deallocation with delete expressions" << endl;
MyString* ms_Pt = new MyString("MyString to be deleted…");
cout << "Ms_Pt Value: " << *ms_Pt << endl;
delete ms_Pt;
ms_Pt = NULL;

//(5),(6)
cout << endl << "Testing Size and Length helper methods" << endl;
MyString ms_size_length("Size and length test");
cout << ms_size_length.size() << endl;
cout << ms_size_length.length() << endl;

//(7)
cout << endl << "Testing c_str conversion helper method" << endl;
MyString ms_toCstring("C-String equivalent successfully obtained!");
cout << ms_toCstring.c_str() << endl;

//(8)
cout << endl << "Testing Equality operator==" << endl;
MyString ms_same1("The same"), ms_same2("The same");
if (ms_same1==ms_same2)
    cout << "Equality: Same success" << endl;
MyString ms_different("The same (NOT)");
if (!(ms_same1==ms_different))
    cout << "Equality: Different success" << endl;

//(9)
cout << endl << "Testing Assignment operator=" << endl;
MyString ms_assign("MyString before assignment");
cout << ms_assign << endl;
ms_assign = MyString("MyString after performing assignment");
cout << ms_assign << endl;

//(10)
cout << endl << "Testing operator+" << endl;
MyString ms_append1("Why does this");
MyString ms_append2(" work when its invokes?");
MyString ms_concat = ms_append1+ ms_append2;
cout << ms_concat << endl;

//(11)
cout << endl << "Testing operator[]" << endl;
MyString ms_access("Access successful (NOT)");
ms_access[17] = 0;

//(12)
cout << ms_access << endl;
return 0;
}

MyString.cpp

#include "MyString.h"

//default constructor
MyString::MyString()
{
m_buffer = NULL;
buffer_allocate(0);
}

//parameterized constructor
MyString::MyString (const char * str)
{
m_buffer = NULL;
size_t len = strlen(str);
buffer_allocate(len);
std::strcpy (m_buffer, str);
}

MyString::MyString (const MyString& srcStr)
{
buffer_allocate (srcStr.m_size);
std::strcpy (m_buffer, srcStr.m_buffer);
}

/*
~MyString:
    Deallocates the memory created for a char *
*/
MyString::~MyString()
{
delete [] m_buffer;
}

void MyString::buffer_allocate (size_t size)
{
if(m_buffer != NULL)
    buffer_deallocate();
m_size = size;
m_buffer = new char [m_size + 1];
m_buffer[0] = '\0';
}

/*
buffer_deallocate:
    Deallocates the memory pointed to
    by the m_buffer member and updates
    the size to zero.
*/
void MyString::buffer_deallocate()
{
    if(m_buffer != NULL)
    {
      delete [] m_buffer;
      m_buffer = NULL;
      m_size = 0;
    }
    else
      return;
}

/*
size:
    Returns the size of the buffer in bytes.
*/
size_t MyString::size () const
{
return (sizeof(m_buffer));
}

/*
length:
    returns the length of the buffer as a valid data semantic
*/
size_t MyString::length() const
{
size_t len = std::strlen(m_buffer);
return len;
}

const char* MyString::c_str() const
{
if(m_buffer)
    return m_buffer;
else
{
    char * cstr = new char [1];
    cstr[0] = '\0';
    return cstr;
}

}

/*
operator==:
    Checks if the calling object represents the same string as another
    MyString object, and return true (or false) respectively.
*/
bool MyString::operator== (const MyString& srcStr) const
{
return (std::strcmp(m_buffer, srcStr.m_buffer) == 0);
}

/*
opertor=:
    assign a new value to the calling object's string data
    based on the data passed as a parameter.
    Reference is returned for cascading.
*/
MyString& MyString::operator= (const MyString& srcStr)
{
//if this is the same object, just return it
if(this == &srcStr)
    return *this;
//if there is a value in the buffer, delete it
buffer_deallocate();
//initializing the contents of the srcStr
buffer_allocate(srcStr.m_size);
std::strcpy(m_buffer, srcStr.m_buffer);
return *this;
}

/*
operator+:
    concatenates C-string equivalent data of srcStr object
    and returns it by value, invoking the copy constructor.
*/
MyString MyString::operator+ (const MyString& srcStr) const
{
//create temporary object
MyString temp;
//store the total size of all the buffer sizes
temp.m_size = m_size + srcStr.m_size;
//allocate memory to hold the total size of all elements
temp.m_buffer = new char [temp.m_size + 1];
//copy the calling objects data into the newly allocated temp
std::strcpy(temp.m_buffer, m_buffer);
//concatenate the srcStr to the newly allocated buffer
std::strcat(temp.m_buffer, srcStr.m_buffer);
//return the object created (invokes the copy constructor).
return temp;
}

/*
operator[]:
    by reference accessing of a specific character at index of size_t
    within the allocated m_buffer. This allows access to MyString data
    by reference, with read/write access.
*/
char& MyString::operator[] (size_t index)
{
return m_buffer[index];
}

/*
operator[]:
    by reference access of a specific character at index
    but with read-only priviliges.
*/
const char& MyString::operator[] (size_t index) const
{
return m_buffer[index];
}

/*
operator<<
    Friend operator that writes the values of the MyString object
    to the calling routine requesting.
*/
std::ostream& operator<<(std::ostream& os, const MyString& myStr)
{
size_t i = 0;
while(i < myStr.m_size)
{
    os << myStr.m_buffer[i++];
}
os << std::endl << "Length: " << myStr.m_size;
return os;
}

MyString.h

#ifndef MYSTRING_H_
#define MYSTRING_H_

#include <iostream>
#include <cstring>

const int MAX_BUF = 255;

class MyString{

public:
    MyString();
    MyString(const char* srcStr);
    MyString(const MyString& srcStr);
    ~MyString();

    size_t size() const;
    size_t length() const;
    const char* c_str() const;

    bool operator== (const MyString& srcStr) const;
    MyString& operator= (const MyString& srcStr);
    MyString operator+ (const MyString& srcStr) const;
    char& operator[] (size_t index);
    const char& operator[] (size_t index) const;

friend std::ostream& operator<<(std::ostream& os, const MyString& myStr);

private:
    void buffer_deallocate();
    void buffer_allocate(size_t size);

    char * m_buffer;
    size_t m_size;
};

#endif //MYSTRING_H_