// Function: MyString
// Description: Default Constructor
// Purpose: Initialize the data char string to the empty string,
// and initialize the length and capacity
///////////////////////////////////////////////////////////////////////////////
MyString::MyString() {
len = 0;
capacity = 10;
data = new char[this->capacity + 1];
data[this->len] = '\0';
}

///////////////////////////////////////////////////////////////////////////////
// Function: MyString
// Description: Overloaded Constructor
// Purpose: Initialize the data char string to hold the input string,
// appropriately setting the size and capacity
///////////////////////////////////////////////////////////////////////////////
MyString::MyString(const char *cStr) {
len = 0;
capacity = 10;
data = new char[capacity + 1];

//iterate until the end of cStr, adding each character to data
while (cStr[len] != '\0') {
//if input string copying becomes too large, increase the capacity of
//our string
if (len >= capacity) {
//double the capacity
capacity = capacity * 2;

//copy all characters into a new buffer
char *tmp = new char[capacity + 1];
for (int i = 0; i < len; i++) {
tmp[i] = data[i];
}
delete[] data;
data = tmp;
tmp = NULL;
}

//add the character to our string
data[len] = cStr[len];
len++;
}

data[this->len] = '\0';
}

///////////////////////////////////////////////////////////////////////////////
// Function: ~MyString
// Purpose: Deallocate the memory to data and set to NULL, and set
// length and capacity to zero
///////////////////////////////////////////////////////////////////////////////
MyString::~MyString() {
delete[] data;
data = NULL;
capacity = 0;
len = 0;
}

///////////////////////////////////////////////////////////////////////////////
// Function: MyString
// Description: Copy Constructor
// Purpose: Set 'this' to be a deep copy of 'that'
///////////////////////////////////////////////////////////////////////////////
MyString::MyString(const MyString &that) {
this->len = that.len;
this->capacity = that.capacity;

this->data = new char[capacity + 1];

int index = 0;
//iterate until the end of cStr, adding each character to data
while (that.data[index] != '\0') {
this->data[index] = that.data[index];
index++;
}
this->data[this->len] = '\0';
}

///////////////////////////////////////////////////////////////////////////////
// Function: operator =
// Description: Overloaded Assignment Operator
// Purpose: Set 'this' to be a deep copy of 'that'
///////////////////////////////////////////////////////////////////////////////
MyString& MyString::operator = (const MyString& that) {
this->len = that.len;
this->capacity = that.capacity;
this->data = new char[capacity + 1];
int index = 0;
//iterate until the end of cStr, adding each character to data
while (that.data[index] != '\0') {
this->data[index] = that.data[index];
index++;
}
this->data[this->len] = '\0';
return *this;
}

///////////////////////////////////////////////////////////////////////////////
// Function: operator ==
// Description: Overloaded Equivalency Operator
// Purpose: Check that 'this' and 'that' are equivalent
///////////////////////////////////////////////////////////////////////////////
bool MyString::operator == (const MyString& that) const {
bool isEqual = true;
if(this->len != that.len) {
isEqual = false;
} else if(this->capacity != that.capacity) {
isEqual = false;
} else {
int index = 0;
while(this->data[index] != '\0' && that.data[index] != '\0') {
if(this->data[index] != that.data[index]) {
isEqual = false;
break;
}
index

Bell-LaPadula Model Describe the Bell-LaPadula Model (What kind o...