Einmal habe ich das ganze mit Direktem Zugriff auf die Variable gemacht und einmal mit Pointern, doch ein Unterschied war einfach nicht zu spüren.
Vielleicht könnte mir das jemand erklären oder noch besser ein Beispiel dafür geben bei dem man wirklich merkt das ein Geschwindigkeit's-Unterschied vorhanden ist am liebsten währe mir ein Code.

Vielen Dank,
Gruß,
scratsch

scratsch schrieb:

... am liebsten währe mir ein Code.
Vielen Dank,
Gruß,
scratsch

viel spass beim coden!

mfg,
p.

Geschwindigkeit's-Unterschied

Aua!

... ü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

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.

Da's macht doch gar keinen Unter'schied.

Warum gibt es dann Zeiger? Dachte die sind Schneller mh

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.

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?

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

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".

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!"

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

#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)

"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

#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!?

"Achtung Pseudocode"

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

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;
	}
}

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...

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!

Ein Pointer ist immer so groß wie das Maschinenwort!

Nö.