Klasse von QString ableiten und Methoden weiter verwenden

Hallo zusammen,
ich hoffe mir kann jemand bei meinem Problem helfen.
Ich verwende Qt5 und möchte eine Klasse Hexstring von QString ableiten.

Die Klasse Hexstring soll nur eine weitere Methode haben:

unsigned char * Hexstring::toUCharArray() const

ansonsten möchte ich die Methoden von QString weiter verwenden, da diese ja auch für Hexstring passen.

Im Main-Programm möchte ich Klasse wie folgt verwenden:

Hexstring hex = Hexstring::number(serial,16);

Jedoch bekomme ich bei der ersten Zeile schon eine Fehlermeldung...klar, da die Hexstring Klasse keine statische Methode number hat. Dann bin ich den Weg so gegangen:

Hextring hex = QString::number(serial,16);

Jedoch habe ich dann wieder das Problem, dass der folgende Code nicht mehr funktioniert.

if (hex.length()%2!=0){
   hex = QString("0").append((QString) hex);
}
unsigned char* hexarray = hex.toUCharArray();

Es gibt dafür keine passende Konvertierung.
Wenn ich es so mache

if (hex.length()%2!=0){
   hex = (Hexstring) QString("0").append((QString) hex);
}
unsigned char* hexarray = hex.toUCharArray();

dann bekomme ich die Fehlermeldung, dass keine Konvertierung von QString nach Hexstring möglich ist.
Was muss ich ich der Klasse machen, damit das so funktioniert?

Eine letzte Frage habe ich noch:
Wie komme ich von der Methode toUCharArray() an den jeweiligen String der in QString gespeichert ist?

unsigned char * Hexstring::toUCharArray() const
{
   QString str = "Hier benötige ich den String aus QString";
}

Mr.Pfiff schrieb:

Hexstring hex = Hexstring::number(serial,16);
Jedoch bekomme ich bei der ersten Zeile schon eine Fehlermeldung...

Schön, dass du sie nicht nennst, sonst hätte man dir sagen können, was du falsch machst.

Mr.Pfiff schrieb:

Eine letzte Frage habe ich noch:
Wie komme ich von der Methode toUCharArray() an den jeweiligen String der in QString gespeichert ist?
unsigned char * Hexstring::toUCharArray() const
{
   QString str = "Hier benötige ich den String aus QString";
}

???
*this, begin(), at(), [] ...

unsigned char * schreit nach dangling Pointer oder Memoryleak.

Warum keinen freie Funktion?

hustbaer

Mr.Pfiff schrieb:

Hallo zusammen,
ich hoffe mir kann jemand bei meinem Problem helfen.

Klar.
Lass den Quatsch und mach statt dessen ne freie Funktion toUCharArray .
Ist doch völliger Unfug da nen riesen Aufwand reinzustecken, nur weil du foo.toUCharArray() statt toUCharArray(foo) schreiben willst.

Ihr habt ja schon recht
Eine freie Funktion wäre viel einfacher.
Danke schonmal für euere super schnellen Antworten.
Wollte die Sache mit der Vererbung mal anhand einer vorhandenen Klasse durchexerzieren.

Hier noch der Header

#ifndef HEXSTRING
#define HEXSTRING

#include <QString>

class Hexstring:public QString{
public:
    Hexstring(const char *);
    Hexstring(QString &&);
    unsigned char *toUCharArray() const;
};

#endif // HEXSTRING

und die cpp-Datei

#include "hexstring.h"

Hexstring::Hexstring(const char * other) : QString(other)
{
}

Hexstring::Hexstring(QString && other) : QString(other)
{
}

unsigned char * Hexstring::toUCharArray() const{
    int i;
    bool ok;
    QString str = *this;//QString(this->data());
    if (str.length()%2!=0){
        str = QString("0").append(str);
    }
    unsigned char *hexarray_expiration = (unsigned char*) malloc(sizeof(char)*str.length()/2);
    for(i=0;i<str.length();i=i+2){
        hexarray_expiration[i/2]=QString(str.at(i)).append(str.at(i+1)).toUShort(&ok,16);
        if(!ok){
            qDebug("Konvertierung fehlgeschlagen!");
        }
    }
    return hexarray_expiration;
}

Falls ich jetzt noch böse Fehler drin hab, dann bitte ein freundlicher Hinweis! Sorry dass die Klassendefinition bei meiner Problemstellung gefehlt hat

Danke auch noch für den Tipp mit "*this"

malloc?
new[]!

(wenn schon diese unsinnige händische Speicherverwaltung)

hustbaer

Mr.Pfiff schrieb:

Wollte die Sache mit der Vererbung mal anhand einer vorhandenen Klasse durchexerzieren.

Dann wähl aber bitte ein Beispiel wo die Vererbung auch Sinn macht, und nicht wie hier eines wo die Vererbung eben gerade total sinnfrei ist.
Das ist doch total dämlich, dabei lernst du *nichts* ausser wie man es total falsch macht.

BTW kleiner Tip noch (bzw. 2): sizeof(char) ist garantierterweise immer 1. Und das Deklarieren von allen Variablen am Anfang der Funktion ist ganz schlimm 90er-Jahre Stil und verschlechtert immens die Lesbarkeit.

Ja ok...
wie mache ich soetwas dann ohne die "unsinnige" Speicherverwaltung?

So sinnfrei würde ich die Vererbung hier nicht sehen, denn ein Hexstring ist
doch nichts anderes als ein "erweiterter" QString!?

Mr.Pfiff schrieb:

Ja ok...
wie mache ich soetwas dann ohne die "unsinnige" Speicherverwaltung?

std::vector<unsigned char>
oder
std::basic_string <unsigned char>
oder
std::string mit "normalem" char (warum benutzt du unsigned?)

Das Ganze natürlich auch als Ergebnistyp der Funktion!

Nathan

Mr.Pfiff schrieb:

So sinnfrei würde ich die Vererbung hier nicht sehen, denn ein Hexstring ist
doch nichts anderes als ein "erweiterter" QString!?

Ja, aber das modelliert man (in C++) nicht mit Vererbung.
Verwende public Vererbung nur, wenn die Basisklasse einen virtuellen oder protected Destruktor hat. Denn nur dann kann die polymorphisch genutzt werden.
Verwerbe, damit andere deine Klasse nutzen können, nicht damit du, eine andere Klasse nutzen kann.

Super schon wieder was gelernt

Verwende public Vererbung nur, wenn die Basisklasse einen virtuellen oder protected Destruktor hat. Denn nur dann kann die polymorphisch genutzt werden.

Könnt ihr mir hier eine Beisielklasse nennen?

std::vector<unsigned char>
oder
std::basic_string <unsigned char>
oder
std::string mit "normalem" char (warum benutzt du unsigned?)

Das Ganze natürlich auch als Ergebnistyp der Funktion!

Seh ich ein. Brauche jedoch für eine vorhandene C-Funktion, die ich damit füttere, den unsigned char Pointer. Meine C-Funktion kann ja kein std::vector<unsigned char> verarbeiten!? Oder seh ich das falsch?

Für reines C++ ist dein Ansatz natürlich der

http://en.cppreference.com/w/cpp/string/basic_string/c_str

hustbaer

@Mr.Pfiff

std::vector<unsigned char> vec;
// Daten nach vec reinschaufeln
unsigned char* data = &vec[0]; // C++03
unsigned char* data2 = vec.data(); // C++11
// Die Zeiger kannst du jetzt an deine C-Funktion übergeben

@manni66
basic_string<unsigned char> ist ja wohl ein ziemliches no-go für Binärdaten!