Geschwindigekits-Vorteil Pointer

volkard

scratsch schrieb:

Geschwindigkeit's-Unterschied

Aua!

point0r schrieb:

... übergib 1000 000 mal an die funktion als pointer und 1000 000 mal als zeiger...

ist das so warm? ne. einmal als instanz und einmal als zeiger

TyRoXx

Wa's i'st eigentlich die genaue Frage?

for (int i = 0; i < 10000; ++i)
{
	cout << i << endl; //direkter Zugriff
}

for (int i = 0; i < 10000; ++i)
{
	int *p = &i;
	cout << *p << endl; //über Zeiger
}

Da's macht doch gar keinen Unter'schied.

scratsch

Da's macht doch gar keinen Unter'schied.

Warum gibt es dann Zeiger? Dachte die sind Schneller mh

volkard

scratsch schrieb:

Da's macht doch gar keinen Unter'schied.

Warum gibt es dann Zeiger? Dachte die sind Schneller mh

Nein, sie sind lang'samer. Aber halt nur ein wenig lang'samer. Ganze Strukturen zu übergeben i'st bei superkleinen Strukturen schneller und bei normalen lang'samer und bei großen lahm und bei sehr großen sehr lahm und bei supergroßen superlahm. Da nimmt man Zeiger, die sind nur ein ganz wenig lang'samer und damit viel viel schneller als superlahm.

Da hast du was falsch verstanden.

Was du wahrscheinlich meinst ist:
Achtung Pseudocode!

int array[5242880]; // Das array wäre 20 MB groß
int *arraypointer = &array;

funktion1 (array)
funktion2 (arraypointer)

Hier würden bei funktion1 die ganzen 20MB im Speicher kopiert und die Kopie an Funktion1 übergeben. Bei funktion2 wird hingegen nur der Pointer (32Bit = 4byte) übergeben was soch um einiges schneller ist (zusätzlich spart es speicher ).

War das gemeint?

unskilled

orlor schrieb:

Da hast du was falsch verstanden.

Was du wahrscheinlich meinst ist:
Achtung Pseudocode!
int array[5242880]; // Das array wäre 20 MB groß
int *arraypointer = &array;

funktion1 (array)
funktion2 (arraypointer)
Hier würden bei funktion1 die ganzen 20MB im Speicher kopiert und die Kopie an Funktion1 übergeben. Bei funktion2 wird hingegen nur der Pointer (32Bit = 4byte) übergeben was soch um einiges schneller ist (zusätzlich spart es speicher ).

War das gemeint?

seit wann kann man in C++ arrays per value übergeben ohne hilfsklassen zu nutzen?
zu dem:
so müsste es heißen:
int *arraypointer = &array[0];
oder gleich so:
int *arraypointer = array;
und dann sieht man auch schon, dass das array eh nur ein pointer ist und nicht ohne weiteres kopiert werden kann...

bb

Artchi

scratsch schrieb:

Da's macht doch gar keinen Unter'schied.

Warum gibt es dann Zeiger? Dachte die sind Schneller mh

Echt? Zeiger sind da, weil damit es schneller geht? Höre ich das erste Mal das Argument. Zeiger sind (wie der Name sagt) zum Zeigen da. Also jetzt mal wirklich im Ernst: für mich zeigen Zeiger auf eine Speicherstelle. NIcht mehr und nicht weniger!
Der Gedanke, das es sie gibt damit es schneller gehen soll, fällt glaube ich in diesem Forum auch das erste Mal.

Es gibt in C++ eigentlich keine Spracheigenschaften, die explizit für "damit es extra schneller geht" gemacht sind. Weil das würde ja bedeuten, das es einen Gegenpart gibt, der bewusst für "damit es langsamer wird" gemacht ist. Ist doch aber blödsinn?

Wenn ich einen Value (z.B. eine Struktur) ohne Pointer und ohne Reference übergebe... dann mache ich das, weil ich einen Value-Copy will. Und nicht weil ich will, das es langsam wird. Ist doch logisch, oder? Und wenn ich keinen Value-Copy will, mache ich einen Parameter by-Reference oder by-Pointer. Das es dann zufällig schneller ist, ist ein "Abfallprodukt".

life

unskilled schrieb:

seit wann kann man in C++ arrays per value übergeben ohne hilfsklassen zu nutzen?
zu dem:
so müsste es heißen:
int *arraypointer = &array[0];
oder gleich so:
int *arraypointer = array;
und dann sieht man auch schon, dass das array eh nur ein pointer ist und nicht ohne weiteres kopiert werden kann...

bb

"Achtung Pseudocode!"

volkard

Artchi schrieb:

Es gibt in C++ eigentlich keine Spracheigenschaften, die explizit für "damit es extra schneller geht" gemacht sind.

Das Schlüsselwort register
Das Schlüsselwort inline
Die Array-Übergabe per Zeiger

scratsch

Ok, da habe ich mich was die Verwendung von Zeigern angeht wohl deutlich geirrt, in der Zwischenzeit ist noch etwas aufgetaucht und zwar möchte ich einmal folgenden Code-Ausschnitt zeigen wo das Hauptaugenmerk bitte auf default: zu legen ist:

#include <iostream>
using namespace std;
int choice;

void menu()
{
    switch (choice)
    {

    case 1:
        cout << "TestA gewealt!";
        break;

    case 2:
        cout << "TestB gewealt!";
        break;

    case 3:
        cout << "TestC gewealt!";
        break;

    default:
        system("cls");
        cout << "Falscher Wert wurde eingegeben! \n";
        menu();
        break;
    }

}

int main ()
{
    cout << "[Test-Application - Bitte waehlen:]" << endl;
    cout << endl;
    cout << "[1] TestA" << endl;
    cout << "[2] TestB" << endl;
    cout << "[3] TestC" << endl;
    cin >> choice;
    menu();
    return 0;
}

Auszug:

default:
        system("cls");
        cout << "Falscher Wert wurde eingegeben! \n";
        menu();
        break;
    }

Mein Gedanke dahinter war recht einfach: Sobald eine Fehleingabe gemacht wird soll zur Auswahl zurückgekehrt werden, leichter gesagt als getan ^^
Wenn ich einfach die menu(); wieder aufrufe bleibt er dabei hängen, also wo ist der Fehler?
(Ich wollte jetzt nicht noch einmal extra einen neuen Thread eröffnen)

life schrieb:

"Achtung Pseudocode!"

Danke auf das wollte ich auch grade aufmeksam machen. Das nächste mal mache ich es fett und färbe es rot ein

scratsch

So,
bin in meinem kleinen Menü-Problem von oben schon etwas weiter gekommen das ist der Aktuelle Stand:

#include <iostream>
#include <conio.h>
using namespace std;
int choice;
int error_count;        // Counter für Fehl-Eingaben

void usr_in()
{
    system ("cls");
    cout << "[Test-Application - Bitte waehlen:]" << "   Fehler: " << error_count << endl;
    cout << endl;
    cout << "[1] TestA" << endl;
    cout << "[2] TestB" << endl;
    cout << "[3] TestC" << endl;
    cin >> choice;
    cout << "\n";
}

void check_error()
{
    if (error_count == 1)
    {
        choice = 4;
        error_count = 0;
        usr_in();
    }
}

void menu()
{

    switch (choice)
    {

    case 1:
        cout << "TestA gewealt!";
        break;

    case 2:
        cout << "TestB gewealt!";
        break;

    case 3:
        cout << "TestC gewealt!";
        break;

    default:

        if (error_count < 1)
        {
            error_count ++;             // Eine Fehl-Eingabe hinzuzählen
        }
        check_error();
        system("cls");
        cout << "Falscher Wert wurde eingegeben! \n";
        getch();
        usr_in();
        menu();
        break;
    }
}

int main ()
{
    usr_in();
    menu();
    return 0;
}

Problem derzeit:
Sobald ein Buchstabe eingegeben wird endet das ganze in einer Endlos-Schleife - Dafür hatte ich einen Fehler-Counter eingebaut nur leider funktioniert dieser nicht so wie er ist. Mein Gedanke dabei:
Sobald eine Fehl-Eingabe getätigt wird ist "default:" zuständig, also erhöhe ich einfach den Wert des Error-Zählers um 1eins, stößt er nun ein zweites mal auf diese Ebene und der Error Zähler ist schon 1 wird der Eingegebenen-Variable einfach wieder eine Zahl zugewiesen so das der Buchstabe nicht mehr vorkommen kann, dann wird wieder alles "resetet" und das ganze sollte wieder gehen - leider fehlanzeige!?

volkard

Tätest Du das alles in die main() hauen, wär's aber hübscher und die Probleme wären auch weg. Oder in eine Funktion namens menu.
Die klassische Menuschleife geht übrigens so:

"Achtung Pseudocode"

bool willnochmal
do
  eingabe
  switch
    case
      tuwas
    case
      tuwasandres
    default
      beschimpfe benutze
while willnochmal

TyRoXx

volkard schrieb:

Artchi schrieb:

Es gibt in C++ eigentlich keine Spracheigenschaften, die explizit für "damit es extra schneller geht" gemacht sind.

[...]
Die Array-Übergabe per Zeiger

Damit kommen wir wieder ganz an den Anfang zurück. Zeiger sind nicht nur dafür da, dass es schneller geht.

Es war wohl eher sowas gemeint:

int add(int a, int b)
{
	int result;

	fast
	{
		result = a + b;
	}

	very fast
	{
		return result;
	}
}

unskilled

orlor schrieb:

life schrieb:

"Achtung Pseudocode!"

Danke auf das wollte ich auch grade aufmeksam machen. Das nächste mal mache ich es fett und färbe es rot ein

deshalb war das &arr[0] auch nur so am rande - aber die übergabe eines arrays als bsp zu nutzen ist einfach falsch...

XaTrIxX

orlor schrieb:

Hier würden bei funktion1 die ganzen 20MB im Speicher kopiert und die Kopie an Funktion1 übergeben. Bei funktion2 wird hingegen nur der Pointer (32Bit = 4byte) übergeben was soch um einiges schneller ist (zusätzlich spart es speicher ).

Falsch. Ein Pointer hat prinzipiell keine Größe von 32Bit. Ein Pointer ist immer so groß wie das Maschinenwort!

volkard

XaTrIxX schrieb:

Ein Pointer ist immer so groß wie das Maschinenwort!

Nö.