In: Computer Science
c++
I cannot get my operator+ to pass my test, it is failing on the first test, how would i convert my operator+ to use pointers and dynamic memory?
Requirements:
============================================================================
string.hpp:
#ifndef CS23001_STRING_INTERFACE_HPP #define CS23001_STRING_INTERFACE_HPP #include <iostream> //////////////////////////////////////////////////// // CLASS INV: str[length()] == 0 && // length() == capacity() && // capacity() == stringSize - 1 // class String { public: String (); //Empty string String (char); //String('x') String (const char[]); //String("abc") String (const String&); //Copy Constructor ~String (); //Destructor void swap (String&); //Constant time swap String& operator= (String); //Assignment Copy char& operator[] (int); //Accessor/Modifier char operator[] (int) const; //Accessor int capacity () const; //Max chars that can be stored (not including null) int length () const; //Actual number of chars in string String operator+ (const String&) const; String& operator+= (const String&); bool operator== (const String&) const; bool operator< (const String&) const; String substr (int, int) const; //The sub-string from staring position to ending position int findch (int, char) const; //Find location of charater starting at a position int findstr (int, const String&) const; //Find location of str starting at a position void test_String (); friend std::ostream& operator<<(std::ostream&, const String&); friend std::istream& operator>>(std::istream&, String&); private: String (int n ); //String(10) - capacity 10, empty string String (int , const char []); //String(10, "abc") - capacity 10 with "abc" void resetCapacity (int); //Resets capacity to N, keeps string intact char *str; //Pointer to char[] int stringSize; //Size includes NULL terminator }; String operator+ (const char[], const String&); String operator+ (char, const String&); bool operator== (const char[], const String&); bool operator== (char, const String&); bool operator< (const char[], const String&); bool operator< (char, const String&); bool operator<= (const String&, const String&); bool operator!= (const String&, const String&); bool operator>= (const String&, const String&); bool operator> (const String&, const String&); #endif
============================================================================
string.cpp:
#include <iostream> #include "string.hpp" #include <cassert> String::String() { // default constructor - empty string stringSize = 1; str = new char [stringSize]; str[0] = 0; } String::String(char ch) { stringSize = 2; str = new char [stringSize]; str[0] = ch; str[1] = '\0'; } //REQUIRES: str.length() < capacity() //String a("abc") //Takes character array and turns into string array String::String(const char X[]) { int i = 0; while (X[i] != '\0') ++i; stringSize = i + 1; str = new char [stringSize]; for(int j = 0; j < capacity(); ++j) str[j] = X[j]; str[capacity()] = 0; } String::String(const String& rhs) { //copy constructor stringSize = rhs.stringSize; str = new char [stringSize]; for(int i = 0; i < capacity(); ++i) str[i] = rhs.str[i]; } String::~String() { //destructor delete[] str; } void String::swap (String& rhs) { //Constant time swap char * temporary = str; str = rhs.str; rhs.str = temporary; int hold = stringSize; stringSize = rhs.stringSize; rhs.stringSize = hold; } String& String::operator= ( String rhs) { // Assignment copy if (str == rhs.str) return *this; //check to see if they are already pointing to the same address delete [] str; stringSize = rhs.stringSize; str = new char [stringSize]; for (int i = 0; i < capacity(); ++i) str[i] = rhs.str[i]; return *this; } //REQUIRES: 0 <= i < length() // operator[] const --- allows access to const objects char String::operator[](int i) const { assert( (i > 0) && (i < length()) ); return str[i]; } //REQUIRES: 0 <= i < length() // operator[] --- allows access / modification to non-const objects char& String::operator[] (int i) { assert( (i >= 0) && (i < length() ) ); return str[i]; } int String::capacity() const { //capacity = stringSize -1; return (stringSize - 1); } //ENSURES: Retval == i where str[i] = 0 int String::length() const { int result = 0; while (str[result] != '\0') ++result; return result; } // retval == "xyzabc" where "xyx" + "abc" String String::operator+(const String& rhs) const { String result; int offset = length(); int i = 0; while(rhs.str[i] != 0) { result.str[offset + i] = rhs.str[i]; ++i; if (offset + i == capacity()) break; } return result; } String operator+(char lhs, const String& rhs) { return String(lhs) + rhs; } String operator+(const char lhs[], const String& rhs) { return String(lhs) + rhs; } String& String::operator+=(const String& rhs) { *this = operator+(rhs); return *this; } bool String::operator==(const String& rhs) const { int i = 0; while ((str[i] != '\0') && (str[i] == rhs.str[i])) ++i; return str[i] == rhs.str[i]; } bool operator==(char lhs, const String& rhs) { return String(lhs) == rhs; } bool operator==(char lhs[], const String& rhs) { return String(lhs) == rhs; } bool String::operator<(const String& rhs) const { int i = 0; while ((str[i] != 0) && (rhs.str[i] != 0) && (str[i] == rhs.str[i])) ++i; return str[i] < rhs.str[i]; } bool operator<(char lhs, const String& rhs) { return String(lhs) < rhs; } bool operator<(const char lhs[], const String& rhs) { return String(lhs) < rhs; } bool operator!=(const String& lhs, const String& rhs) { return !(lhs == rhs) || (lhs == rhs); } bool operator<=(const String& lhs, const String& rhs) { return (lhs < rhs) || (lhs == rhs); } bool operator>(const String& lhs, const String& rhs) { return (rhs < lhs); } bool operator>=(const String& lhs, const String& rhs) { return !(lhs < rhs); } std::ostream& operator<<(std::ostream& out, const String& rhs) { out << rhs.str; return out; } std::istream& operator>>(std::istream& in, String& rhs) { char placehold[540000]; in >> placehold; rhs = String(placehold); return in; } //REQUIRES: 0 <= start < length() //ENSURES: retval == i where str[i] == ch && i >= start // or retval == -1 if ch != s[start.length()-1] int String::findch(int start, char ch) const { if ( (start < 0) || (start >= length()) ) return -1; int i = start; while (str[i] != 0) { if (str[i] == ch) return i; ++i; } return -1; } int String::findstr(int pos, const String& rhs) const { int i = pos; if ((pos < 0) || (pos >= length() - rhs.length())) return -1; if (length() < rhs.length()) return -1; while ((str[pos] != 0) && (rhs.length() + pos - 1 <= length())) { if (rhs == substr(i, i + rhs.length() - 1)) return pos; ++i; } return -1; } //REQUIRES: 0 <= start <= end < length() //ENSURES: retval == s[start, ..., end] String String::substr(int start, int end) const { if (start < 0) return String(); if (start > end) return String(); if (end >= length()) return String(); String result; int i = start; while (i <= end) { result += str[i]; ++i; } return result; } String::String (int n) { //String(10) - capacity 10, empty string stringSize = n; str = new char [stringSize]; str[0] = 0; } String::String (int n, const char ch[]) { //String(10, "abc") - capacity 10 with "abc" stringSize = n; str = new char [n]; for (int i = 0; i < n; ++i) str[i] = ch[i]; } void String::resetCapacity (int n ) { //Resets capacity to N, keeps string intact int smaller = stringSize; if (smaller > n) smaller = n; stringSize = n; char * tmp = new char [stringSize]; for (int i = 0; i < smaller; ++i) tmp[i] = str[i]; delete [] str; str = tmp; } void String::test_String() { String testing(5); assert(testing.length() == 0); assert(testing.capacity() == 5); String test(15); assert(test.length() == 0); assert(test.capacity() == 15); String CharArray(10, "abc"); assert(CharArray.length() == 3); assert(CharArray.capacity() == 10); }
============================================================================
concat test .cpp:
#include "string.hpp" #include <cassert> #include <iostream> int main () { { // TEST String str = "x"; String str2 = "y"; String result; result = str+str2; std::cout<< str << " " << str2 << " " <<result<<std::endl; // VERIFY assert(result == "xy"); } { // TEST String str = "xyz"; String str2 = "abc"; String result; result = str+str2; // VERIFY assert(result == "xyzabc"); } { // TEST String str = "qlW3KSqbFk"; String str2 = "f6iSmJhRTl"; String result; result = str+str2; // VERIFY assert(result == "qlW3KSqbFkf6iSmJhRTl"); } { //------------------------------------------------------ // SETUP FIXTURE // TEST String str = "lZ8kmGDuKeqzqPOmvthx94jQQg46C8"; String str2 = "SgiwD"; String result; result = str+str2; // VERIFY assert(result == "lZ8kmGDuKeqzqPOmvthx94jQQg46C8SgiwD"); }
std::cout << "Done testing Concatination Constructor." << std::endl; }
// ============================================================================
// string.cpp:
#include <iostream>
#include "string.hpp"
#include <cassert>
using namespace std;
String::String() { // default constructor - empty string
stringSize = 1;
str = new char [stringSize];
str[0] = 0;
}
String::String(char ch) {
stringSize = 2;
str = new char [stringSize];
str[0] = ch;
str[1] = '\0';
}
//REQUIRES: str.length() < capacity()
//String a("abc")
//Takes character array and turns into string array
String::String(const char X[]) {
int i = 0;
while (X[i] != '\0') ++i;
stringSize = i + 1;
str = new char [stringSize];
for(int j = 0; j < capacity(); ++j)
str[j] = X[j];
str[capacity()] = 0;
}
String::String(const String& rhs) { //copy constructor
stringSize = rhs.stringSize;
str = new char [stringSize];
for(int i = 0; i < capacity(); ++i)
str[i] = rhs.str[i];
}
String::~String() { //destructor
delete[] str;
}
void String::swap (String& rhs) { //Constant time swap
char * temporary = str;
str = rhs.str;
rhs.str = temporary;
int hold = stringSize;
stringSize = rhs.stringSize;
rhs.stringSize = hold;
}
String& String::operator= ( String rhs) { // Assignment copy
if (str == rhs.str) return *this; //check to see if they are already pointing to the same address
delete [] str;
stringSize = rhs.stringSize;
str = new char [stringSize];
for (int i = 0; i < capacity(); ++i)
str[i] = rhs.str[i];
return *this;
}
//REQUIRES: 0 <= i < length()
// operator[] const --- allows access to const objects
char String::operator[](int i) const {
assert( (i > 0) && (i < length()) );
return str[i];
}
//REQUIRES: 0 <= i < length()
// operator[] --- allows access / modification to non-const objects
char& String::operator[] (int i) {
assert( (i >= 0) && (i < length() ) );
return str[i];
}
int String::capacity() const { //capacity = stringSize -1;
return (stringSize - 1);
}
//ENSURES: Retval == i where str[i] = 0
int String::length() const {
int result = 0;
while (str[result] != '\0')
++result;
return result;
}
// retval == "xyzabc" where "xyx" + "abc"
String String::operator+(const String& rhs) const {
char *c = new char[length() + rhs.stringSize];
int i = 0;
while(str[i] != 0) {
c[i] = str[i];
++i;
}
int j = 0;
while(rhs.str[j] != 0) {
c[i++] = rhs.str[j++];
}
c[i] = '\0';
String *k = new String(c);
return *k ;
}
String operator+(char lhs, const String& rhs) {
return String(lhs) + rhs;
}
String operator+(const char lhs[], const String& rhs) {
return String(lhs) + rhs;
}
String& String::operator+=(const String& rhs) {
*this = operator+(rhs);
return *this;
}
bool String::operator==(const String& rhs) const {
int i = 0;
while ((str[i] != '\0') && (str[i] == rhs.str[i])) ++i;
return str[i] == rhs.str[i];
}
bool operator==(char lhs, const String& rhs) {
return String(lhs) == rhs;
}
bool operator==(char lhs[], const String& rhs) {
return String(lhs) == rhs;
}
bool String::operator<(const String& rhs) const {
int i = 0;
while ((str[i] != 0) && (rhs.str[i] != 0) && (str[i] == rhs.str[i])) ++i;
return str[i] < rhs.str[i];
}
bool operator<(char lhs, const String& rhs) {
return String(lhs) < rhs;
}
bool operator<(const char lhs[], const String& rhs) {
return String(lhs) < rhs;
}
bool operator!=(const String& lhs, const String& rhs) {
return !(lhs == rhs) || (lhs == rhs);
}
bool operator<=(const String& lhs, const String& rhs) {
return (lhs < rhs) || (lhs == rhs);
}
bool operator>(const String& lhs, const String& rhs) {
return (rhs < lhs);
}
bool operator>=(const String& lhs, const String& rhs) {
return !(lhs < rhs);
}
std::ostream& operator<<(std::ostream& out, const String& rhs) {
out << rhs.str;
return out;
}
std::istream& operator>>(std::istream& in, String& rhs) {
char placehold[540000];
in >> placehold;
rhs = String(placehold);
return in;
}
//REQUIRES: 0 <= start < length()
//ENSURES: retval == i where str[i] == ch && i >= start
// or retval == -1 if ch != s[start.length()-1]
int String::findch(int start, char ch) const {
if ( (start < 0) || (start >= length()) ) return -1;
int i = start;
while (str[i] != 0) {
if (str[i] == ch) return i;
++i;
}
return -1;
}
int String::findstr(int pos, const String& rhs) const {
int i = pos;
if ((pos < 0) || (pos >= length() - rhs.length()))
return -1;
if (length() < rhs.length())
return -1;
while ((str[pos] != 0) && (rhs.length() + pos - 1 <= length())) {
if (rhs == substr(i, i + rhs.length() - 1))
return pos;
++i;
}
return -1;
}
//REQUIRES: 0 <= start <= end < length()
//ENSURES: retval == s[start, ..., end]
String String::substr(int start, int end) const {
if (start < 0) return String();
if (start > end) return String();
if (end >= length()) return String();
String result;
int i = start;
while (i <= end) {
result += str[i];
++i;
}
return result;
}
String::String (int n) { //String(10) - capacity 10, empty string
stringSize = n;
str = new char [stringSize];
str[0] = 0;
}
String::String (int n, const char ch[]) { //String(10, "abc") - capacity 10 with "abc"
stringSize = n;
str = new char [n];
for (int i = 0; i < n; ++i)
str[i] = ch[i];
}
void String::resetCapacity (int n ) { //Resets capacity to N, keeps string intact
int smaller = stringSize;
if (smaller > n) smaller = n;
stringSize = n;
char * tmp = new char [stringSize];
for (int i = 0; i < smaller; ++i)
tmp[i] = str[i];
delete [] str;
str = tmp;
}
void String::test_String() {
String testing(5);
assert(testing.length() == 0);
assert(testing.capacity() == 5);
String test(15);
assert(test.length() == 0);
assert(test.capacity() == 15);
String CharArray(10, "abc");
assert(CharArray.length() == 3);
assert(CharArray.capacity() == 10);
}
============================================================================
All the Test Passed,
SEE OUTPUT
Thanks, PLEASE COMMENT if there is any concern. PLEASE UPVOTE