Ein Zuweisungsoperator für Strings schreiben - wie?



  • Hallo!

    string s;
    wstring ws;
    ws = s;
    

    Binärer Operator '=': Es konnte kein Operator gefunden werden, der einen rechtsseitigen Operanden vom Typ 'std::string' akzeptiert (oder keine geeignete Konvertierung möglich

    Kann ich mir nen eigenen Operator schreiben, der auch gleichzeitig von wchar_t nach UTF-8 konvertiert`?



  • Warum operator=? Gibt doch sowas schon:

    std::string str;
    wxstring ws = wxstring::FromAscii(str.c_str());
    


  • Es ist mit purem C++ ohne externe libs noch nicht möglich wchar_t nach UTF-8 zu konvertieren. Sie dazu einen Artikel in linuxquestions



  • orgienisator schrieb:

    Warum operator=? Gibt doch sowas schon:

    std::string str;
    wxstring ws = wxstring::FromAscii(str.c_str());
    

    Danke, aber son fettes Urvieh von lib wollte ich nicht einbinden.

    DeepCopy schrieb:

    Es ist mit purem C++ ohne externe libs noch nicht möglich wchar_t nach UTF-8 zu konvertieren. Sie dazu einen Artikel in linuxquestions

    Ich dachte, es wäre eventuell möglich einen Zuweisungsoperator zu schreiben, der z.B. eine Konvertierungsfunktion aufruft?



  • operat0r schrieb:

    Ich dachte, es wäre eventuell möglich einen Zuweisungsoperator zu schreiben, der z.B. eine Konvertierungsfunktion aufruft?

    Im Prinzip schon aber dann hast die nächste Woche noch viel zu tun 🙂
    Der Zuweisungsoperator wäre dann ja auch nicht das Problem aber der Konverter.

    Tipp: Schau dir mal den Source wxString der wxWidgets an, vielleicht kannst du was davon verwenden.



  • operat0r schrieb:

    orgienisator schrieb:

    Warum operator=? Gibt doch sowas schon:

    std::string str;
    wxstring ws = wxstring::FromAscii(str.c_str());
    

    Danke, aber son fettes Urvieh von lib wollte ich nicht einbinden.

    argh, sry. Ich hab in deinem Code-Beispiel ein "x" gelesen wo keines war 😕
    Du willst wstring und nicht wxstring...



  • den konverter habe ich schon, das problem ist für mich der operator.



  • Öhm.. ja, und wo soll das Problem sein?

    Zeigt doch mal ein bisschen Code, dann kann ich auch was machen.

    EDIT: Ich meine natürlich von deinem Konverter.



  • wstring::operator = ( const string& s )
    {
    	if ( s.empty() )
    		return wstring();
    	wstring w;
    	utf8_to_wchar_t (s, w);
    	return w;
    }
    

    error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
    1>e:\unilangtrain\unilangtrain\winmain.cpp(210) : error C2511: 'int std::basic_string<_Elem,_Traits,_Ax>::operator =(const std::string &)': Überladene Memberfunktion nicht in 'std::basic_string<_Elem,_Traits,_Ax>' gefunden



  • achso, den konverter willst du sehen - das ist die windowsfunktion MultiByteToWideChar



  • Ah, ich glaube ich weiss jetzt wo dein Problem liegt: es gibt zwei Arten von Operatoren, globale und klassenlokale Operatoren.

    Im ersten Fall (global) definierst du:

    wstring& operator=(wstring& parname1, string& parname2) 
    { /* der Aufruf des Konverters */ 
      //mach was...
      return parname1;
    }
    

    und erweiterst in die Klasse wstring um deinen Operator als friend operator

    class wstring
    {
    /** ein Haufen anderes Zeugs **/
      public:
       friend wstring& operator=(wstring&, string&);
    /** ein Haufen anderes Zeugs **/
    };
    

    Im zweiten Fall (klassenlokal) machst du das gleich in der Klasse wstring:

    class wstring
    {
    /** ein Haufen anderes Zeugs **/
      public:
       wstring& operator=(string& parname) 
       { /* konverter aufruf */ 
         // mach was...
        return *this; 
       };
    /** ein Haufen anderes Zeugs **/
    };
    

    So funktioniert es im allgemeinen für alle Operatoren, mit ein paar kleinen Ausnahmen. (wie immer in C/C++).



  • Aber erweitern geht sicher nicht, wstring ist ein fixer typedef auf std::basic_string<wchar_t>.
    Also wenn dann nur global.



  • Oh, dann müsste ich ja am Quellcode der Standardbibliothek rumdoktern. Das ist wohl nicht so gut, ne.



  • Orgienisator schrieb:

    Aber erweitern geht sicher nicht, wstring ist ein fixer typedef auf std::basic_string<wchar_t>.
    Also wenn dann nur global.

    Und ein Blick in meinen Prinz verrät mir dass
    op=
    op[]
    op()
    op->
    nur als Memberfunktionen überladbar sind, also nix mit Global.



  • Orgienisator schrieb:

    Und ein Blick in meinen Prinz verrät mir dass
    op=
    op[]
    op()
    op->
    nur als Memberfunktionen überladbar sind, also nix mit Global.

    Schei...se stimmt. 😞



  • Und wie wäre es mit einem anderen Operator?



  • operat0r schrieb:

    Oh, dann müsste ich ja am Quellcode der Standardbibliothek rumdoktern. Das ist wohl nicht so gut, ne.

    Hmmm...oder ich müsste nen neuen Stringtypen einführen und diesem dann die neuen Operatoren spendieren ... hmm... son einfacher Funktionsaufruf ist dann wohl doch weniger aufwendig, ne.



  • DeepCopy schrieb:

    Und wie wäre es mit einem anderen Operator?

    Weiss nicht, eventuell ein bisschen verwirrend/unüblich?



  • Beim Ableiten der Klasse würde deutlich mehr Aufwand entstehen, Konstruktoren, Destruktoren, Zuweisungsoperatoren und friend Deklarationen müssten mitgeschliffen werden.

    Als Operator könnte ich mir einen der Bit-Shifter Operatoren vorstellen, also:

    string s;
    wstring w;
    
    w << s; // würde vom Compiler auch vom Transfer-Operator unterschieden werden.
    

    Der Code dazu könnte so aussehen:

    wstring& operator<<(wstring& w, string& s)
    {
      if (s.empty()) return w);
      utf8_to_wchar_t (s, w);
      return w;
    }
    

    PS:

    Weiss nicht, eventuell ein bisschen verwirrend/unüblich?

    Was in C++ ist nicht verwirrend/unüblich 🙂



  • Mir ist da noch was eingefallen warum auf den Zuweisungsoperator schauen.

    Eine globale Funktion tut es doch (fast) genauso.

    wstring& UToW(wstring& w, string& s)
    {
      if (s.empty()) return w;
      utf8_to_wchar_t (s, w);
      return w;
    }
    

    aber nur ein Vorschlag, soll dich nicht von der Operator-Schiene wegbringen.
    Ich weiss ist lange nicht so schön wie ein Zuweisungsoperator, aber vielleicht gefällt dir ja mein letzter Vorschlag.


Log in to reply