🚀 go-pugleaf

Christoph Liebig <chris>:
>Bekanntlich kann man in C++ eigene Typkonversionsoperatoren definieren.
>Beispielsweise um ein Objekt der Klasse A nach B zu casten, koennte in A der
>operator B()' definiert werden, der ein B-Objekt zurueckliefern muss.
>Was bedeutet das fuer das target-Objekt der Klasse A, wenn es nach B gecastet
>wird ? Wird das Objekt A zerstoert -- ich denke nein, und nehme an, dass bei
>casts sogenannte temporary objects erzeugt werden.

Was die Lebensdauer der A- und der zurueckgelieferten B-Instanz betrifft, 
verhaelt es sich genauso wie bei Memberfunctions. Wird eine Instanz der 
Klasse B zurueckgeliefert, wird der B-Copy-Constructor aufgerufen, ein
temporaeres Objekt erzeugt und an geeigneter Stelle wieder zerstoert.
Bei einer Initialisierung der Form 'B b=(B)a;' bleibt das temp. Objekt z.B.
solange bestehen, bis die Initialisierung von 'b' abgeschlossen ist.
Einen Einfluss auf die Lebensdauer der A-Instanz hat dies (i.allg.) nicht.

>Wenn dem so ist,  muesste in operator B() eine neues B Objekt konstruiert
>werden und ueberdies koennte der operator B() gegebenenfalls als const
>deklariert werden.

Ja

>Gibt es dazu naehere Vorschriften oder Konventionen (beispieslweise koennten
>cast operatoren guenstigerweise nur eine Referenz zurueckliefern) ?

Das haengt stark von der Art der Typumwandlung ab. Falls die B Instanz
z.B. als Member-Variable in der Klasse A enthalten ist, bietet es sich
sicherlich an eine *konstante* Referenz darauf zurueckzuliefern.
Der Nachteil von Konversionsoperatoren ist, dass man ein Stueck 'Kontrolle'
ueber sein Programm verliert, was zu wirklich ueblen (=schwer auffindbaren)
Fehlern fuehren kann. Haeufig ist deshalb eine normale Memberfunction 
vorzuziehen, auch wenn auf den ersten Blick der Konversionsoperator 
schicker aussieht.

	Gruss
		Enno

Christoph Liebig (chris) wrote:
>  Hallo !

>  Bekanntlich kann man in C++ eigene Typkonversionsoperatoren definieren.
>  Beispielsweise um ein Objekt der Klasse A nach B zu casten, koennte in A der
>  operator B()' definiert werden, der ein B-Objekt zurueckliefern muss.
>  Was bedeutet das fuer das target-Objekt der Klasse A, wenn es nach B gecastet
>  wird ? Wird das Objekt A zerstoert 

Nur wenn Du darauf bestehst. Natuerlich kann die Funktion A::operator B()
eigene Member veraendern oder gar "delete this" aufrufen - sinnvoll ist 
das meist nicht. Vorsichtshalber sollte man sie gleich als const deklarieren.

> -- ich denke nein, und nehme an, dass bei
>  casts sogenannte temporary objects erzeugt werden.
>  Wenn dem so ist,  muesste in operator B() eine neues B Objekt konstruiert
>  werden und ueberdies koennte der operator B() gegebenenfalls als const
>  deklariert werden.

Ob temporaere Objekte erzeugt werden, haengt vom Compiler ab. Es steht ihm
frei, sie in geeigneten Situationen wegzuoptimieren.

Beispiel:

	A	a(4711);
	B	b(a);

Ein schlauer Compiler kann direkt das Objekt b initialisieren, ohne Umweg
ueber eine temporaere Variable.

>  Gibt es dazu naehere Vorschriften oder Konventionen (beispieslweise koennten
>  cast operatoren guenstigerweise nur eine Referenz zurueckliefern) ?

Das mit der Referenz ist sinnvoll, wenn es sich um eine auf das 
A-Objekt selber (bzw. einen Basisteil davon) handelt. Allerdings ist das
dann ein anderer Cast, naemlich operator B&().
Beim Cast Referenzen auf _Member_ zurueckgegeben, ist dagegen natuerlich 
ueberhaupt nicht zu empfehlen.

Gruss
	Bernd

--
+----------------------------------+
|          Bernd Eggink            |
|    Rechenzentrum Uni Hamburg     |
| admin@rzaix13.rrz.uni-hamburg.de |
+----------------------------------+

admin@rzaix13.uni-hamburg.de (Bernd Eggink) writes:

> Beim Cast Referenzen auf _Member_ zurueckgegeben, ist dagegen natuerlich 
> ueberhaupt nicht zu empfehlen.

Wieso?  Wenn nach dem Konversionsoperator der Copy-Konstruktor
drankommt, wird der Kram i.a. doch sowieso kopiert, und dann kann das
Originalobjekt ohne weiteres gelöscht werden.

Wenn der Copy-Konstruktor tatsächlich Referenzen speichert, so ist das
sein Problem, nicht das des Konversionsoperators.

Harald Fuchs (hf@colibri.de) wrote:
>  admin@rzaix13.uni-hamburg.de (Bernd Eggink) writes:

>  > Beim Cast Referenzen auf _Member_ zurueckgegeben, ist dagegen natuerlich 
>  > ueberhaupt nicht zu empfehlen.

>  Wieso?  Wenn nach dem Konversionsoperator der Copy-Konstruktor
>  drankommt, wird der Kram i.a. doch sowieso kopiert, und dann kann das
>  Originalobjekt ohne weiteres gelöscht werden.

Kommt er aber nicht immer:

  class A
  {
	public:
	  // ...
	  A(int p): x(p) { }
	  operator int &() { return x; }

	private:
	  int   x;
  };

  A    *pa = new A(4711);

  int  &r = *pa;     // Aufruf pa->operator int &()   
  delete pa;
  r = 0;             // oops - r zeigt auf geloeschtes Objekt

Gruss
	Bernd

--
+----------------------------------+
|          Bernd Eggink            |
|    Rechenzentrum Uni Hamburg     |
| admin@rzaix13.rrz.uni-hamburg.de |
+----------------------------------+

Hallo,

Ich bin mir nicht sicher, ob Typ-Casting mit eigenen Klassen geht.
In einer Matrix-Klasse benutze ich den Copy-Constructor, um aus einem
Vektor eine Matrix zu erzeugen. Das ist eine echte Umwandlung und nicht 
nur eine andere Interpretation.
Bsp:

template <class T> class Matrix
{
..
   Matrix   ( const Matrix<T>& );
   Matrix   ( const Vector<T>& );
..
}
template <class T> Matrix<T>::Matrix ( const Vector<T>& a )
{
..
}

In einem Programm koennte man das so anwenden:
Vector<int> V;
Matrix<int> M;

M = M * V;

Aus dem Vektor V wird eine temporaere Matrix erzeugt und diese mit M
multipliziert (mit M.operator*).

M.operator() benutze ich uebrigens zur FORTRAN-Indizierung einer Matrix.

Gruss
Bernd Braun
-- 
Bernd Braun, mailto:braun@stahlw00.stahl.bau.tu-bs.de
http://stahlw00.stahl.bau.tu-bs.de/people/bbraun.html
Institut fuer Stahlbau, TU Braunschweig
Beethovenstrasse 51, 38106 Braunschweig, Germany

Bernd Braun (braun@stahlw00.stahl.bau.tu-bs.de) wrote:
>  Hallo,

>  Ich bin mir nicht sicher, ob Typ-Casting mit eigenen Klassen geht.
>  In einer Matrix-Klasse benutze ich den Copy-Constructor, um aus einem
>  Vektor eine Matrix zu erzeugen. Das ist eine echte Umwandlung und nicht 
>  nur eine andere Interpretation.
>  Bsp:

>  template <class T> class Matrix
>  {
>  ..
>     Matrix   ( const Matrix<T>& );
>     Matrix   ( const Vector<T>& );
>  ..
>  }
>  template <class T> Matrix<T>::Matrix ( const Vector<T>& a )
>  {
>  ..
>  }

>  In einem Programm koennte man das so anwenden:
>  Vector<int> V;
>  Matrix<int> M;

>  M = M * V;

>  Aus dem Vektor V wird eine temporaere Matrix erzeugt und diese mit M
>  multipliziert (mit M.operator*).

Prima! Und wo ist das Problem??

	Bernd

--
+----------------------------------+
|          Bernd Eggink            |
|    Rechenzentrum Uni Hamburg     |
| admin@rzaix13.rrz.uni-hamburg.de |
+----------------------------------+