Ich habe versucht ein Programm zu schreiben, welches eine gewünschte Anzahl von Wörtern einliest und anschliessend alphabetisch sortiert (mit bubblesort) wieder ausgibt. Das kompilieren läuft fehlerfrei durch, es tritt jedoch dann ein Laufzeitfehler auf..
Hier der Code:

#include <string>
#include <iostream>
using namespace std;

int main()
{
    int number;

    cout << "Anz. Woerter: ";
    cin >> number;

    string* words = new string[number];

    int k = 1;
    while(k<=number)
    {
        cout << "Wort " << k << ": ";
        cin >> words[k-1];
        k++;
    }

    for(int i = number; i>0; i--) //bubblesort
    {
        for(int j=0; j<i; j++)
        {
            if(words[j][0] > words[j+1][0])  //Erste buchstaben vergleichen
            {
                string tmp = words[j+1];
                words[j+1] = words[j];
                words[j] = tmp;

            }
        }
    }

    for(int i=0; i<number; i++)
    {
        cout << words[i] << endl;
    }

    return 0;
}

Wäre cool, wenn sich das jemand kurz anschauen könnte.

Der Fehler liegt in deinem Bubblesort. Du setzt i = number, dann lässt zu j bis number - 1 laufen, addierst dann aber nochmal 1 drauf.
Problem ist aber, dass dein größter Index für words "number - 1" ist.

for(int i = number - 1; i>0; i--) //bubblesort

löst das Problem

Ah wie blöd von mir Danke dir vielmals.

Noch ein paar Denkanstöße für dich:

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>

int main()
{
	unsigned number; // Eine Anzahl ist natürlich immer nicht-negativ.
    std::cout << "Anz. Woerter: ";
    std::cin >> number;

	std::vector<std::string> words; // Steht die Größe eines Arrays erst zur Laufzeit fest, nimmst du std::vector (dyn. Array).

	for(unsigned i=0; i!=number; ++i) // Hier nimmst du eine for Schleife... du weißt ja im Voraus, wie oft sie durchläuft...
	{
		std::string str;
		std::cout << "Wort " << i+1 << ": ";
        std::cin >> str;
		words.push_back(str);
	}

	std::sort( words.begin(), words.end() ); // Ok du willst Bubblesort machen :). Zur Übung ok, aber vergiss nicht. Man erfindet das Rad nicht immer neu.

	for(std::vector<std::string>::iterator it=words.begin(); it!=words.end(); ++it)
		std::cout << *it << '\n';
}

Wenn du ein set statt vector benutzt kannst du dir sogar noch das Sortieren komplett sparen.

Nicht nur ist es langsamer, es löscht auch doppelte Einträge. Wenn das Programm das gleiche machen soll, müsstest du multiset vorschlagen (ist halt immer noch Overkill und langsamer).

Wie das mit unordered_multiset aussieht, weiss ich nicht, das müsste man ev. testen.

Warum ist hier ein vector dem dynamischen array vorzuziehen?
Habe gehört, dass die Arbeit mit Vektoren weniger "fehleranfällig" sei.
Inwiefiern stimmt das?

Warum ist hier ein vector dem dynamischen array vorzuziehen?
Habe gehört, dass die Arbeit mit Vektoren weniger "fehleranfällig" sei.
Inwiefiern stimmt das?

Nein das hast du falsch verstanden. Ein std::vector IST ein dynamisches Array. D.h. wenn du ein dynamisches Array benötigst, nimmst du std::vector. Oh ja, es ist um einiges weniger fehleranfälliger und hat noch andere Vorteile, z.B. kannst du einfach die Größe abfagen.

- du hast range-checks in debug-builds. D.h. vector[88] gibt ein Fehler zur Laufzeit, wenn der Index zu groß ist.

- du die Größe mit size abfragen kannst.

- du kein array-to-pointer-decay mehr hast. D.h. wenn du dein Array an eine Funktion übergibst, zefällt dieses in einen Zeiger auf das erste Element. Bei einem std::vector hast du das Problem nicht.

- du Kopiersemantik hast. Einen std::vector kannst du kopieren, ein Array nicht.

Das Problem ist aber, dass scheinbar die backslash-characters auch irgendwie eingelesen werden, sprich lese ich eine liste mit 8 Zahlen ein gibt mir das Programm nur 4 Zahlen aus. (die backslashs werden aber wies aussieht nicht ausgegeben) Wie kann ich das Problem umgehen?

Hier der Code:

#include <iostream>
#include <fstream>
#include <vector>
#include <stdlib.h>
#include <string>
using namespace std;

void sortE(vector<int>& arr, int length);

int main()
{
    unsigned int lines = 0;
    ifstream fin;
    fin.open("data.txt");

while(!fin.eof())  //Anzahl Zeilen/bzw.Zahlen zählen
{
    string str;
    getline(fin,str);
    lines++;
}

fin.seekg(0,ios::beg); //Get-Pointer zurücksetzen

vector<int> liste;

    for(unsigned int i = 0; i!=lines; i++) //einlesen?????
    {
        int tmp;
        fin >> tmp;
        liste.push_back(tmp);
        i++;
    }

    sortE(liste, lines);

    for(vector<int>::iterator it = liste.begin(); it!=liste.end(); it++) //Ausgabe
    {
        cout << *it << endl;
    }

    return 0;
}

void sortE(vector<int>& arr, int length)
{
    for(int k=1; k<length; k++)
    {
        for(int j=k; j>0; j--)
        {
            if(arr[j] < arr[j-1])
            {
                int temp = arr[j-1];
                arr[j-1] = arr[j];
                arr[j] = temp;

            }
        }
    }
}

Das Einlesen (z27) hatte ich zuerst wie folgt implementiert:

for(unsigned int i = 0; i!=lines; i++) //einlesen?????
    {
        fin >> liste[i];
        i++;
    }

Das verursachte aber einen Laufzeitfehler, also habe ich es dann mit push_back() gelöst... Warum geht das so nicht?

push_back [...] (ist aber ineffizienter)

Sagt wer?

Das beste ist immer noch reserve+push_back.

Natürlich ist reserve() und push_back() das bester, aber nur push_back() ist ineffizienter als resize() und operator [].

Ah, interessant.

Hast du dazu auch eine Begründung?

Nathan schrieb:

Natürlich ist reserve() und push_back() das bester, aber nur push_back() ist ineffizienter als resize() und operator [].

Ah, interessant.

Hast du dazu auch eine Begründung?

Also wenn ich das richtig verstanden habe wird bei push_back() ja immer automatisch der vector vergörssert, bzw. es wird eine "resize-Funktion ausgeführt.
Klingt für mich plausibel, dass es weniger aufwendig ist, wenn man ganz am Anfang nur einmal resize aufruft und die benötigte Grösse definiert. Oder?

Wie dem auch sei, der Tipp mit dem Resize funktioniert, und auf diese Weise werden,wie es aussieht, auch die backslash-characters ignoriert...

liste.resize(8);
for(unsigned int i = 0; i!=lines; i++) //einlesen?????
{
    fin >> liste[i];
}

Damit werden alle acht Zahlen am schluss ausgegeben. (und nicht nur 4 wie bei push_back)
Bleibt also nur noch die Frage, wie ich die backslashs mit der push_back()-Methode ignorieren kann.

Sage ich.
Natürlich ist reserve() und push_back() das bester[sic!], aber nur push_back() ist ineffizienter als resize() und operator [].

Hier eine Klasse zum testen:

struct X {
  X(){sleep(1);}
};

Edit: Ja, ok, bei deiner Klasse ist das vielleicht so, aber wir reden hier von Zahlen nicht von Objekten die komplexe Initialisierungsvorgänge benötigen.
Du musst meine Beiträge auch in einem gewissen Kontext sehen. Und in seiner Situation (von der ich eigentlich auch geredet habe) ist das so.

Edit 2 @TE: Warum hast du den Backslashs in deinem File?

Also wenn ich das richtig verstanden habe wird bei push_back() ja immer automatisch der vector vergörssert, bzw. es wird eine "resize-Funktion ausgeführt.
Klingt für mich plausibel, dass es weniger aufwendig ist, wenn man ganz am Anfang nur einmal resize aufruft und die benötigte Grösse definiert. Oder?

Der vector ist schlau und vergrössert sich nicht nur um 1 Element sondern vervielfacht seine Grösse.

Das führt dazu, dass jeder Aufruf von push_back durchschnittlich in konstanter Zeit abläuft, d.h. normalerweise braucht man sich da nicht drum zu kümmern. Mit reserve() wird das ganze noch etwas schneller.

Nathan schrieb:

Du musst meine Beiträge auch in einem gewissen Kontext sehen. Und in seiner Situation (von der ich eigentlich auch geredet habe) ist das so.

Nicht ganz. resize() vergrössert den Vektor und setzt erst einmal alle Elemente auf 0. Dann werden die noch einmal eingelesen und richtig initialisiert. mit push_back() werden die gleich auf den echten Wert gesetzt, dafür muss die Grösse verändert werden.

Ist insgesamt ein Nullsummenspiel (gerade bei ints) und push_back ist um einiges sauberer.

Und seit wann werden die Werte bei ints ohne weiteres Argument auf 0 gesetzt?

Seit es vector gibt Ist übrigens ein weiterer Vorteil von vector gegenüber einem rohen Array.

Ohne reserve() ist resize() in diesem Fall möglicherweise wirklich schneller, aber trotzdem sollte man resize() nicht empfehlen, wenn es doch auch reserve() gibt.

Ohne reserve() ist resize() in diesem Fall möglicherweise wirklich schneller

Davon rede ich ja die ganze Zeit.

Ohne reserve() ist resize() in diesem Fall möglicherweise wirklich schneller

Davon rede ich ja die ganze Zeit.

Ja, aber wayne?
Wenn man kurzen und schönen Code will, nimmt man push_back und wenn man schönen und schnellen Code will nimmt man reserve+push_back. resize hat da gar nichts zu suchen.

OK, du hast Recht: TE, verwende reserve() und push_back(), sofern dein Backslash-Problem gelöst ist.
Zufrieden?
Und was hat Sone damit zu tun?

Glaube du hast mich falsch verstanden
Genau dann wenn ich push_back() verwende, gibt mir die Funktion am schluss nur die Hälfte der Liste sortiert aus. Reserve() und Resize() ändern daran irgendwie nichts. Wie gesagt, meine vermutung ist, dass es ein Zusammenhang mit '\n' hat, mir ist jedoch nicht klar, wie ich das Problem umgehen kann.

is.seekg (0, ios::end);
length = is.tellg();
is.seekg (0, ios::beg);

Mit seekg bestimmst du die Leseposition im File, abhängig von der Position, die im zweiten Parameter angegeben wird.