CS 450 Notes Chapter 6
- Introduction
Some C notes: A function call that returns a certain type can be used
anywhere that that type can. so you don't have to do this:
int n;
n=atoi("54");
printf("%d%\n",n);
You can do:
printf("%d\n",atoi("54"));
tracing trick
Here is a neat way to trace the execution of your program.
class Trace {
public:
Trace(char *);
~Trace();
private:
char * fn;
} // Trace
Trace::Trace(char * mesg)
{
cerr << "now entering: " << mesg << endl;
fn = strdup(mesg);
} // trace constructor
Trace :: ~Trace()
{
cerr << "now leaving: " << fn << endl;
free(fn);
} // trace destructor
Now in any function you want to trace:
int
foo(int a,int b)
{
Trace tracer("foo");
other stuff
} // foo
The constructor is called at the beginning of the function and the destructor
at the end. This can be expanded to use a file member to record tracing,
read an environment variable to see if tracing is on, keep a list of functions
to be traced and only trace those, etc.
More inheritance.
You don't inherit constructors, destructors or assignment operators.
If a derived class has a member function with the same name
as the base class, the derived function overrides the base version.
Either version can be run by explicitly using the scope resolution operator.
So derived.overridden() can call base::overridden() to get the parent version
of the functions.
Pointers to the base class can also point to the derived class.
This is because the derived class is a base class, not just an instance.
Derived class pointers cannot point at base class instances.
The isa relationship only goes one way.
virtual functions.
In a type hierarchy, the top class can have a virtual function.
Each of the derived classes will override this function.
Then, using a pointer to the base class, the program can point at
a variety of objects of the derived classes and when the
overridden function is called,
it is the one for the type of the object being pointed at.
Without virtual functions, the function called is the one for the
type of the pointer.
class instrument {
public:
void play(note) { cout << "instrument::play" << endl;}
} // instrument
class wind : public instrument {
public:
void play(note) { cout << "wind::play" << endl;}
}; // wind
void tune(instrument& i)
{
i.play(note);
}
main()
{
wind flute;
tune(flute);
} // main
This prints instrument::play.
This is because the variable in tune() is
of type instrument so it uses the function from there, even though we passed
in a flute.
Change the definition in instrument to:
virtual void play(note) { cout << "instrument::play" << endl;}
Now running the program prints wind::play.
The function to be called is determined at run time (late binding).
This technique allows us to write
functions like tune() that will work for any derived class from a base
class.
It is easier to extend the classes because tune() still works for
other classes derived from instrument.
Like drum or guitar.
It will also work for lower levels.
If class brass is derived from wind, tune() still works.
If there is no overridden functions, the one next up the hierarchy
is used.
friend functions
Functions that are not members but need access to private
data are friends.
class foo {
public:
friend int buddy();
} // foo
int
buddy()
{
} // buddy
A good use of friends are functions that use multiple classes and can be
more efficient if they have direct access to the inner parts of a class.
Member functions of one class can be listed as friend functions in another.
Use the scope resolution operator to make this clear.
class foo {
public:
friend int other_class::buddy();
} // foo
class otherclass {
int buddy(){} // buddy
If all the code in a class is a friend of another class, you can say
friend class other_class;