🚀 go-pugleaf

Dietmar Kuehl wrote:
> Bei einem einfachen Member, wie 'char*' macht es vermutlich, ob des
> Optimierers, keinen echten Unterschied, aber bei komplizierteren Membern
> sollte man auf jeden Fall eine 'mem-initializer-list' verwenden, also
> den Konstruktor folgendermassen schreiben:
> 
>       charPointer(char *aValue):
>         value(aValue)
>       {
>       }
Das ist mal ein konstruktiver Vorschlag :-)

[Lehrreiches weggeschnippelt]

> ... und gleich noch was relativ neues aus dem Standard: Fuer den Fall,
> dass man eine etwaige Exception bei der Konstruktion eines Members in
> der 'mem-initializer-list' abfangen will, kann man das so schreiben:
> 
>       charPointer(char *aValue)
>         try
>         {
>           : value(a_value)
>           {
>           }
>         }
>         catch (...)
>         {
>         }

Abgesehen vom Nutzen der Exceptions muss ich Dir leider
sagen, dass sie ein aesthetischer Fauxpas sind:

versucheMalObDasGeht {
  Arbeit();
} WennNaemlichNicht {
  kannJaGarNixGegenTun();
  sageWasUebles();
  terminiere();
}

Ich ziehe da allemal noch das klassische assert()
vor. Ein Konstruktor darf IMHO gar nicht fehlschlagen,
ausser im Falle aeusserer Fehler (zu wenig Speicher
etc.). Da aber im Fall von externen Fehlerursachen
sowieso nichts behoben werden kann, kann man auch 
genausogut bereits im Konstruktor abbrechen (z.B.
mit assert()).
Nichtsdestotrotz ist die abenteuerliche Schreib-
weise zum Abfangen von Exceptions aus abgeleiteten
Konstrukturoen natuerlich ein Grund zum Schmunzeln,
wie auch:

this->~bla();
this= new blubber();

zur Herstellung von Dr. Mabuse-Objekten :-)
IMHO wird C++ gerade so erweitert, dass irgendwann
jede beliebige Zeichenfolge irgendeine Semantik
hat, das ist nicht sehr schoen.


>   template <class T>
>   class UnmanagedPointer
>   {
>   private:
>     T *i_res;
>   public:
>     explicit UnmanagedPointer(T *res = 0): i_res(res) {}
>     // The generated copy ctor, assignment, and dtor are suitable
> 
>     T    *operator-> () const      { return i_res; }
>     T    &operator[] (int i) const { return i_res[i]; }
>     T    &operator* () const       { return *i_res; }
>     T    *get() const              { return i_res; }
>     T    *release()                { T *rc = i_res; i_res = 0; return rc; }
>     void reset(T* res = 0)         { i_res = res; }
>   };

Das wollte ich eigentlich ausdruecken ;-)
-- 
*	Greetinx from Watson (sayegh@fokus.gmd.de)
	http://www.fokus.gmd.de/ovma/employees/sayegh/entry.html
	signal(SIGSEGV,SIG_IGN);