Study Guide 11 Answers

Unary operators have one operand
Binary operators have two operands
When called, member functions are bound to one object, called the implicit or "this" object
friend are not members of the befriending class and are not bound to objects
Programs pass explicit arguments inside the function-call parentheses
When a program separates a function's definition and prototype, any default arguments go with the prototype
When a program separates a friend function's definition and prototype, the friend keyword goes in the class specification
When a program separates a constructor's definition and its prototype, any default arguments go with the constructor's definition

a
b
b
c
b
a
b; d
d
b
a
a
1. (b) foo foo::operator+(foo f) { . . . . }
2. (d) foo operator+(foo f1, foo f2) { . . . . }
3. (c) friend foo operator+(foo f1, foo f2) { . . . . }
4. (a) foo operator+(foo f) { . . . . }
friend void harry(george g);
a
b
b
c
a - The second call is not very useful and not used in practice, but it is legal.
b - The first call is legal, but friend functions are not members of a class and cannot be called using the dot (.) operator. The correct syntax for the second call is C = operator+(A,B); (which is not useful nor used in practice).
b - IF operator+ was a member function, the statement could be rewritten as 3.operator(f), which is not possible because '3' is just a plain number, which does not support the dot operator. However, if operator+ is a friend function, then operation can be rewritten as operator+(3,f), which is just fine.
a, b - Any constructor that can be called without arguments is a default constructor.
c, d, e - Broadly, the distinction between a conversion and general constructor is how a program uses them. Nevertheless, conversion constructors frequently have one parameter, which they convert from the parameter type to the defining class type. For example, suppose that class foo has a conversion constructor: foo(bar x);. This constructor converts a bar into a foo. The textbook uses the narrower view as a convenience.
e
b - Satisfying all three calls requires (1) a conversion constructor, and (2) a friend function that takes two arguments of the class type.
d - operator+ is implemented as a friend function (which is not a member) and therefore cannot appear on the left hand side of the dot operator. Choice b calls the constructor.

friend ostream& operator<<(ostream& out, room& me)
{
    out << me.width << " x " << me.length << endl;
    return out;
}

friend istream& operator>>(istream& in, room& me)
{
    in >> me.width;
    in >> me.length;
    return in;
}

The functions are the same but without the friend keyword.

friend ostream& operator<<(ostream& in, Beta& me)
{
	out << (Alpha &)me << " " << me.id << endl;
	return out;
}

1. count(a_count), balance(a_balance)
2. Bar(count, balance), name(a_name)
3. (Bar &)f << " " << f.name
1. f.name
2. f.my_bar
1. f.name
2. if (me.my_bar != nullptr)
3. *me.my_bar