3. Von std::string erben

Von std::string erben

  • S

    @_ro_ro Generell ist mein Eindruck, das man versucht man in C++ Laufzeitpolymorphie zu vermeiden.
    Tatsächlich benötigt man es selten, denn meistens ist vorher bekannt, welche Funktion tatsächlich ausgeführt werden soll. Und dafür möchte man den Performanceverlust durch die Indirektion über den v-table vermeiden.

    In C++ gibt es verschiedene Möglichkeiten für "Compile Time Polymorphism", umgesetzt z.B. über Templates. Da wird direkt zu Compiletime entschieden, welche Funktion aufgerufen werden soll. Ein Stichwort zur Suche ist z.B. CRTP.

    Wenn ich mir überlege, dass ich zum Beispiel einen Split auf einem string brauche, hat deine Implementierung z.B: schon das Problem, dass sie nur auf std::string also std::base_string<char> funktioniert und nicht auf std::wstring und anderen Varianten (https://en.cppreference.com/w/cpp/string/basic_string).

    Vielleicht wäre es sogar möglich einen Algorithmus zu schreiben, der so eine Art Split auf ganz unterschiedlichen Containern durchführen kann? Warum z.B. soll man einen Vektor nicht an einer bestimmten Stelle splitten können?

    Mit C++20 (auch schon 4 Jahre alt) haben wir zum Beispiel std::ranges::views::split (https://en.cppreference.com/w/cpp/ranges/split_view) was das lösen soll und mit C++ 23 ist es sogar für Strings sinnvoll nutzbar 😉

    #include <ranges>
#include <iostream>
#include <algorithm>
#include <string_view>

int main()
{
 std::string a = "hallo welt";

  for (const auto word : std::views::split(a, std::string(" ")))
        std::cout << std::string_view(word) << "\n";

  return 0;
}

    geklaut und angepasst von hier (https://en.cppreference.com/w/cpp/ranges/split_view)

    Zum spielen mit dem Code, siehe: https://godbolt.org/z/n5MsY5e7W

    0
    _
    T
     2 Antworten
  • _

    @Schlangenmensch

    ungemein wichtiger ist es, daß alle diese Stringfunktionen zwischen bytesemantics und charactersemantics unterscheiden müssen: Wegen UTF-8. Also daß bspw. ein length("ä") bytesemantisch 2 ergibt, zeichenorientiert hingegen 1 sofern dieses 'ä' utf-8-kodiert ist. Denn sonst führt ein substr() u.U. dazu, daß die Einzelbytes von Zeichen ungewollt voneinander getrennt werden.

    Wie geht denn C++ mit diesem Sachverhalt um?

    MFG

    0
    W
     1 Antwort
  • W

    @_ro_ro sagte in Von std::string erben:

    Wie geht denn C++ mit diesem Sachverhalt um?

    Gar nicht.

    Musst du selber machen oder darauf spezialisierte Bibliotheken verwenden. Zum Beispiel https://github.com/copperspice/cs_string

    (Es gibt wstring, aber das hat ja eigentlich dasselbe Problem)
    (Du kannst mit stream.imbue arbeiten, aber das erschien mit immer unendlich kompliziert, schau dir dazu https://en.cppreference.com/w/cpp/locale/codecvt an - teilweise eingeführt mit C++11 und mit C++20 wieder deprecated... also besser lieber gar nicht aufmachen, dieses Fass)

    0
    _
     1 Antwort
  • _

    @wob

    danke, hab'ch mir schon gedacht 😉

    Wie auch immer, wenn man Bytesequenzen nur durchreicht spielt die Zeichenkodierung überhaupt gar keine Rolle. Also strict bytesemantisch arbeiten, so handhabe ich das seit 20 Jahren Web-Anwendung-Programmierung -- Entgegen aller Empfehlungen (die beim genauen Hingucken blödsinnig sind).

    MFG

    0
  • T

    @Schlangenmensch sagte in Von std::string erben:

    Mit C++20 (auch schon 4 Jahre alt)

    Das heißt in 10- bis 15 Jahren kommt es in der Industrie an 🙂 Hab doch tatsächlich letztes Jahr eine Firma erlebt, die jetzt so langsam auf c++11 umsteigen will.

    0
Anmelden zum Antworten