Re: Exception handling

On Sep 2, 9:11 am, mattb <matthew.b...@l-3com.com> wrote:


The majority of C++ books get exceptions wrong.
Just like there are many ways to use inheritance, there are many ways
to use exceptions. The most typical pattern is the "transactional"
pattern. It is something like this:

void onEvent(msg){

try {
      validate(msg);//this can throw anything
      apply(msg);//this cant throw
}catch(...){}

}
So if I have a program that starts in state A, and if msg will request
that the program move to state B, then
onEvent(movetoB);
Will either leave the program in state A, or move it to B. To see this
in code, suppose I wrote this:

std::vector<unsigned> sum_lt10000; //global invariant, must always sum
to less than 10000
void validate(std::vector<unsigned> const&v){
    if(std::accumulate(v.begin(),v.end(),unsigned())<10000)return;
    throw 1;
}
void apply(std::vector<unsigned> const&v){
    sum_lt10000.swap(v);//does not throw
}
void main(){

while(1){
     try{
     std::vector<unsigned> b;
     for(int i=i,i!=10;++i)
       b.push_back(rand());
     validate(b);// invariant check
     apply(b);// change of state
     }catch(...){}
     }
     validate(sum_lt10000);//a test to see if the program is still in a
valid state

}

You can see froom this little program that a) it will never terminate.
There are no "intermediate states"

To make this cleaner, what one does it to move the validations to a
ctor and trim down the interface of things that could possibly break
invarainits. So now I have
std::vector<unsigned> sum_lt10000;
struct Sum_lt10000{
     typedef std::vector<unsigned> base_type;
     Sum_lt10000(){}//default ctor preserves invariants
     Sum_lt10000(base_type const& v):m(v){
        if(std::accumulate(v.begin(),v.end(),unsigned())<10000)return;
        throw 1;
     }
//default copy ctor OK
    base_type::const_iterator begin()const{
      return base_type::begin();
    }
    base_type::const_iterator end()const{
      return base_type::begin();
    }

    void swap(Sum_lt10000 &g){
        g.m.swap(m);
    }
private:
     base_type m;
};
Nw we change the "apply" function and the global to to
Sum_lt10000 sum_lt10000;
void apply(Sum_lt10000 const&v){
    sum_lt10000.swap(v);//does not throw
}
Now the rest of the code becomes cleaner:
void main(){

while(1){
     try{
     std::vector<unsigned> b;
     for(int i=i,i!=10;++i)
       b.push_back(rand());

     apply(Sum_lt10000(b));// change of state
     }catch(...){}
     }
}
Note that there is no way of even compiling this code without running
the validations.
,nor can some rogue code anywhere change the object once it is
validated. You may complain that I added an extra copy, however
remember the dictum "it is easier to make a correct program fast that
it is to make a fast programm correct"

Note that I did not attempt was trying to make an different exception
type for every different type of error. This is a disaster in Java.
The code above works no matter what gets thrown. This is also the
reason virtually all C++ gurus recommend not using exception
specifications.
Now that we have the basic design down, we can now make this a little
more user freindly. It is nice to add some messages

Change
    Sum_lt10000(base_type const& v):base_type(v){
        if(std::accumulate(v.begin(),v.end(),unsigned())<10000)return;
        throw std::logic_error("Sum exceeded 10000!!!");
     }
and

void main(){

while(1){
     try{
     std::vector<unsigned> b;
     for(int i=i,i!=10;++i)
       b.push_back(rand());

     apply(Sum_lt10000(b));// change of state
     }catch(std::exception const& e){
       std::cerr<<"exception said "<<e.what()<<"\n";
     }catch(...){
       std::cerr<<"Unknown exception\n";
     }
    }
}
The choice of "logic_error" onlhy matters because it inherits from
std::exception. Virtually every C++ library out there now will also
inherit their exceptions in the same way, so the two catch statements
is all you really need.

There are other uses for exceptions, such as "typed gotos" But the
above is 99% of how people with exceptions expecience actually use
exceptions.

Lance

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]