Vielen Dank im Voraus!

Gruß
wxSkip

std::sort() wird mit ziemlicher Sicherheit effizienter sortieren, als irgendwas, das du schreiben würdest. Die Standardbibliothek wurde nämlich über Jahre hinweg entwickelt und man kann davon ausgehen, dass die Entwickler sich auch über Optimierungsmöglichkeiten Gedanken gemacht haben.

So sieht ein Aufruf aus. Mehr Infos findest du unter www.cplusplus.com.

std::sort(vec.begin(), vec.end());

Nein, mach sowas nicht! Das widerspricht dem Prinzip der Kapselung und Objektorientierung.

std::sort() wird mit ziemlicher Sicherheit effizienter sortieren, als irgendwas, das du schreiben würdest. Die Standardbibliothek wurde nämlich über Jahre hinweg entwickelt und man kann davon ausgehen, dass die Entwickler sich auch über Optimierungsmöglichkeiten Gedanken gemacht haben.

So sieht ein Aufruf aus. Mehr Infos findest du unter www.cplusplus.com.

std::sort(vec.begin(), vec.end());

Komischerweise hab ich erst neulich eine Funktion geschrieben, die schneller sortiert...
Jetzt wollte ich schauen, ob meine Sortierfunktion für C-Arrays noch schneller darauf läuft...

Ja natürlich gehts um die Version der Standardlibrary, aber die ist wie du schon sagtest mit dem Compiler recht gut verdrahtet. Welchen Algorithmus hast du denn implementiert? AFAIK nutzen einige std::sort Implementierungen Quicksort und der hat im Worst-Case ja immer noch O(n²), so gesehen könntest du schon recht haben.

Tatsächlich? Ich dachte immer die benutzen ein ziemlich gut optimiertes IntroSort?!

MfG SideWinder

Komischerweise hab ich erst neulich eine Funktion geschrieben, die schneller sortiert... Jetzt wollte ich schauen, ob meine Sortierfunktion für C-Arrays noch schneller darauf läuft...

Kann sein, dass es für deinen spezifischen Fall schneller war. Ich denke, std::sort() ist auf grosse Datenmengen ausgelegt und im Allgemeinen keine schlechte Wahl.

Dann schreib deinen Sortieralgorithmus basierend auf Iteratoren oder Indizes. Es gibt keinen Grund, wieso du den internen Zeiger kennen müsstest.

std::vector<int> myVector(100);
int* myIntAttay = &myVector[0];

Nein, mach sowas nicht! Das widerspricht dem Prinzip der Kapselung und Objektorientierung.

std::sort() wird mit ziemlicher Sicherheit effizienter sortieren, als irgendwas, das du schreiben würdest. Die Standardbibliothek wurde nämlich über Jahre hinweg entwickelt und man kann davon ausgehen, dass die Entwickler sich auch über Optimierungsmöglichkeiten Gedanken gemacht haben.

So sieht ein Aufruf aus. Mehr Infos findest du unter www.cplusplus.com.

std::sort(vec.begin(), vec.end());

1.Eine friend-Funktion widerspricht dem Prinzip aber nicht, oder?
2.Wenn ich Sicherheit wollte, würde ich nicht C++ programmieren

SideWinder: Ja du scheinst recht zu haben - meine Information ist auch schon etwas älter.

1.Eine friend-Funktion widerspricht dem Prinzip aber nicht, oder?

Natürlich widerspricht es dem Prinzip, du müsstest schliesslich den std::vector verändern!

wxSkip schrieb:

2.Wenn ich Sicherheit wollte, würde ich nicht C++ programmieren

In der Tat sehr einfallsreich. Dirty Hacks, wie du sie gerade versuchst, würde ich nicht als modernes C++ bezeichnen. Aber weil es möglich ist, darf man nicht mehr selbst nachdenken, genau.

Sag einfach, warum du meinst, direkt auf die Interna zugreifen zu wollen. Du kannst

• Iteratoren benutzen
• Indizes benutzen, genau wie beim C-Array
• Icematix' Variante einsetzen, weil std::vector das garantiert. Aber stell dich darauf ein, dass du im Debug-Modus keine Sicherheitsabfragen mehr hast.

Im Ernst: Wenn dein Compiler und deine Standardbibliotheken irgendetwas taugen, sollten alle Möglichkeiten ungefähr gleich schnell sein (deaktivierbare Laufzeitchecks mal nicht berücksichtigt).

Bei Icematix' Variante stürzt das Programm aber immer ab, wahrscheinlich, weil vec[0] eine Referenz zurückgibt.

Wahrscheinlich eher, weil du die besagten Sicherheitsabfragen nicht mehr hast und ausserhalb des gültigen Bereichs zugreifst.

Schreib dein Programm zuerst korrekt und optimiere dann. Für ersteres kannst du den überladenen operator[] oder noch besser at() verwenden.

wxSkip schrieb:

1.Eine friend-Funktion widerspricht dem Prinzip aber nicht, oder?

Natürlich widerspricht es dem Prinzip, du müsstest schliesslich den std::vector verändern!

Nein, ich wollte ja gerade eine eigene Vektor-Klasse machen, die von std::vector erbt, und da würde ich ja nicht den std::vector ändern

wxSkip schrieb:

Bei Icematix' Variante stürzt das Programm aber immer ab, wahrscheinlich, weil vec[0] eine Referenz zurückgibt.

Wahrscheinlich eher, weil du die besagten Sicherheitsabfragen nicht mehr hast und ausserhalb des gültigen Bereichs zugreifst.

Schreib dein Programm zuerst korrekt und optimiere dann. Für ersteres kannst du den normalen std::vector::operator[] verwenden.

Programm: (nur ein Testprogramm)

vector<int> vec;
    vec[0] = 12345;
    int *ip = &vec[0];
    printf("%d", *ip);

-> stürzt ab, obwohl ohne Kompilierfehler

Das Testprogramm ist falsch, weil der Vector keine elemente enthält. Du greifst auf das nullste Element zu, obwohl es nie erzeugt wurde. Ändere die zweite Zeile in einen push_back()-Aufruf. Genau aus diesem Grund raten wir dir hier zu Iteratoren.

Nein, ich wollte ja gerade eine eigene Vektor-Klasse machen, die von std::vector erbt

Davon rate ich dir ebenfalls ab. Nur weil du die Methoden nicht neu deklarieren willst, solltest du nicht von std::vector erben. Aggregation ist in dem Falle sinnvoller.

wxSkip schrieb:

und da würde ich ja nicht den std::vector ändern

Ja, aber wenn du in deiner eigenen Klasse ein friend nach aussen machst, kannst du immer noch nicht auf std::vector zugreifen.

Aber wie gesagt: Das ist alles gar nicht nötig.

wxSkip schrieb:

Programm: (nur ein Testprogramm)

vector<int> vec;
    vec[0] = 12345;
    int *ip = &vec[0];
    printf("%d", *ip);

-> stürzt ab, obwohl ohne Kompilierfehler

Eben, dein Code ist inkorrekt. Das ist das gleiche Problem wie hier:

int vec[2];
vec[2] = 12345;

P.S.: Versteh das nicht falsch, aber wenn du solche Problematik nicht erkennst, bezweifle ich mal, dass du auf die Schnelle ein besseres und dennoch allgemeingültiges std::sort() hinkriegst. Du bist wahrscheinlich besser beraten, wenn du vorgefertigte Lösungen anwenden würdest, da diese auch bugfrei sind. Es gibt nichts Schlimmeres als undefiniertes Verhalten, das man erst Minuten nach dem Auftreten erkennt.

Nein, ich wollte ja gerade eine eigene Vektor-Klasse machen, die von std::vector erbt

Wie kommt man denn auf die Idee, von std::vector zu erben? Wozu soll das gut sein? Was hilft Dir das denn, wenn Du etwas sortieren willst?

Wenn du dich in die Klassenhierarchie einklinkst, brichst du damit die Kapselung auf. Es mag vielleicht die eleganteste Methode sein, dies zu tun, ändert aber nichts am eigentlichen Problem.

Das Testprogramm ist falsch, weil der Vector keine elemente enthält. Du greifst auf das nullste Element zu, obwohl es nie erzeugt wurde. Ändere die zweite Zeile in einen push_back()-Aufruf. Genau aus diesem Grund raten wir dir hier zu Iteratoren.

Danke, wenn ich den Vektor mit 5 initialisiere, funktionierts!

wxSkip schrieb:

Nein, ich wollte ja gerade eine eigene Vektor-Klasse machen, die von std::vector erbt

Wie kommt man denn auf die Idee, von std::vector zu erben? Wozu soll das gut sein? Was hilft Dir das denn, wenn Du etwas sortieren willst?

Dann kann ich mir dort meine eigenen Funktionen machen oder friend-Funktionen deklarieren oder so...

Komisch... Mein Quicksort für Vektoren ist schneller als mein Quicksort für C-Arrays mit der Adresse des Arrays aufgerufen, obwohl beide genau denselben Algorithmus nutzen.

Koenntest du bitte mal Implementierung und Testprogramm posten, damit andere das auch nachvollziehen koennen?

template<class Type> inline void vquicksort2(myvector<Type> &in, register int size, register int pos = 0)
{
    register Type tmp;
    register int right = pos + size - 1;
    register int left = pos;
    register double av = (in.at(pos) + in.at(pos+size-1)) / 2.0;

    while(left < right)
    {
        if (in.at(left) > av)
        {
            if (av > in.at(right))
            {
                tmp = in.at(left);
                in.at(left) = in.at(right);
                in.at(right) = tmp;
                left++;
            }
            right--;
        }
        else
        {
            if (av <= in.at(right)) right--;
            left++;
        }
    }
    if(left == right && in.at(left) <= av) left++;

    if((right = left-pos) < 2)return;
    else vquicksort2(in, right, pos);
    if((right = size-left+pos) < 2) return;
    else vquicksort2(in, right, left - pos);
}

#include <algorithm>
#include <vector>
#include <iostream>
#include <ctime>

#define SIZE 20000000

using namespace std;

template <class Type> inline void vquicksort2(vector<Type> &in, register int size, register int pos = 0);

inline double getProgramTime()
{
    return clock() / (double)CLOCKS_PER_SEC;
}

int main()
{
    vector<double> v1(SIZE), v2(SIZE), v3(SIZE);
    for(int c = 0; c < SIZE; c++) v1[c] = rand();
    for(int c = 0; c < SIZE; c++) v2[c] = v1[c];
    printf("Start.\n");
    register double y = getProgramTime();
    sort(v1.begin(), v1.end());
    cout << "Sort-Zeit: " << getProgramTime() - y << "s\n";
    y = getProgramTime();
    vquicksort2(v2, v2.size());
    cout << "Vquicksort2-Zeit: " << getProgramTime() - y << "s\n";
}

template <class Type> inline void vquicksort2(vector<Type> &in, register int size, register int pos = 0)
{
    register Type tmp;
    register int right = pos + size - 1;
    register int left = pos;
    register double av = (in.at(pos) + in.at(pos+size-1)) / 2.0;

    while(left < right)
    {
        if (in.at(left) > av)
        {
            if (av > in.at(right))
            {
                tmp = in.at(left);
                in.at(left) = in.at(right);
                in.at(right) = tmp;
                left++;
            }
            right--;
        }
        else
        {
            if (av <= in.at(right)) right--;
            left++;
        }
    }
    if(left == right && in.at(left) <= av) left++;

    if((right = left-pos) < 2)return;
    else vquicksort2(in, right, pos);
    if((right = size-left+pos) < 2) return;
    else vquicksort2(in, right, left - pos);
}