CS 450 Notes Chapter 7
-
Odds and Ends
-
Static member data
-
Each instance of a class with a static data member sees the same value
for that member.
// trace.h - class definitions for tracing class
#ifndef traceh_
#define traceh_
class Trace {
public:
Trace(char *);
Trace(){fn=0;};
~Trace();
friend void TraceOn();
friend void TraceOff();
private:
static bool Trace_flag;
char *fn;
};
#endif //traceh_
The static value gets initialized only once, in the definition file.
// trace.cc - tracing class functions
#include <stdlib.h>
#include <stdio.h>
#include <iostream.h>
#include <string.h>
#include "trace.h"
bool Trace::Trace_flag=false;
Trace::Trace(char * name)
{
cerr << "T:entering <" << name << ">" << endl;
fn=strdup(name);
} // Trace constructor
Trace::~Trace()
{
if(fn != 0) {
cerr << "T:leaving <" << fn << ">" << endl;
free(fn);
}
} // Trace destructor
void
TraceOn()
{
Trace::Trace_flag=true;
} // TraceOn
void
TraceOff()
{
Trace::Trace_flag=false;
} // TraceOFF
The friend functions are needed to alter the private data. And so you don't
need to create an instance just to set the data.
const references
All C and C++ args are passed by value. However, C++ has added pass
by reference. It is recommended to use this for almost all parameters as
it can speed things up.
int foo(int a) // (A)
int foo(int& a) // (B)
In (A), since a copy of a is being made when the function is called, the
contructor must be called. And when it exits, the destructor must be called.
The effect of pass by value (no alteration of the original) can be achieved
by
int foo(const int& a) // (C)
This allows the compiler to push just an address on the stack and prevents
the function from altering it.
copy constructors
When passing an object as a parameter and doing it by value, the bits
of the object are passed from the callers environment to the called functions
environment. The local var is a bit copy of the original. This isn't always
desirable. One example is that it copies the state of static members and
you might not want this. So you must write a special constructor called
a copy constructor to handle this. You add a member function that looks
like:
mycc(const myclass&);
This will be called any time a class instance is passed by value. Examples
include:
foo(myclass a) {};
myclass x;
x= bar(z); // copies return value to x
operator overloading book chapter 10
Overloaded operators are simply another name for a function call. the expression
'a+b' is another way of saying '+(a,b)'. You can overload a variety of
operators in C++, both unary and binary. The overloaded operators must
operate on a user type. You cannot redefine what it means to add integers
by overloading the '+' operator. A unary operator function takes no arguments
and a binary operator takes one. This is because the object on the left
side is the other argument. So 'a+b' is more like 'a.+(b)'. Here is an
example involving string concatenation.
class string {
public:
char * operator+(const string str)
{
char *result= new[this->length() + str.length() + 1];
strcpy(result,this->value);
strcat(result,str.value);
return(result);
}
private:
char value[32];
}
You can create your own insertors by overloading the << operator.
To print a name with a label for a class you created:
ostream &
operator<<(ostream& os, const myclass &t)
{
os << "myclass:name is " << t.name << endl;
return os;
} // << operator
increment and decrement overloading
It is possible to overload the ++ and -- operators. You can even differentiate
between pre and post increment. The compiler ass the prefix call,
++a;
as a call to
operator++(a)
However, a postfix call is seen differently:
a++;
operator++(a,int)
The compiler provides the dummy second argument.
Pure virtual functions
Virtual functions are a method of providing that the overridden versions
of a base class method get executed. Often the base class method is instantaited
so there is always something to run. However, you may want to build the
base class as an abstract class. This would have the interface and the
data, but no function. All the methods are virtual functions and they have
no code. These are defined by setiing them to 0.
virtual void foo() const = 0;
The function is defined by cannot be executed. It must be overridden by
the derived class.
Error handling
-
C error handling
There are several error handling techniques in C. Functions return
error codes or save them in global error variables like errno. Signals
can be sent and received on error. Can clash with other applications. long
jumps take the program out of the current contect and into another. This
has all the classic problems of gotos as well as not cleaning up if it
can.
-
catch and throw
In C++, a function can detect an error and throw an object containing
information about the error out into the world. Seomwhere, some other function
catches it and processes the error.
-
throw
The syntax for a throw is:
throw classname(args);
This creates an instance of this class and effectively returns it from
the function, even if that isn't the return type of the function. Usually
the context of thrown errors is a try block. The code looks like:
try {
// some code that generates errors
}
catch(thrown_type1 var) {
// catcher code
}
catch(thrown_type2 var) {
// other catcher code
}
Only one catch clause is needed for each exception type, even if there
are multiple throw statements in the try block. C++ supports the termination
model. The assumption that the code throws an exception because things
are so bad there is no help. If you want to construct the catchers so they
try to fix the problem, put the try block inside a while loop.
exception specification
To tell the user what the function is likely to throw as exceptions,
there is an extention of the function definition syntax.
void foo() throw( toobig,badpointer);
A function definition without a throw clause indicates that any exception
can be thrown.
void foo() throw();
Means hat no execptions will be thrown. Specifying the execeptions helps
the user know what to do if they want to put a try loop around your code.
generic catchers can be used.
catch(...) { }
This should be put at the end of the catcher list to pick up any you missed.
If you can't figure out what to do, putting a call to throw with no arguments
in a catcher will cause the exception to be re-raised to be picked up in
the next outer try block. To make sure everything is clean, when you leave
the scope of the code that threw the exception, all objects that have been
succesfully constructed, are destructed.
When to use
Use them for non-local errors. If you can handle it, do it. Use heirarchies
of execptions to help classify the error. use reference parameters in catchers.
Wrap a simple try block with a generic catcher around code and refine it
as needed. Good to throw exceptions during construction so execution doesn't
continue with incomplete code. Don't use exceptions in destructors. scope
changes call destructors and you might get in a loop.