🚀 go-pugleaf

Ruediger Berlich <berlichr@afal23.cern.ch> (10.03.96):

> Hallo,
> - Wenn ich etwa die folgenden (Member-)Funktionen/Klassen
> deklariere/definiere :   (schwachsinnig, ich weiss, soll nur ein Beispiel
> sein)
>
> ===============================================
>
> class matrix
> {
> public:
>  matrix(long, long);
>  matrix(const matrix&);
> ...
>  matrix& giveBackMatrix(void);
>  matrix& operator=(const matrix&);
>  matrix& operator=(double); // Soll Matrix mit dem Argument initialisieren
> private:
> ...
> };
>
> matrix& matrix::giveBackMatrix(void)
> {
> matrix z(*this);
> return z;
> }
>
> main()
> {
> matrix x(3,3),y(3,3);
> x=1.;
> y=0.;
> ...
> y=x.giveBackMatrix();
> }
>
> =============================================
>
>  w"are dann sichergestellt, dass 'z' als lokale Variable lange genug
>  lebt, um operator= auszuf"uhren ?

Nein, die lokale Variable muss geloescht werden, bevor die  
Funktion zurueckkehrt; operator= wird erst nach der  
Rueckkehr aufgerufen.

>  W"urden dann in y also lauter
>  '1.' stehen ? Oder w"are das Ganze undefiniert ?

Ja.

>  Anders ausgedr"uckt, wie kann ich bei der R"uckgabe einer Referenz
>  vermeiden, den R"uckgabewert (z) mit 'new' anlegen zu m"ussen
>  (==> explizites L"oschen notwendig) ?

Lass' doch einfach das '&' beim Rueckgabewert weg, dann wird  
das ganze nicht als Referenz sondern als Kopie (mit new  
angelegt) uebergaben; aber der Compiler kuemmert sich  
implizit um das Loeschen.

Claus

------------------------------------------------------------------------
Claus Andre Faerber - claus@faerber.muc.de - http://www.muc.de/~cfaerber
------------------------------------------------------------------------

Ruediger Berlich <berlichr@afal23.cern.ch> (10.03.96):

> Hallo,
> ich habe ein paar Fragen :
> - Ist es durchweg ratsam, alle Z"ahl-Variablen als
>   'register' zu deklarieren ? Oder sollte man sich da nur auf die
>   wichtigsten (am h"aufigsten gebrauchten) beschr"anken ?
>   Ich stelle mir vor, dass ja immer nur eine beschr"ankte Anzahl von
>   Variablen die Register des Prozessors belegen kann. Bremst man so nicht
>   das ganze Programm aus ? Oder ist 'register' nur eine Empfehlung an
>   den Compiler ?

So ist es. Das Schluesselwort 'register' sagt dem Compiler  
nur, dass es hier besonders effizient waere, die Variable in  
einem Register zu speichern, weil sie oft benutzt wird. Ob  
der Compiler das dann macht (machen kann) und ob und wie er  
ohne 'register' trotzdem Register benutzt ist seine Sache.

Claus

------------------------------------------------------------------------
Claus Andre Faerber - claus@faerber.muc.de - http://www.muc.de/~cfaerber
------------------------------------------------------------------------

Ruediger Berlich <berlichr@afal23.cern.ch> (10.03.96):

> - Mir wurde erz"ahlt, dass auf modernen (>= 32 Bit-) Rechnern intern alle
>   floatingpoint-Zahlen als double dargestellt sind, sodass Programme,
>   die nur mit double arbeiten, schneller sind, da floats intern umgewandelt
>   werden m"ussen. Stimmt das und gilt dasselbe dann auch f"ur int/long ?

Die Koprozessoren von intel 80x86-Prozessoren arbeiten  
intern ausschliesslich mit 80 Bit, also 'long double'.
'float' und 'double' sind also, da sie beide intern  
umgewandelt werden, etwa gleich schnell.
'long double's sind interesanterweise sogar langsamer, weil  
sie im Gg.satz zu 'float' und 'double' bei einigen Befehlen  
(zB. FADD, floating p. add) nicht direkt aus dem Speicher  
gelesen werden koennen, sondern erst mit einem separaten  
Befehl geladen werden muessen.

'int' und 'long' sien auf intel 32-Bit-Systemen etwa gleich  
schnell, auf anderen 32-Bittern kann es wirklich sein, dass  
die Konvertierung einen Geschwindigkeitsnachteil bringt.

Claus

------------------------------------------------------------------------
Claus Andre Faerber - claus@faerber.muc.de - http://www.muc.de/~cfaerber
------------------------------------------------------------------------

Moin Ruediger,

In article <Do2325.Fwu@news.cern.ch>, berlichr@afal23.cern.ch (Ruediger Berlich) writes:
|> Hallo,
|> ich habe ein paar Fragen :
|> - Ist es durchweg ratsam, alle Z"ahl-Variablen als
|>   'register' zu deklarieren ? Oder sollte man sich da nur auf die
|>   wichtigsten (am h"aufigsten gebrauchten) beschr"anken ?
|>   Ich stelle mir vor, dass ja immer nur eine beschr"ankte Anzahl von
|>   Variablen die Register des Prozessors belegen kann. Bremst man so nicht
|>   das ganze Programm aus ? Oder ist 'register' nur eine Empfehlung an
|>   den Compiler ?

register ist eine Empfelung (muss es auch sein, man denke nur daran, dass
irgentwann einmal ein Zeiger auf die Variable verlangt wird. Dann muss sie
zwangslaeufig als "normale" Speichervariable angelegt werden). I.d.R. ist
es auch nicht notwendig (bzw. sinnvoll) sich darueber Gedanken zu machen, 
welche Variablen in Registern gehalten werden sollen. Ein optimierender 
Compiler macht das automatisch (und meistens besser als der Programmierer).
Sinnvoll ist es hoechsten, wenn man durch profilen des Otimierten 
Programm signifikante Performance-Maengel festgestellt hat.

|> - Mir wurde erz"ahlt, dass auf modernen (>= 32 Bit-) Rechnern intern alle 
|>   floatingpoint-Zahlen als double dargestellt sind, sodass Programme,
|>   die nur mit double arbeiten, schneller sind, da floats intern umgewandelt
|>   werden m"ussen. Stimmt das und gilt dasselbe dann auch f"ur int/long ?

Wie die eingebauten Datentypen dargestellt werden, ist Sache der Compiler-
bauer. Der Standard schreibt lediglich vor:
sizeof(long)>=sizeof(int)>=sizeof(char)=1
Das laesst sogar die Moeglichkeit zu alle Ganzzahligen Werte 32bit zu codieren.
Die kleinste anzusprechende Speichereinheit ist dann 4 Byte. Fuer Float
und double gilt analoges. Gerade wenn float und double intern identisch
sind faellt uebrigens die Umwandlung weg. Bei der Benutzung von Bibliotheken
gilt: Wenn man die Datentypen nutzt, die im Funktions-/Methodenaufruf 
gewuenscht werden, ist das Programm i.d.R. minimal schneller. Typwandlungen
sollte man nur fuer die Faelle benutzen, in denen es triftige Gruende gibt
andere als die in den Bibliotheken benutzten Typen zu verwenden (Haupt-
argument hierfuer ist aber, der gerade impliziete Typwandlungen dazu neigen,
zweideutig zu sein).

|> - Wenn ich etwa die folgenden (Member-)Funktionen/Klassen deklariere/definiere :
|>   (schwachsinnig, ich weiss, soll nur ein Beispiel sein)
|> 
[Beispiel geloescht]
|> 
|>  w"are dann sichergestellt, dass 'z' als lokale Variable lange genug
|>  lebt, um operator= auszuf"uhren ? 

Definitiv nein.
|>W"urden dann in y also lauter
|>  '1.' stehen ? Oder w"are das Ganze undefiniert ?

Definitv ja: Der Stack wird beim return aufgraeumt, also sind die localen
Variablen dann weg.

|>  Anders ausgedr"uckt, wie kann ich bei der R"uckgabe einer Referenz
|>  vermeiden, den R"uckgabewert (z) mit 'new' anlegen zu m"ussen 
|>  (==> explizites L"oschen notwendig) 

Keine Referenz sondern ein Objekt zurueckgeben. Du musst ohnehin irgendwann
dieses Objekt erzeugen (siehe z in deinem Beispiel). Es nuetzt nichts, man
darf seine Daten nicht wegoptimieren.

|> 
|> Danke f"ur Eure Hilfe,
|> R"udiger

Bitte schoen
Oliver

-- 
O. Rebach <Oliver.Rebach@UniBw-Hamburg.DE>                /|\  /|\
Universitaet der Bundeswehr Hamburg FB Maschinenbau      / | \/ |
Fachgebiet Maschinenelemente und Getriebetchnik         |--|    | ~|
- CAD - Labor -                                            |    | /