es wäre schön wenn Ihr Feedback zu meiner Funktion geben könntet.
Was kann ich besser machen, was würdet ihr anders machen?

Ich habe zuerst versucht const_reverse iteratoren zu benutzen und den Filenamen damit abzuschneiden allerdings habe ich es nicht hingekriegt.
Das das schneller ist als mit der herkömlichen Methode.

Ich brauche wenn ich reverse iteratoren benutzen will eine zusätzliche For-Schleife um den Namen wieder zurückumzuwandeln und ich schubse die Buchstaben dann manuell rein.

Vielleicht hat ja noch jemand eine Idee wie das abschneiden des Filenamens mit reverse iteratoren richtig zu implementieren ist.
Ich stell mich da ein wenig zu doof an.

Der reverse Iterator Ansatz:

char Mgr::filename_parse_result(const std::string & filepath) {

    string::const_reverse_iterator cr_it;

    string work_reverse_string;
    work_reverse_string.reserve(15);

    string work_string;
    work_string.reserve(15);  

    for (cr_it = filepath.crbegin(); cr_it != filepath.crend(); ++cr_it) {
        if (*cr_it == '\\') 
            break;

        work_reverse_string += *cr_it;
    }
    for (cr_it = work_reverse_string.crbegin(); cr_it != work_reverse_string.crend(); ++cr_it) {
        work_string += *cr_it;
    }

    if (work_string.find("resolve") != string::npos)
        return 'B';
    else {
        for (string::const_iterator it = work_string.cbegin(); it != work_string.cend(); ++it) {
            if (*it >= '0' && *it <= '9')
                return 'B';
            else return 'A';
        }
    }
}

Hier erst mal das Problem:

Ich möchte 40 Filename parsen.(40 Filenames)
Problem:
4 Arten von Filenames und ich muss sie entweder in den einen oder anderen Korb werfen.

1. Korb1:
Syntax Fileart 1: "foo_bar_foo.txt"
Syntax Fileart 2: "foo_foo_bar.html"

2. Korb2:
Syntax Fileart 3: "1033.txt"
Syntax Fileart 4: "bar_foo_bar.html.resolve"

Die Funktion bekommt einen relativen Pfad e.g. ".\foo\foo_bar_foo.txt"

char Mgr::filename_parse_result_loesung_3(const std::string & filepath) {

    string::const_iterator c_it;
    string::const_iterator it_begin;

    string work_string;
    work_string.reserve(15);  

    for (c_it = filepath.cbegin(); c_it != filepath.cend(); ++c_it) {
        if (*c_it == '\\')
            it_begin = c_it+1;
    }

    work_string.assign(it_begin, filepath.end());

    if (work_string.find("resolve") != string::npos)
        return 'B';
    else {
        for (string::const_iterator it = work_string.cbegin(); it != work_string.cend(); ++it) {
            if (*it >= '0' && *it <= '9')
                return 'B';
            else return 'A';
        }
    }
}

Ich hatte auch noch eine dritte Lösung die mir vom Lesen her ein wenig besser gefällt, allerdings ein wenig langsamer ist.

char Mgr::filename_parse_result_loesung_2(const std::string & filepath) {

    string filename;
    filename.reserve(15);

    size_t begin = filepath.find_last_of("\\")+1;

    filename = std::move(filepath.substr(begin, filepath.length() - begin));

    if (filename.find("resolve") != string::npos)
        return 'B';
    else {
        for (string::const_iterator it = filename.cbegin(); it != filename.cend(); ++it) {
            if (*it >= '0' && *it <= '9')
                return 'B';
            else return 'A';

        }
    }
}

Vielen Dank schon mal für Feedback.

Gruß
Christian

Da passt [c]erase[/c] viel eher. (Willst du damit gleichzeitig noch ein [c]shrink_to_fit[/c] erzwingen? Wozu?)

for (cr_it = work_reverse_string.crbegin(); cr_it != work_reverse_string.crend(); ++cr_it) {
        work_string += *cr_it;
    }

append .

4 Arten von Filenames und ich muss sie entweder in den einen oder anderen Korb werfen.

Und wie genau sind die definiert? .hmtl und .txt - oder html.resolve und nur Zahlen im Dateinamen?

filename = std::move(filepath.substr(begin, filepath.length() - begin));

Da passt erase viel eher. (Willst du damit gleichzeitig noch ein shrink_to_fit erzwingen? Wozu?)

Das versteh ich nicht so ganz.
Du meinst, dass ich den Filepfad von den anderen Zeichen säubere?
Das würde nicht funktionieren da der FIlepath nicht verändert werden darf, da ich damit später noch die Datei öffne, deswegen ist der const.
Ich müsste ansonsten den Filepath per Value übergeben.

Ich dachte mir eine move Operation eines kleinen strings ist besser als eine Call by Value Übergabe eines langen Strings.

Arcoth schrieb:

for (cr_it = work_reverse_string.crbegin(); cr_it != work_reverse_string.crend(); ++cr_it) {
        work_string += *cr_it;
    }

append .

Ich dachte += operator und append seien das selbe oder wie meinst du das?

Arcoth schrieb:

Und wie genau sind die definiert? .hmtl und .txt - oder html.resolve und nur Zahlen im Dateinamen?

Das ist die Definition:

Fileart 1: hat zusammenhängenden alphabetischen Text mit .txt Endung:
Syntax Fileart 1: "foo_bar_foo.txt"

Fileart 2: hat zusammenhängenden alphabetischen Text mit .html Endung:
Syntax Fileart 2: "foo_foo_bar.html"

Fileart 3: hat zusammängenden numerischen Text mit *.txt Endung
Syntax Fileart 3: "1033.txt"

Fileart 4 hat: zusammenhängenden alpabetischen Text mit .html.resolve Endung
Syntax Fileart 4: "bar_foo_bar.html.resolve"

Zum += und append (klick mal den Link an, dann siehst du die Unterschiede):

work_string.append( work_reverse_string.crbegin(), work_reverse_string.crend() );

sollte es tun.

Zum += und append (klick mal den Link an, dann siehst du die Unterschiede):

work_string.append( work_reverse_string.crbegin(), work_reverse_string.crend() );

sollte es tun.

EDIT: Visual Studio scheint bei der Messung Probleme zu machen.
Ich bekomm ganz andere Ergebnisse, wenn ich die release exe gleich aus dem Verzeichnis starte: Funktionsaufruf 10.000.000

Das sind die Ergebnise mit Release Exe aus Folder ohne VS Beteiligung

reverse (+=) = 7053ms - 7120ms
reverse (Append) = 6931ms - 7072ms

find_last_of = 3205ms - 3236ms
Iterator = 3102ms - 3126ms

Die Zeile sieht mit Append auf jedenfall schöner aus, danke.
Allerdings egal wie man es dreht und wendet mit dem von links nach rechts wandern bin ich schneller als von rechts nach links wandern.

Gibt es einen weg reverse Iteratoren zu benutzen ohne die Buchstaben dann wieder von rechts nach links zu drehen? Oder sind für diesen Anwendungsfall reverse Iteratoren nicht geeignet?

EDIT: Visual Studio scheint bei der Messung Probleme zu machen.
Ich bekomm ganz andere Ergebnisse, wenn ich die release exe gleich aus dem Verzeichnis starte: Funktionsaufruf 10.000.000

Ja, das ist so.
Macht bei bestimmten Sachen sogar nen Unterschied ob man ein Programm mit "Start without Debugging" aus VS startet, oder es direkt über den Explorer/TaskManager/cmd.exe/... startet.