Sortieren von Zeichen

Konrad Rudolph

Hallo junger Padawan,

ich mach's mir mal einfach und verzichte auf die ganzen Code-Tags beim Durchgehen des Codes:

char* sortstring(string const& quelle)

Du übergibst den String direkt. Dadurch wird eine Kopie des Strings erzeugt. 'string const&' ist letztendlich dasselbe, nur dass keine Kopie des Strings erzeugt werden muss, weil auf das Original verwiesen wird.

Wenn ihr noch keine Referenzen kennt, lass das einfach weg.

size_t chr = static_cast<size_t>(*i); // hier verstehe ich nicht wieso du es in den size_t typ casten tust

'*i' ist ein Zeichen des Strings. Dieses Zeichen wollen wir als Index für das Array verwenden. Ich sträube mich dagegen, einen char als Ganzzahl zu betrachten (auch wenn das in C++ nunmal so ist), daher caste ich das ganze explizit in einen Ganzzahltypen.

*c++ = static_cast<char>(i); wird i gecastet wieso aber auf den *c und nicht direkt auf *ziel und aus welchem grund wird hier inrekemtiert??

Was hier passiert, ist folgendes:

Wir haben unseren Speicher reserviert und 'ziel' verweist darauf. Jetzt müssen wir diesen Speicher Zeichen für Zeichen durchgehen und an der jeweiligen Stelle das nächste Zeichen abspeichern. Das zeichenweise Durchgehen machen wir uns einfacher (gut, Ansichtssache), indem wir zuerst einen Zeiger auf den Beginn zeigen lassen ('c'), und diesen Zeiger dann immer erhöhen, dass er auf das nächste Element zeigt. Direkt vor der Erhöhung des Zeigers schreiben wir an die aktuelle Speicheradresse aber noch das aktuelle Zeichen. Das geschieht durch das '*c++ = zeichen'. Man könnte das auch ausführlich schreiben, nämlich so:

*c = zeichen;
++c; // Speicherindex erhöhen.

In jedem Fall ist das aktuelle Zeichen gegeben durch 'static_cast<char>(i)'.

*D*Evil

Mal ne Frage ... dürft ihr alle Funktionen des Standards nutzen?

#include <algorithm>
#include <string>

std::string sortstring(std::string string)
{
    std::string* copy(new std::string(string));
    std::sort(copy->begin(), copy->end());
    std::unique(copy->begin(), copy->end());
    return copy;
}

Ist zwar etwas unperformant aber einfach

int main()
{    
    std::cout << "Bitte Quelltext: ";
    std::string input;
    std::getline(std::cin, input);
    std::string* ptr_sort(sortstring(input));
    std::cout << "Sortierte Ausgabe: " << *ptr_sort << std::endl;
    delete ptr_sort;
}

... naja den Prof kannst du übrigens direkt in die Tonne kloppen ...

Konrad Rudolph

(D)Evil schrieb:

naja den Prof kannst du übrigens direkt in die Tonne kloppen ...

Warum immer so negativ? Solchte Problemstellungen sind an sich doch ganz gut geeignet, um algorithmisches Denken beizubringen. Gut, dass C++ hierfür nicht unbedingt geeignet ist, ist eine andere Sache. Aber nicht jeder will mit einer funktionalen Sprache anfangen.

queer_boy

(D)Evil schrieb:

Mal ne Frage ... dürft ihr alle Funktionen des Standards nutzen?
#include <algorithm>
#include <string>

std::string sortstring(std::string string)
{
    std::string* copy(new std::string(string));
    std::sort(copy->begin(), copy->end());
    std::unique(copy->begin(), copy->end());
    return copy;
}
Ist zwar etwas unperformant aber einfach

huch?
den code hast du anscheinend nicht ausgiebig getestet

std::string * sorstring (...)
//...
copy.erase (std::unique(copy.begin(), copy.end()), copy.end());

oder

std::string* sortstring(std::string string)
{
    std::sort(string->begin(), string->end());
    std::string *copy = new string;
    std::unique(copy->begin(), copy->end(), back_inserter(*copy));
    return copy;
}

ist auch nicht performant, aber funktioniert immerhin

*D*Evil

Ja auch gut Ich teste die Codes leider nie wenn ich was ins Forum schreibe ... geht auch so gut wie immer gut Nur diesesmal scheinbar nicht.

(D)Evil schrieb:

Mal ne Frage ... dürft ihr alle Funktionen des Standards nutzen?

Ich denke nicht, static_cast kennt er nichtmal (darauf wurde er letztens von jemanden angesprochen, und musste zugeben das nicht zu kennen, genauso wie er <algorithm> nicht kennt)
also ich denke in Klausuren ist es besser auf das zu setzen was er kennt sonst gibt das vllt. Probleme.

(D)Evil schrieb:

... naja den Prof kannst du übrigens direkt in die Tonne kloppen ...

oh wie Recht du hast (kannst du Gedanken lesen?)

danke für eure Hilfe

CStoll

junger_padawan schrieb:

(D)Evil schrieb:

... naja den Prof kannst du übrigens direkt in die Tonne kloppen ...

oh wie Recht du hast (kannst du Gedanken lesen?)

Glaube ich weniger - aber schon die Aufgabenstellung "mit Hilfe von new..." deutet darauf hin, daß er wenig Ahnung hat von C++.

Randfrage: Welche Teile von C++ kennt der Professor überhaupt? string scheint dabei zu sein, wie sieht es mit anderen STL-Containern aus?

string sortstring(const string& input)
{
  set<char> sorted(input.begin(),input.end());
  return string(sorted.begin(),sorted.end());//ich benutze bewußt KEIN new
}

die aufgabe ist nicht grad die hohe kunst der programmierung. das scheint aus nem grundlagen kurs für studienanfänger zu stammen. da muss man davon ausgehen, dass einige hörer das erste mal in ihrem leben etwas mit programmiersprachen zu tun haben. entsprechend simpel sind die aufgaben formuliert und dementsprechend "naiv" sind die lösungsvorgaben.

in der aufgabe geht es darum, sich gedanken zu machen, was ein string ist, wie man an die einzelnen bestandteile herankommt und wie grundlegend daten sortiert werden können. der prof hat hier einen sehr einfach ansatz vorgegeben, sich lediglich auf 8 bit zeichen zu beschränken und lenkt in die richtung, bucketsort zu verwenden.

würd mich einfach daran orientieren und lieber hinweise in den code schreiben, was an dieser lösung ungünstig ist, anstatt einfach einen "besseren" code abzuliefern. maximal als alternative.

asc

junger_padawan schrieb:

(D)Evil schrieb:

Mal ne Frage ... dürft ihr alle Funktionen des Standards nutzen?

Ich denke nicht, static_cast kennt er nichtmal (darauf wurde er letztens von jemanden angesprochen, und musste zugeben das nicht zu kennen, genauso wie er <algorithm> nicht kennt)
also ich denke in Klausuren ist es besser auf das zu setzen was er kennt sonst gibt das vllt. Probleme...

Das Problem mit Dozenten sowie Lehrern ist zumeist das sie einmal gelernt haben und damit meinen es zu beherrschen (ich kenne Ausnahmefälle, aber die Aussage trifft auf den Großteil derer zu die ich bisher im Informatikbereich kennen gelernt habe). Nun ist es so das einige vor dem Verabschieden des C++98 Standes C++ gelernt haben, und nach dem (alten) Stand lehren.

Dabei gibt es ganz gravierende Unterschiede im Pre-Standard zum Standard, die sich auch auf Fehlerhandling beziehen. Heutzutage ist zum Beispiel aktiviertes Exceptionhandling und RTTI der Standard, mit entsprechenden Auswirkungen. Gravierendes Beispiel:

int main()
{
    // Behandlung von fehlgeschlagenen new in Pre-Standard:
    int* a = new int;
    if(!a)
        ; // <-- Hier Fehlerbehandlung

    // Nach dem Standard wird sich aber hier das Programm verabschieden,
    // wenn nicht zufälligerweise irgendwo eine exception gefangen wird...
    try
    {
        int* a = new int;
        ; // <-- Hier kommt er nur hin, wenn new erfolgreich war
    }
    catch(std::bad_alloc& exp)
    {
        // Fehlerbehandlung
    }
}

Jeder Dozent/Lehrer sollte sich zumindestens alle 2-3 Jahre mal über Änderungen informieren, sofern er in einem sehr schnelllebigen Bereich (wie Informatik) arbeitet.

cu André

Artchi

Yo, sieht man ja daran, das hin und wieder jemand mit .h-Standard-Headern ankommt. Seit 10 Jahren obsolet. Man muß sich mal 10 Jahre vorstellen, im PC-Bereich.