Re: throw / catch question

On Oct 4, 1:23 pm, DJ <d...@dj.net> wrote:


The evil is that the code is hard to understand, since exceptions are
being used in a non-idiomatic way. But *technically* there is nothing
wrong with it -- some may argue that exception are an expensive way to
indicate that everything is just dandy, but in this case you are
willing to pay for a failed SQL call everytime, and that I'm sure
dwarfs whatever overhead there is absorbing the exception.

But for the record, the way you would normally see this code:
(example SQlServer )
std::string test_exists("select Name FROM master..sysdatabases where
Name=\'TEST\'");
std::string some_normal_db_access("select * from TEST.sometable");
std::string btrans("begin transaction");
std::string ctrans("commit transaction");
std::string rtrans("rollback transaction");
bool rollbacktransaction =false;

try{
// do a
     int count= SQL_COMMAND->exec(test_exists);
     if(count==0){
          SQL_COMMAND->exec("create database TEST");
     }
//now do regular code
     SQL_COMMAND->exec( btrans );
     rollbacktransaction=true;
     SQL_COMMAND->exec( some_normal_db_access );

//more regular code, could throw anything
     do_stuff();
//now save everything
     SQL_COMMAND->exec( ctrans);
//now that everything is committed, only put code that will not throw
here
    rollbacktransaction=false;
}catch(...){ //all exceptions
     std::cout<<"oops!!";
}

if(rollbacktransaction){
try{
    SQL_COMMAND->exec( rtrans);

}catch(...){
    std::cerr<<"Major DB failure!!!!";
    exit(0);
}
}

This is the way exceptions were intended to be used, and what people
have come to expect. Of course, you can do other things with them, but
these uses should be clearly documented and best avoided, e.g.
Example "Multiple Return Types"
void multireturntypes(int arg){
     if(arg==1)throw std::string("return a string");
     else throw 1.0;//return float
}
void foo(int arg){
try {
    multireturntypes(arg);
}catch(std::string const&ret){
    //process string
}catch(float f){
    //process float
}
}
2:Example "typed switch statement"
template <class T>void foo(T const&a){
try{throw a;}//switch
catch(float ){/*do stuff*/}//case
catch(int){}
catch(std::string){}
catch(...){}//default
}

3: Example "goto statement"
try{
while(true) while(true)while(true)while(true){
   //do stuff
   throw 1;//break out of deep nested loop
}
}catch(...){}
//continue

And there are myriad others. Why these are "evil" is that there are
almost always better ways of accomplishing the same thing, and it
screws up the "transaction" idiom that most designers use exceptions
for.

Lance

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