Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » optimieren von Programmen.

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
16.10.2002, 19:55 Uhr
~public_class
Gast


hab eben schon im alten Forum gepostet, aber da scheint mir nicht merh soooo gut besucht.

Wenn ich ein Programm habe, dass if then else-anweisungen, bzw. switch-anweisungen, schleifen und normale Rechnungen. Praktisch auch einen kleinen algorithmus. Gibt es irgendwleche Dinge, die man diesen ebfehlen beachten sollte, die das ganze etwas schneller machen, oder bestimmte schreibweisen, die c++ schneller verarbeiten kann ?

ich hoff eihr könnt mir da a bissle spezifisch für diese befehle helfen.:=
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
16.10.2002, 21:32 Uhr
fry_



Hi

Für switch nehme lieber if – else if u. bei Schleifen nimmst Du ++i anstelle von i++ bzw --i anstelle von i--.
Wenn Du arrays füllst, dann nehme lieber memcpy(array,füllwert,größe) als Schleifen.
Übergebe wenn möglich Referenzen u. arbeite beim Kopieren mit Adressen übergeben anstelle von Inhalt übergeben. Versuche eigentlich so viele Funktionen der STL zu nutzen, wie es nur geht -> die sind eh immer schneller.

Gruß
--
mit computern geht alles viel schneller
es dauert nur ein bisschen länger
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
17.10.2002, 00:05 Uhr
virtual
Sexiest Bit alive
(Operator)



Zitat:
fry_ postete
Hi
Für switch nehme lieber if – else if



Gewagte Aussage und ich würde das gegenteil empfehlen. Begründung: ein Compiler kann ein switch ggf. in eine Sprungtabelle umwandeln (manche tun das sogar), so dass die Verzeweigung in den entsprechenden case-Zweig deutlich schneller als beim if-else block ist


Zitat:

Wenn Du arrays füllst, dann nehme lieber memcpy(array,füllwert,größe) als Schleifen


Gilt natürlich nur für triviale Typen...

Zitat:

Übergebe wenn möglich Referenzen u. arbeite beim Kopieren mit Adressen übergeben anstelle von Inhalt übergeben.


Das gilt nicht für builtin-Types

Zitat:

Versuche eigentlich so viele Funktionen der STL zu nutzen, wie es nur geht -> die sind eh immer schneller.


Nö. Die STL als Geschwindigkeitswunder darzustellen ist auch sehr fraglich. Die STL kopiert Objekte ws das Zeug hält. Man findet nicht selten schnellere Implemementierungen (sogar selbst).

Naja, dann noch meine bescheidene Meinung zu dem Thema:
Klar, man kann eine Menge Fehler machen beim C++ wenn es ums Thema optimierung geht. Aber:
1. sind die meisten Compiler schon recht schlau und nehmen einem dabei eine Menge arbeit ab
2. ich kann fast nichts so schlecht leiden wie Code der unleserlich wird, weil der Autor probiert den schnellsten Code der Welt zu schreiben an Stellen, wo man sich nur an den Kopf fasst.

In der Regel bringen bewusste Optimierungen wirklich nur an bestimmten Stellen was.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
17.10.2002, 00:31 Uhr
fry_



...och, schaaade.
--
mit computern geht alles viel schneller
es dauert nur ein bisschen länger

Dieser Post wurde am 17.10.2002 um 00:31 Uhr von fry_ editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
17.10.2002, 06:46 Uhr
~public_class
Gast


Obwohl sich STL und referenzen verwenden wohl auf Dinge bezieht, die ich NOCH nicht erlernt habe.

Welche schleife ist denn am etwas die sparsamste? die for schleife nehme ich mal an ?

und für funktion wäre es wohl gut zeiger zu erlernen, anstatt alles mir parametern zu übergeben ?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
17.10.2002, 13:03 Uhr
fry_




Zitat:
und für funktion wäre es wohl gut zeiger zu erlernen, anstatt alles mir parametern zu übergeben ?

Es ist eigentlich immer ein Vorteil, mit Zeigern umgehen zu können. Ich weiß, dass das nicht so einfach ist u. ich kann mich noch gut an meine Anfangzeit erinnern: Zeiger u. wenn dann noch arrays oder Strings mit dazu kamen -> uijuijui *kopfamschütteln*
Referenzen in der Parameterliste zu verwenden, macht aber erst bei komplexen Objekten Sinn(zb. string). Bei char würde es Dir keinen großen Vorteil bringen, zumal char 1 Byte groß ist u. ein Zeiger in der Regel 4 Byte benötigt.

'inline' wurde noch nicht erwähnt. Wird eine Funktion aufgerufen, setzt der Prozessor seinen Programm-Zeiger auf diese Speicherstelle. Zuvor werden verschiedene Prozessorinterne Werte auf den Stapelspeicher gesichert, das sehr Zeitaufwendig ist.
Bei 'inline' definierten Funktionen, schreibt nun der Compiler diesen Code an die jeweiligen Positionen in die aufrufende Funktion hinein -> somit entfällt das Springen und das Sichern der Umgebung. Bläht Deine *.exe Datei zwar auf, macht aber Sinn.
Bsp.:

Code:
#include <iostream>

inline int max( int a, int b)
    { return a > b ? a : b; }

int main() {

    int a= 5, b = 6;
    std::cout << "Maximum von a und b: " << max(a,b) << std::endl;

    return 0;
}

(War der Quellcode früher nicht immer farblich?)


Zitat:

Welche schleife ist denn am etwas die sparsamste? die for schleife nehme ich mal an ?

Kann ich Dir leider nichts zu sagen. Aber so vom Gefühl her, würde ich das bejahen.

Gruß
--
mit computern geht alles viel schneller
es dauert nur ein bisschen länger

Dieser Post wurde am 17.10.2002 um 13:08 Uhr von fry_ editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
17.10.2002, 16:36 Uhr
Cer




Zitat:
fry_ postete
bei Schleifen nimmst Du ++i anstelle von i++ bzw --i anstelle von i--.



Warum ist ++i respektive --i denn schneller als i++ respektive i--?
--
-C
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
17.10.2002, 16:59 Uhr
void*
Generic Pointer
(Operator)


Hallo!

Beim Post-Inkrement bzw. -Dekrement muss eine Kopie von dem Objekt mit dem alten Wert erstellt werden, damit diese zurückgegeben werden kann. Das fällt bei der Prä-Version weg.

Gruß
void*
--
Gruß
void*
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
17.10.2002, 17:03 Uhr
fry_



... man, bin ich heute langsam.

Das kann man gut sehen, wenn man sich die Implementierung der beiden Operatoren anschaut:

C++:
// ++i;
Integer& Integer::operator++() //Präfix Inkrement
{
  ++value_;
  return *this;
}

// i++;
const Integer Integer::operator++(int) //Postfix Inkrement
{
  Integer temp(*this); // <- verlangsamt im Gegensatz zu ++i
  ++*this;
  return temp;
}


Bei i++ muss erst noch ein temporäres Objekt angelegt werden, damit der Originalwert erhalten bleibt und nicht das inkrementierte Objekt zurückgegeben wird.


Oder hier noch mal aus der originalen iterator Klasse:

C++:
// ++i;
_Myt& operator++()
    {--current;
    return (*this); }
// i++;
_Myt operator++(int)
    {_Myt _Tmp = *this;
    --current;
    return (_Tmp); }


--
mit computern geht alles viel schneller
es dauert nur ein bisschen länger

Dieser Post wurde am 17.10.2002 um 17:06 Uhr von fry_ editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: