L13 - String Streams and Operator Overloading

#ece244

string streams

• String streams are helpful when input are line-oriented, e.g. user will enter a line and program has to check if inputs on that line are correct/expected.
• String streams can be used to extract inputs in the line

syntax

• #include <sstream> is the include statement for the class
• stringstream is the class name, which must be called when a new string stream object is created
• <stringstream object name>.str() returns the actual string used by the object, with the cursor at the very beginning of the string
• flags:
  • .eof() is when the end of the string has been reached
  • .fail() is the standard fail flag, as in L12
• getline(cin, <string>) reads in everything until a \n is reached, i.e. reads an entire line

notes

• when you call the stringstream object, you create a copy of the string; you do not actually modify the original string directly.

example: reading

#include <sstream> // short for string stream
#include <string>
using namespace std;

int main(void) {
	int ID;
	string name;
	string line = "1001 Joe";
	stringstream myStringStream(line);
	// after each read, check for .fail() and .eof() flags
	myStringStream >> ID; // reads 1001 into ID	
	myStringStream >> name; // reads "Joe" into name
	cout << myStringStream.str() << endl;
}

example: reading entire lines from standard input

getline(cin, <string>);
string command
stringstream myStringStream(command);
string arg1;
myStringStream >> arg1;
// i have no idea what's going on here i'm gonna be honest

operator overloading

• Similar to function overloading, which is when we declare a function (in a class) that has parameters passed to it, and then we declare it again with different parameters (See L06)
• operator overloading is when we accept objects as arguments and use operators on them
  • these operators include +, -, /, *, %, =, +=, !=, ==, >=, <, <<, >>, etc.
• essentially, we define what behaviour occurs when we call one of the above operators

x + y

x.operator+(y)

where operator+ is being invoked on x, and parameter y is passed into the function.

example: fully implementing the operator+ function

When we want to implement the operator+ function on a Complex number (as an example), we have to:

1. Pass in a parameter of type Complex (or whatever object/data type is on the RHS of the equation x + y)
2. Compute the sum and set a new object of type Complex equal to that sum
3. Return a newly created object of type Complex

Below is the code after it has been implemented

#include <iostream>
using namespace std;

class Complex { // complex number class
	private:
		double real, img;
	public:
		Complex() { // first constructor
			real = 0;
			img = 0;
		}
		Complex (double r, double i) { // second constructor
			real = r;
			img = i;
		}
		operator+(Complex rhs);
}

Complex::operator+(const Complex &rhs) const {
	// as good practice, we should use a reference
	// instead of a pass by value to save on memory
	Complex temp;
	temp.real = real + rhs.real;
	temp.img = img + rhs.img;
	return temp; // returning a COPY of temp (by value)
	// we can't return a reference here because the object will no longer exist
	// in the memory once this function goes out of scope
}

int main(void) {
	Complex x(3,4); // calls second constructor
	Complex y(5,6); // calls second constructor
	Complex z; // calls first constructor
	
	z = x + y;	
}

Notes:

• for the RHS Complex object, we can get its real component through temp.real
  • however, since we are calling the operator+ function on the LHS object, we can simply directly refer to real, which gets us the LHS object's real component
• we can't return a reference to our new object because it's created on the stack, and will therefore disappear when the function goes out of scope. Thus, we return a copy of the temp object we create, which is known as returning by value.
• we want to modify neither the RHS nor the LHS objects, so we can use const:
  • for RHS, use const in the pass-by-value or pass-by-reference
  • for LHS, declare the whole operator+ function with const

some good terminology to know: pass-by-value and return-by-value