Wir haben gestern in der Schule das erste mal über dynamische Arrays gesprochen. Dabei ging es um Heap und was weiß ich.

Nun hab ich ein Problem, ich arbeite mit Vector und weiß nun nicht was ich mit dem Heap anfangen soll? Von Anfang an hab ich Vector benutzt, da dies bereits dynamische Arrays sind, was muss ich nun verändern? Hier mal mein "Testcode" aus dem Unterricht:

#include <iostream>
using namespace std;
int main()
{
    int *array;
    int anzahl, help;
    cout<<"Wie viele Zahlen wollen sie eingeben? ";
    cin >> anzahl;
    array = new int[anzahl];
    for(int i=0;i<anzahl;i++)
    {
        cout<<"Bitte geben Sie eine Zahl ein: ";
        cin >> array[i];
    }
    for(int i=0;i<anzahl;i++)
    {
        for(int j=0;j<anzahl;j++)
        {
            if(array[i] > array[j])
            {
                help = array[i];
                array[i] = array[j];
                array[j] = help;
            }
        }
    }
    for(int i=0;i<anzahl;i++)
    {
        cout<<array[i]<<"\n";
    }
    return 0;
}

Wo muss ich da jetzt was weglassen und ein Vector Array benutzen? Mein Lehrer war bei "Vector" ein wenig überfragt .... <.<

LG
-Lima-

PS: Und die anschließende Doppelschleife soll wohl einen missglückten Sortierversuch darstellen?

Hier mein Code, aber ich glaub ich habe dich falsch verstanden^^:

#include <iostream>
using namespace std;
int main()
{
    int anzahl, help;
    cout<<"Wie viele Zahlen wollen sie eingeben? ";
    cin >> anzahl;
    vector<int> Array(anzahl);
    for(size_t i=0;i<Array.size();i++)
    {
        cout<<"Bitte geben Sie eine Zahl ein: ";
        cin >> Array.at(i);
    }
    for(size_t i=0;i<Array.size();i++)
    {
        for(size_t j=0;j<Array.size();j++)
        {
            if(Array.at(i) > Array.at(j))
            {
                help = Array.at(i);
                Array.at(i) = Array.at(j);
                Array.at(j) = help;
            }
        }
    }
    for(size_t i=0;i<Array.size();i++)
    {
        cout<<Array.at(i)<<"\n";
    }
    return 0;
}

Das ganze mag nämlich nicht funktionieren, aber was ist falsch? Zeile acht Weise ich dem Array doch den Wert von "anzahl" zu, sollte an sich doch funktionieren?

LG

EDIT: hatte #include <vector> vergessen, nun klappts!

Warum? Das Sortieren funktioniert doch! o.o

Bist du dir da sicher? Das Ding hat zwar Ähnlichkeiten mit BubbleSot, aber wenn du ohne Rücksicht auf die aktuelle Reihenfolge Werte austauschst, ist das wenig zielführend.

Hier mein Code, aber ich glaub ich habe dich falsch verstanden^^:

abgesehen von einem fehlenden #include <vector> sieht das eigentlich gut aus.

Weil mal im Ernst, hätte ich das auch nicht mit nem normalen Array realisieren können?

Und wie ist das jetzt wenn ich den Kram in Funktionen schreibe, muss ich dann wieder mit Zeigern arbeiten? Ich versuche stehts mich von Zeigern fern zu halten, denn sobald die auftauchen verstehe ich nichts mehr.

LG

ps: Ja das funktioniert 1A, gibt keine Probleme oder ähnliches bei der Ausgabe!

Und das ganze ist jetzt ein dynamisches Array?

Ja, ich würde es zumindest so nennen - und im Gegensatz zu Bastelarbeiten mit Zeigern und new kümmert der sich um alle Feinheiten der Speicherverwaltung.

PS: Und du bist dir sicher, daß du fallend sortieren willst? Ansonsten würde ich dir empfehlen, einen Blick auf std::sort() zu werfen.

Ansonsten würde ich dir empfehlen, einen Blick auf std::sort() zu werfen.

Bzw. std::stable_sort() wenn's stabil sein soll.

Kannst du mir das mit dem std::sort() mal näher beschreiben? Ich würd echt Klasse finden wenn es da unter vector auch etwas zum sortieren gibt, dann muss ich ja irgendwann echt nie mehr zu normalen Arrays zurück!!

#include <iostream>
#include <vector>
#include <stdlib.h>

using namespace std;
int main()
{
    vector<int> foo(5);
    for (size_t i=0;i<foo.size();i++)
    {
        cin >> foo.at(i);
    }
    std::sort(foo.begin(), foo.end());
    for (size_t i=0;i<foo.size();i++)
{
    cout << foo.at(i);
}
system("pause");
return 0;
}

Oder mach ich es mir nun zu einfach? Er sagt mir das sort kein Teil von "std" ist.

LG

Ich bedanke mich herzlichst bei euch, ihr habt mir super geholfen!!!

Nun kann ich mir endlich dieses blöde bubblesort sparen, vielen vielen Dank!!!

int *irgendeinarray = new int[irgendwas];

wollte und nichtmal weiss was std:: überhaupt bedeuten soll

Er schrieb ja schon im Eingangspost, dass sein Lehrer bei der Frage nach "Vector" überfragt war.

...
Er schrieb ja schon im Eingangspost, dass sein Lehrer bei der Frage nach "Vector" überfragt war.

Besser so als andersherum. Vielleicht gehört der Lehrer ja zu der Sorte, der merkt, dass da irgendwas passiert ist, seit er das letzte Mal in ein C++ Buch geguckt hat. Und vielleicht gehört er sogar zu der ganz seltenen Sorte, die sich dann hinsetzen und sich das auch mal angucken.

On topic:
Der Code ist zwar standesgemäßer C++ Code und löst die Aufgabe, aber das ist vielleicht gar nicht die Zielsetzung der Aufgabe. Wenn es um Verständnis und Realisierung dynamischer Speicherverwaltung geht, dann geht die Lösung komplett an der Aufgabe vorbei, weil vector ja alles kapselt und für den TE erledigt. Wie der TE ja schon zugegeben hat, hat er Probleme beim Verständnis von Zeigern, könnte also keine Fragen zur Funktionsweise beantworten, weil vector eine Black Box für ihn ist.

@TE
Du solltest trotzdem versuchen, eine Lösung ohne std::vector hinzubekommen, damit du verstehst, wie dynamische Speicherverwaltung prinzipiell funktioniert. Wenn du dann noch die Vorzüge des vectors gegenüber der C-Fassung erklären kannst wäre das natürlich das Sahnehäubchen.

Ich habe noch zwei Kritikpunkte:

1. Der korrekte C++ Header ist cstdlib, nich stdlib.h
2. system() ist eine plattformabhängige Funktion (würde mich persönlich aber nicht stören, wenn ich sowas lese)

2. system() ist eine plattformabhängige Funktion (würde mich persönlich aber nicht stören, wenn ich sowas lese)

[klugscheiß]"system" ist plattformunabhängig, "pause" ist es nicht. [/klugscheiß]

Leider hatte ich bei der Vorstellung des programms das problem das ich nicht wusste wie man die Ausgabe nun so sortiert, das es mit der Größten anfängt und mit der kleinsten aufhört o.o

Geht das überhaupt? Nur in eine Richtung sortieren wäre nämlich kacke!

Naja abgesehen davon kam mein Programm recht gut an, außer das der Kligscheißer der Klasse von mir genaustens erklärt haben wollte wie die vector Bibliothek aufgebaut ist und wie das sortieren da eig. funktioniert, denn ich kann da ja nicht einfach benutzen ohne zu wissen wie es funktioniert.

Naja ich hab ihn dann gefragt (Alle vor der Klasse natürlich) wie iostream eig. funktioniert, benutzt er ja auch in jedem Programm. Danach hat er komischerweise die Klappe gehalten :3

Huhu!

Leider hatte ich bei der Vorstellung des programms das problem das ich nicht wusste wie man die Ausgabe nun so sortiert, das es mit der Größten anfängt und mit der kleinsten aufhört o.o

Geht das überhaupt? Nur in eine Richtung sortieren wäre nämlich kacke!

Natürlich geht das. Sortieralgorithmen nehmen noch einen weiteren Parameter an, bei dem man das Vergleichskriterium festlegen kann. Das kann auch std::greater sein.

Naja ich hab ihn dann gefragt (Alle vor der Klasse natürlich) wie iostream eig. funktioniert, benutzt er ja auch in jedem Programm. Danach hat er komischerweise die Klappe gehalten :3

Dabei wäre das gut zu wissen. Viele Anfänger wissen nicht, wie mächtig die Streams sind und was man für tolle Sachen damit machen kann. Man schaue sich die Beiträge von Werner Salomon dazu an, die mich immer wieder begeistern.

Natürlich geht das. Sortieralgorithmen nehmen noch einen weiteren Parameter an, bei dem man das Vergleichskriterium festlegen kann. Das kann auch std::greater sein.

kann man nicht auch einfach ein paar von reverse-iteratoren nehmen? das wäre jetzt mein spontaner Ansatz (okay, eine Ecke denken mehr wäre das schon als std::greater...)

Aber noch eine Sache:
ich begrüße zwar, dass du vector.at(i) verwendest, aber meistens reicht dann doch der Klammerzugriff wie bei den arrays: vector[i]. dann siehts nicht ganz so unbeholfen aus

SeppJ schrieb:

Natürlich geht das. Sortieralgorithmen nehmen noch einen weiteren Parameter an, bei dem man das Vergleichskriterium festlegen kann. Das kann auch std::greater sein.

kann man nicht auch einfach ein paar von reverse-iteratoren nehmen? das wäre jetzt mein spontaner Ansatz (okay, eine Ecke denken mehr wäre das schon als std::greater...)

Stimmt. Kommt halt drauf an, was man will. Man sollte generell so sortieren, wie man am häufigsten Durchiterieren will. Abundan mal rückwärts gehen, da sind die reverse_iteratoren gut. Ich könnte mir aber vorstellen, dass die nicht besonders performant sind, so von wegen Prefetching und so. Jedoch wird das bei der hier gezeigten Applikation wohl kaum in's Gewicht fallen.

Naja abgesehen davon kam mein Programm recht gut an, außer das der Kligscheißer der Klasse von mir genaustens erklärt haben wollte wie die vector Bibliothek aufgebaut ist und wie das sortieren da eig. funktioniert, denn ich kann da ja nicht einfach benutzen ohne zu wissen wie es funktioniert.

Du kannst ihm gerne die Header <vector> und <algorithm> vor die Nase knallen, damit er es selber herausfindet