exam 1 class definitions and code questions

Question 1

what is the preferred way to do operator+ overloading?

Answer 1

overload the += in the class and + outside of the class

Question 2

overload the operator+= for the String class as a method.

Answer 2

String& String::operator+=(const String& rhs){
int offset = length();
int rhsLength = rhs.length();
int i = 0;
while(rhs.str[i] != 0){
if(offset + i >= CAPACITY){
break;
}
str[offset + i] = rhs.str[i];
++i;
}
str[offset + i] = 0;
return *this; //dereferencing
}

Question 3

overload the operator+ for the String class as a function

Answer 3

String operator+(String lhs, const String& rhs){
return lhs += rhs;
}

Question 4

overload the operator== for the String class, include requires and ensures

Answer 4

//REQUIRES: 0 <= length() && rhs.length() < CAPACITY
// && i <= length()
// && i <= rhs.length()
//ENSURES: retval == true if str == rhs.str
// && retval == false if not
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];
}

Question 5

overload the operator< for the String class as a method

Answer 5

//REQUIRES: 0 <= length() && rhs.length() < CAPACITY
//&& i <= length()
//&& i <= rhs.length()
//ENSURES: retval == true if lhs < rhs
// && retval == false if not
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];
}

Question 6

overload the operator== for the String class as a function. Use parameters char[] and String.

Answer 6

bool operator==(const char lhs[], const String& rhs){
return String(lhs) == rhs;
}

Question 7

overload the operator== for the String class as a function. Use parameters char and String.

Answer 7

bool operator== (char lhs, const String& rhs){
return String(lhs) == rhs;
}

Question 8

overload the operator<= for the String class as a function. Use parameters String and String.

Answer 8

bool operator<=(const String& lhs, const String& rhs){
return !(rhs < lhs);
}

Question 9

overload the operator> for the String class as a function. Use parameters String and String.

Answer 9

bool operator>(const String& lhs, const String& rhs){
return rhs < lhs;
}

Question 10

overload the operator>= for the String class as a function. Use parameters String and String.

Answer 10

bool operator>=(const String& lhs, const String& rhs){
return !(lhs < rhs);
}

Question 11

overload the operator!= for the String class as a function. Use parameters String and String.

Answer 11

bool operator!=(const String& lhs, const String& rhs){
return !(lhs == rhs);
}

Question 12

make a method for the String class called findChar. Use parameters int and char. Include requires and ensures

Answer 12

//REQUIRES: 0 <= start < length()
//ENSURES: retval == i if str[i] == toFind
//or retval == -1 if not
int String::findChar(int start, char toFind) const{
int i = 0;
if(start < 0){
start = 0;
}
if(start >= length()){
return -1;
}
i = start;
while(str[i] != 0){
if(str[i] == toFind){
return i;
}
}
return -1;
}

Question 13

make a method for the String class called substr. Use parameters int and int. Include requires and ensures

Answer 13

//REQUIRES: 0 <= start <= end < length()
//ENSURES: retval == str[start, …, end]
String String::substr(int start, int end) const{
String result;
if(start < 0){
start = 0;
}
if(end >= length()){
end = length() - 1;
}
if(end < start){
return result;
}
for(int i = start: i <= end; i++){
result += str[i];
}
return result;
}

Question 14

what are the private variables of the point class?

Answer 14

double x;
double y;

Question 15

make a method for the point class called init that has two doubles as parameters.

Answer 15

void Point::init (double newX, double newY){
x = newX;
y = newY;
}

Question 16

make a default constructor for the Point class.

Answer 16

Point::Point(){
x = 0;
y = 0;
}

Question 17

make a method for the Point class called setX that has one double as a parameter.

Answer 17

void Point::setX(double newX){
x = newX;
}

Question 18

make a method for the Point class called setY that has one double as a parameter.

Answer 18

void Point::setY(double newY){
y = newY;
}

Question 19

make a method for the Point class called getX that takes no parameters.

Answer 19

double Point::getX(){
return x;
}

Question 20

make a method for the Point class called getY that takes no parameters.

Answer 20

double Point::getY(){
return y;
}

Question 21

make a method for the Point class called add that has a Point as a parameter.

Answer 21

Point Point::add(const Point& rhs) const{
Point result;
result.x = x + rhs.x;
result.y = y + rhs.y;
return result;
}

Question 22

make a method for the Point class called sub that has a Point as a parameter.

Answer 22

Point Point::sub(const Point& rhs) const{
Point result;
result.x = x - rhs.x;
result.y = y - rhs.y;
return result;
}

Question 23

make a constructor for the Point class that takes two doubles as parameters.

Answer 23

Point::Point(double newX, double newY){
x = newX;
y = newY;
}

Question 24

overload the + operator for the point class.

Answer 24

Point Point::operator+(Point rhs){
Point result;
result.x = x + rhs.x;
result.y = y + rhs.y;
return result;
}

Question 25

overload the - operator for the Point class.

Answer 25

Point Point::operator-(Point rhs){ Point result; result.x = x - rhs.x; result.y = y - rhs.y; return result; }

Question 26

overload the << operator for the Point class. Assume it is a friend function.

Answer 26

std::ostream& operator<<(std::ostream& out, Point rhs){ out << "(" << rhs.x << ", " << rhs.y << ")"; return out; }

Question 27

what are the private variables for the Set class?

Answer 27

bool element[SET_DOMAIN], an array of bools, where an element is true if it is in the set and false if not

Question 28

make the default constructor for the Set class.

Answer 28

Set::Set(){ for(int i = 0; i < SET_DOMAIN; i++){ element[i] = false; } }

Question 29

make a constructor for the Set class that takes one int as a parameter.

Answer 29

Set::Set(int input){ Set() if(input >= 0 && input < SET_DOMAIN){ element[input] = true; } }

Question 30

make a constructor for the Set class that takes two ints as parameters.

Answer 30

Set::Set(int input1, int input2){ Set(); if(input1 >= 0 && input1 < SET_DOMAIN){ element[input1] = true; } if(input2 >= 0 && input2 < SET_DOMAIN){ element[input2] = true; } }

Question 31

make a method card for the Set class that returns the cardinality of the set and takes no parameters.

Answer 31

int Set::card() const{ int result = 0; for(int i = 0; i < SET_DOMAIN; i++){ if(element[i]){ ++result; } } return result; }

Question 32

overload operator+ for the Set class that takes a Set object as a parameter. operator+ functions as the union of two sets

Answer 32

Set Set::operator+(const Set& rhs) const{ Set result; for(int i = 0; i < SET_DOMAIN; i++){ result.element[i] = (element[i] || rhs.element[i]); } return result; }

Question 33

overload operator[] for the Set class that takes an int as a parameter.

Answer 33

bool Set::operator[](int position) const{ if(position >= 0 && position < SET_DOMAIN){ return element[position]; } return false; }

Question 34

overload operator* for the Set class that takes a Set as a parameter. operator* functions as the intersection of the two Sets.

Answer 34

Set Set::operator*(const Set& rhs) const{ Set result; for(int i = 0; i < SET_DOMAIN; i++){ result[i] = element[i] && rhs.element[i]; } return result; }

Question 35

overload operator+ for the Set class that takes an int and a Set object as parameters. Assume this is not a method and operator+ has already been overridden as a method for the Set class.

Answer 35

Set operator+ (int lhs, const Set& rhs){ return Set(lhs) + rhs; }

Question 36

overload operator* for the Set class that takes an int and a Set object as parameters. Assume this is not a method and operator* has already been overridden as a method for the Set class.

Answer 36

Set operator* (int lhs, const Set& rhs){ return Set(lhs) * rhs; }

Question 37

overload operator- for the Set class that takes an int and a Set object as parameters. Assume this is not a method and operator- has already been overridden as a method for the Set class.

Answer 37

Set operator- (int lhs, const Set& rhs){ return Set(lhs) - rhs;

Question 38

overload operator== for the Set class that takes a Set object as a parameter.

Answer 38

bool Set::operator==(const Set& rhs) const{ int i = 0; while(element[i] == rhs.element[i] && i < SET_DOMAIN){ ++i; } return element[i] == rhs.element[i]; }

Question 39

overload operator== for the Set class that takes an int and a Set object as parameters. Assume this is not a method and operator== has already been overridden as a method for the Set class.

Answer 39

bool operator== (int lhs, const Set& rhs){ return Set(lhs) == rhs; }

Question 40

overload operator!= for the Set class that takes an Set object and a Set object as parameters. Assume this is not a method and operator== has already been overridden as a method for the Set class.

Answer 40

bool operator!=(const Set& lhs, const Set& rhs){ return !(lhs == rhs); }

Question 41

overload operator<= as a method for the Set class that takes a Set object as a parameter.

Answer 41

bool Set::operator<=(const Set& rhs){ for(int i = 0; i < SET_DOMAIN; i++){ if(element[i] && !rhs.element[i]){ return false; } } return true; }

Question 42

overload operator< for the Set class that takes an Set object and a Set object as parameters. Assume this is not a method and operator== and operator<= have already been overridden as a method for the Set class.

Answer 42

bool operator<(const Set& lhs, const Set& rhs){ return (lhs <= rhs) && (lhs != rhs); }

Question 43

overload operator>=for the Set class that takes an Set object and a Set object as parameters. Assume this is not a method and operator<= has already been overridden as a method for the Set class.

Answer 43

bool operator >=(const Set& lhs, const Set& rhs){ return rhs <= lhs; }

Question 44

overload operator<< for the Set class as a function, not a friend function.

Answer 44

std::ostream& operator<<(std::ostream& out, const Set& rhs){ out << "{ "; bool printComma = false; for(int i = 0; i < SET_DOMAIN; i++){ if(rhs[i]){ if(printComma){ out << ", "; } out << i; printComma = true; } } return out; }

Question 45

what are the private members of the String class?

Answer 45

char str[256]

Question 46

make a default constructor for the String class.

Answer 46

String::String(){ str[0] = 0; }

Question 47

create a constructor for the String class that takes in a char as a parameter.

Answer 47

String::String(char c){ str[0] = c; str[1] = 0; }

Question 48

create a constructor for the String class that takes in a char array as a parameter.

Answer 48

String::String(const char& arr[]){ int i = 0; while(arr[i] != 0){ str[i] = arr[i]; ++i; } }

Question 49

create a method for the String class called length that takes no parameters and returns the length of the string.

Answer 49

int String::length(){ int result = 0; while(str[result] != 0){ ++result; } return result; }

Question 50

overload operator[] for the String class so that it returns the char in str that is in the position of the integer that is entered.

Answer 50

char String::operator[](int i) const{ assert(i >= 0); assert(i < length()); return str[i]; }

Question 51

overload operator[] for the String class so that it returns a char reference of the char in str that is in the position of the integer that is entered.

Answer 51

char& String::operator[](int i){ assert(i >= 0); assert(i < length()); return str[i]; }