🚀 go-pugleaf

Alfred wrote:

> What about : char * buf=new char[Size]; 
> It is good like a vector or it is not a good idea to use ?

It's quite okay to use it but as Thomas has said it's harder to ensure
it doesn't leak. Taking the example code I posted:

char * buf=new char[ Size ];
File->Read( buf, Size );
Form1->Memo->Lines->Add( AnsiString( buf, Size ) );
delete[] buf;

Both of the the middle two statements could raise exceptions. The
Read() in particular could since it's file I/O. If either of them does
the code will exit before ever reaching the 'delete[]' and that will
leak memory. The same is true for your original code.

The reason std::vector doesn't have this problem is that although an
exception would still of course cause the code to exit, any local stack
based variables will be correctly destroyed. For a 'char *' that
doesn't mean anything but a std::vector<char> is a class and when it's
destroyed its destructor will be called. That will ensure that any
related allocations are cleared up.

FWIW there is another way to do this and when 'upgrading' code I often
prefer it. There is a library called Boost (www.boost.org) and one of
its template classes is designed to wrap array pointers and ensure they
are deallocated:

boost::scoped_array<char> buf( new char[ Size ] );
File->Read( buf.get(), Size );
Form1->Memo->Lines->Add( AnsiString( buf.get(), Size ) );

The advantage of this (for me) is that it keeps a lot of the old code
and thus makes it obvious that it's been upgraded. I work with a lot of
old code and knowing the vintage of that code can be very handy.
-- 
Andrue Cope [TeamB]
[Bicester, Uk]
http://info.borland.com/newsgroups/guide.html