ohne dass ich noch ein eigenes QByteArray-Objekt benötige.
Ein definitives Jein ....
QByteArray QString::toAscii () const
Allein schon das vorhandensein dieser Funktion gibt zu verstehen, das die "Daten" nicht in ASCII vorliegen, sondern in irgend was anderen, bzw das du dich auf das vorhandensein der Daten im Ascii format nicht verlassen kann.
Liest man die Doku, weiss man, das die Daten als Unicode vorliegen, und impliziet shared sind, also ein direkter zugriff darauf ned so einfach ist, bzw sowieso das falsche format liefert.
Deshalb wirst du um einen eigenen "Holder" fuer die Daten ned drumherumkommen.Dein char* zeiger ist ja nur ein Zeiger dessen "Inhalt" du ja irgendwie verwalten musst.
DU koenntest alles selber haendisch machen, aber das waer schlechtes C++, weil vorhandene Klassen dann besser verwendet werden sollten.
Unter QT bietet sich das QByteArray halt an ... warum es nicht nutzen ?
Warum statt der Zeigervariable ned das QByteArry selber nehmen ?
Und ueberall wo du die zeichenkette brauchst, die entsprechnde funktion aufzurufen.
Code: Alles auswählen
QString test = "Test";
QByteArray strAscii = test.toAscii();
std::cout << strAscii.data() << std::endl;
Waer nen saueberer schneller und performanter Weg ....
Wenn Du QByteArray ned magst, gibt es natuerlich andere Alternativen.
C++ gibt es fuer Ascii Strings den std::string als container.
Als erstes wuerde man vielleicht folgendes Schreiben:
Code: Alles auswählen
QString test = "Test";
std::string strAscii = test.toAscii().data();
std::cout << strAscii.c_string() << std::endl;
Das wuerde funktionieren, ist aber boese unperformant.
- test.toAscii() erzeugt das temp. Object und transformiert die Daten da rein.
- der Konstruktor von std::string kopiert die als const char * uebergebene zeichenkette und verwaltet die dann.
Man hat also 2 mal speicher reserviert fuer das ergebnis, und einmal gleich wieder freigegeben.
Zum Glueck mag Trolltech die C++ Programmierer, und der QString bietet auch ein
std::string QString::toStdString () const
an.
Code: Alles auswählen
QString test = "Test";
std::string strAscii = test.toStdString();
std::cout << strAscii.c_str() << std::endl; // Besser : std::cout << strAscii << std::endl; weil std::ostream den std:string nativ unterstuetz.
Warum iss das Performanter, mal abgesehen davon das es schoener aussieht ?
Eigentlich muesste der Compiler ja zuerst das Temp std::string object erzeugen, und dieses dann deiner selbst angelegten variable zuweissen. Die zuweisung sollte doch auch kopieren. Damit haettest genau so 2 mal speicher erzeugt und einmal gleich wieder freigegeben.
Das Zauberwort heisst "Return Value Optimization" und die meisten compiler koennen dies.
Das heisst der Compiler erkennt, das das temporaere rueckgabeobject gleich einer
neuen variablen des
selben Types zugewiesen wird, und erzeugt die spart sich die kopie in dem er gleich die temporaere Variable als die erzeugte weitergibt.
Ob du QByteArray oder std:string verwendest, iss in dem fall deine entscheidung.
Ohne Den Holder kommst aber ned aus !
Noch mehr machen kann man schon, aber da muss man auch mehr in Frage stellen, z.b. den QString selber !
Wer erzeugt den QString, und muss es wirklich ein QString sein ? Meist bekommt man nen C-String und convertiert den in nen QString, um den dann wieder zurueck in nen C-String zu verwandeln.
Code: Alles auswählen
QByteArray test = "Test";
std::cout << test.data() << std::endl;
iss natuerlich noch effizienter
Ciao ...
