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";
}

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?

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.

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"

(wenn schon diese unsinnige händische Speicherverwaltung)

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.

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

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!

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.

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

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!