Re: Safe refactoring on heap-allocated object

From:

Lance Diduck <lancediduck@nyc.rr.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Fri, 14 Dec 2007 21:36:19 CST

Message-ID:

<0f517877-bc91-465e-9683-5d045ed363ac@s12g2000prg.googlegroups.com> b10db5ad-4d62-4f74-ba47-3ae88cf7a434@b40g2000prf.googlegroups.com

On Dec 13, 6:09 pm, Buck Yeh <buck....@gmail.com> wrote:

The following code demonstrate the similar problem I found during a
code review:

class Foo
{
public: bool bar();
private: // The contents is irrelevant to the question

};

int main(int argc, char **argv)
{
    Foo *pFoo =new Foo;
    if (!pFoo->bar())
    {
        delete pFoo;
        // Log the failure
        return 1;
    }
    delete pFoo;
    return 0;

}

I would suggest the Foo object should be allocated from stack to
achieve exception safety. Like this ...

int main(int argc, char **argv)
{
    Foo foo;
    if (!foo.bar())
    {
        // Log the failure
        return 1;
    }
    return 0;

}

But my colleague claims the code is copied and pasted from some other
module already working on production. We shouldn't change the pattern.
Or should we ? Could the suggested refactoring possibly break
anything ?

The obvious fix:
main(int argc, char **argv)
  {
      std::auto_ptr<Foo>pFoo(new Foo);
      if (!pFoo->bar())
      {
           // Log the failure
          return 1;
      }
      return 0;
   }
better and more scalable
class Foo
  {
  public: bool bar();
  Foo(){
     if(!bar())throw std::logic_error("Foo is bad");
   }
  };
int main(int argc, char **argv)
  {
    try{
        std::auto_ptr<Foo>pFoo(new Foo);
     }catch(std::exception const&e){
           // Log the failure
          std::cerr<<e.what();
          return 1;
      }catch(...){
         std::cerr<<"Bad news";
          return 2;
      }
      return 0;
}
With this pattern, you have the most versaility.
Lance

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