1. The difference between operator overloading as a member function
and as a friend function are:
a. Operator overloading as a member function has
one argument less than as a friend function.
b. The member function has access to the "this"
pointer while a friend function may not use it.
2. (a) Class XYZZY
{
Private:
int X, Y, Z;
Public:
XYZZY (int a=1, b=2, c=3);
void setX (int value);
void setY (int value);
void setZ (int value);
int getX ( ) const;
int getY ( ) const;
int getZ ( ) const;
friend int F (const XYZZY& );
};
(b)
Constructor
XYZZY::XYZZY (int a, int b, int c)
: X(a), Y(b), Z(c)
{
//no code
}
(c)
int F (const XYZZY& param)
{
int m = param.X;
if (param.y < m)
m = param.Y;
if (param.Z < m)
m = param.Z;
return m;
}
3. a. Precedence, associativity, and number of arguments are preserved.
b. Assignment, function calls, subscript, and pointer
dereferencers MUST be number functions.
c. Cannot create new operators.
d. Operators: ".", "*", and "::" cannot be overloaded.
e. Must have one user defined operand.
The restrictions are imposed to limit the complexity
of the compiler.
4. a. The copy constructor creates a copy of an existing object by taking
its argument a reference to an object of the class.
b. It's called when an object of the class is passed
by value. Also when a function returns an object of the class, or when
initialization an object to be a copy of another object of the same class.
c. This is not correct. Because a reference argument
is required rather than a pass by value argument.
5. Conversion constructors are constructors that take a single
argument. They are used to convert built-in datatypes into the
user-defined type.
Conversion cast operators are the operators used
to convert the user-defined type into another built-in datatypes.
Both are called expictly or implicitly.