malloc und Exceptions

*Cpp-Anfänger* 0

Hallo zusammen,

mein Code sieht zur Zeit immer etwa so aus:

char* p = (char*)malloc(4096);
try{
// Hier kann ne Exception fliegen
free(p);
}
catch(...){
free(p);
throw;
}

Gibt es da noch ne andere Möglichkeit?

Es geht ja auch mit einem std::vector (nicht getestet!):

std::vector<char> vec = std::vector<char>(4096);
// Hier fliegt ne Exception

Das ist natürlich kürzer, aber wie groß ist der Overhead?
(Ich bin da ziemlich pingelig )

Kann man anders dafür sorgen, dass mein durch malloc angeforderter
Speicher nach Ablauf des Blocks immer freigegeben wird?

Gruß,
*Cpp-Anfänger*

a) Wenn überhaupt dann new[] und delete[] nehmen!
b) Der Overhead von Vector ist zu vernachlässigen. Wenn du aber immer eine feste größe hast kannst du auch boost::array<> nehmen

Der Overhead bei std::vector ist das ganze Array mit 0 initialisiert wird.

Zur not baust du dir halt einen smart-ptr:

template< typename T >
class smart_ptr
{
public:
  smart_ptr( T* src = 0 ) //mit malloc allozierter speicher
    : pointee_( src )
  {
  }

  ~smart_ptr()
  {
      free( pointee_ );
  }

  T& operator*()
  {
      return *pointee_;
  }

  T* operator->()
  {
      return pointee_;
  }

  T* get()
  {
      return pointee_;
  }

  bool is_valid()
  {
      return pointee_ != 0;
  }

private:

  const smart_ptr& operator=( const smart_ptr& other );
  smart_ptr( const smart_ptr& other );

  T* pointee_;
};

Ist nicht wirklich ausgereift, aber das grundlegende hat er so.

Achja du kannst auch einfach rohen speicher mit ::operator new[] anfordern, dann wird der Konstruktor nicht aufgerufen und den kannst du über ein placement new aufrufen, dann kannst du den speicher einfach mit delete[] löschen, wenn operator delete[] nicht überladen wurde, ansonsten einfach mit einem expliziten d'tor Aufruf und einem anschließenden ::operator delete[] Aufruf.

groovemaster

Cpp-Anfänger schrieb:

Gibt es da noch ne andere Möglichkeit?

Ja, du nimmst einen entsprechenden Smart Pointer, wie boost::scoped_array. Die bessere Lösung ist hier aber definitiv ein passender Container. Und wie bereits erwähnt wurde, der Overhead ist zu vernachlässigen. Sollten idR maximal 2 size_t's zusätzlich sein.

Simon2

Cpp-Anfänger schrieb:

...Overhead ... (Ich bin da ziemlich pingelig)...Cpp-Anfänger

Warum bist Du da pingelig ?

Gruß,

Simon2.