ich will eine String Klasse schreiben, um zu verstehen wie div. Dinge intern funktionieren. Außerdem soll es möglich sein den String entsprechenden integer, float, etc. zuweisbar sein (also umwandelbar).

Jedoch habe ich irgendwo in meinem Ansatz einen Fehler, da nachdem ich den String über die entsprechenden Funktionen in den entsprechenden Datentyp umzuwandeln wie z.B. int, float, etc. sind meine char* Daten totaler Matsch... Selbst wenn ich das Konstant zurück gebe anstatt es durch die Funktionen umwandeln zu lassen werden meine Daten matsch... Ich suche schon seit mehreren Stunden und finde den Fehler nicht.... Kann es sein das ich irgendeinen essentiellen Fehler bei der Überladung gemacht habe? Ich hoffe jmd. findet den Fehler, denn ich selbst hab all mein Wissen daran probiert und nichts gefunden...

Header

#ifndef STRING_H_INCLUDED
#define STRING_H_INCLUDED

#include <iostream>
#include <exception>

class String;
class StringHelper;

class OutOfRangeException : public std::exception{
    virtual const char* what() const throw()
    {
        return "String kann nicht umgewandelt werden, da ausserhalb des Wertebereichs.";
    }
};

class StringHelper{
    public:
        static int      toInt(String);
        static float    toFloat(String);
        static double   toDouble(String);
};

/**
    STRING LIBARY
*/
class String{
    public:
        String(){
            this->data = NULL;
        };
        ~String(){
            if(this->data != NULL)
                delete this->data;
        };

        /**
            Wrapper Funktionen für type-casting
        */
        char*   toChar()    { return this->data; };
        int     toInt()     { return StringHelper::toInt(*this); };
        float   toFloat()   { return StringHelper::toFloat(*this); };
        double  toDouble()  { return StringHelper::toDouble(*this); };

        /**
            INT "cast" via << oder >> operatoren
        */
        friend int& operator << (int&, String);
        friend int& operator >> (String, int&);

        friend String& operator << (String&, int);
        friend String& operator >> (int, String&);

        /**
            FLOAT "cast"
        */
        friend float& operator << (float&, String);
        friend float& operator >> (String, float&);

        friend String& operator << (String&, float);
        friend String& operator >> (float, String&);

        /**
            Output-STREAM Operatoren
        */
        friend std::ostream& operator << (std::ostream&, String);
        friend std::ostream& operator << (std::ostream&, String*);

        String& operator = (char*);
        String& operator = (int);
        String& operator = (float);
        String& operator = (double);
        String& operator = (const char*);

        /**
            CAST Operators
        */
        operator int(){ return this->toInt(); }
        operator double(){ return this->toDouble(); }
        operator float(){ return this->toFloat(); }

    private:
        char *data;
};

#endif // STRING_H_INCLUDED

Quelltext

#include "string.h"

int      StringHelper::toInt(String s){
    int tmp = strtol(s.toChar(), NULL, 10);

    if ((errno == ERANGE && (tmp == LONG_MAX || tmp == LONG_MIN))
            || (errno != 0 && tmp == 0)) {
        throw OutOfRangeException();
    }

    return tmp;
}
float    StringHelper::toFloat(String s){
    float tmp = strtod(s.toChar(), NULL);

    if ((errno == ERANGE)
            || (errno != 0 && tmp == 0)) {
        throw OutOfRangeException();
    }

    return tmp;
}
double   StringHelper::toDouble(String s){
    double tmp = strtod(s.toChar(), NULL);

    if ((errno == ERANGE)
            || (errno != 0 && tmp == 0)) {
        throw OutOfRangeException();
    }

    return tmp;
}

/**
    INT "cast" via << oder >> operatoren
*/
int& operator << (int& i,String s){
    i = s.toInt();
    return i;
}

int& operator >> (String s, int& i){
    i = s.toInt();
    return i;
}

String& operator << (String& s, int i){
    char* buf = new char[128];
    sprintf(buf, "%i", i);
    s.data = buf;
    return s;
}

String& operator >> (int i, String& s){
    char* buf = new char[128];
    sprintf(buf, "%i", i);
    s.data = buf;
    return s;
}

/**
    FLOAT "cast"
*/
float& operator << (float& i,String s){
    i = s.toFloat();
    return i;
}

float& operator >> (String s, float& i){
    i = s.toFloat();
    return i;
}

String& operator << (String& s, float i){
    char* buf = new char[128];
    sprintf(buf, "%f", i);
    s.data = buf;
    return s;

}
String& operator >> (float i, String& s){
    char* buf = new char[128];
    sprintf(buf, "%f", i);
    s.data = buf;
    return s;
}

std::ostream& operator << (std::ostream& stream, String s)
{
    stream << s.toChar();
    return stream;
};
std::ostream& operator << (std::ostream& stream, String *s)
{
    stream << s->toChar();
    return stream;
};

String& String::operator = (char* ca){
    this->data = ca;
    return *this;
}

String& String::operator = (int i){
    char* buf = new char[128];
    sprintf(buf, "%i", i);
    this->data = buf;
    return *this;
}

String& String::operator = (float i){
    char* buf = new char[128];
    sprintf(buf, "%f", i);
    this->data = buf;
    return *this;
}

String& String::operator = (double i){
    char* buf = new char[128];
    sprintf(buf, "%f", i);
    this->data = buf;
    return *this;
}

String& String::operator = (const char* ca){
    // Einfach formuliert ca den const charakter nehmen
    *this = const_cast<char*>(ca);
    return *this;
}

Test

#include <iostream>
#include "main.h"

using namespace std;

int main()
{
    try{
        String s;
        s = "3";

        int i = 300;
        float f = 5.56;

        s << f;
        i << s; // Hier tritt der Fehler auf...

        cout << i << endl;
        cout << f << endl;
        cout << s << endl;

    }catch(...){
        cout << "Uncatched Exception occured." << endl;
        return -1;
    }

    return 0;
}

Danke.
Blackskyliner

class String{
//[...]
        String(){
            this->data = NULL;
        };
        ~String(){
            if(this->data != NULL)
                delete this->data;
        };

        String(const String &s)
        {
            this->data = new char[getLength(s.toChar())+1];
            strcpy(this->data, s.toChar());
        }

        String(char* &s)
        {
            this->data = new char[getLength(s)+1];
            strcpy(this->data, s);
        }

        String const& operator=(String const& s)
        {
            String temp(s);
            std::swap(this->data, temp.data);
            return *this;
        }
//[...]
        int getLength(char* s) const{
            int i = 0;
            while(*s++ != '\0'){
                i++;
            }
            return i;
        };
        int getLength() const{
            return getLength(this->data);
        };
//[...]
}

Ist das so jetzt in Ordnung oder hab ich noch etwas übersehen? Nicht das ich nochmal irgendwann ein Problem bekomme...

Ist das swap() notwendig oder geht das auch kürzer?
Ist der Initial Konstruktor String(){ this->data = NULL } sinnvoll?

Das mit dem Memoryleak stimmt... wird aber noch behoben.

Danke für die konstruktiven Beiträge, haben mir sehr weitergeholfen

EDIT:
Bin ich vor Memory leaks sicher, wenn ich folgendes mache:

String& operator << (String& s, float i){
    // Auf einen String umbauen damit speicherleak verhindert werden kann..
    //char* buf = new char[128];
    String ss(128);
    sprintf(ss, "%f", i);
    std::swap(s.data, ss.data);
    return s;
}

und dazu den Konstruktor

String(int i){
            this->data = new char[i];
        }

und den cast Operator

operator char*(){ return this->data; }

MFG
Blackskyliner

Zeile 4: die Initialisierung des Zeigers mit Null ist unbedingt nötig da der Zeiger sonst zufällige Werte enthalten kann. Spätestens beim Aufruf des Destruktors führt dies zu Problemen, da ein ungültiger Pointer gelöscht wird. Die Initialisierung sollte aber über die Initialisierungsliste erfolgen. Bei einem char Pointer ist es zwar noch egal, aber du solltest dir grundsätzlich angewöhnen alle Member über die Initialisierungsliste zu initialisieren.

Zeile 7: delete prüft selbst ob ein Null Pointer gelöscht werden soll, deshalb ist diese Prüfung nicht nötig.

Zeile 17: der Parameter sollte const sein.

Zeile 30: hier solltest du die Standardfcunktion strlen benutzen. Einige Funktionen ( z.B. strlen , memcopy , ... ) werden vom Compiler nicht in Funktionsaufrufe übersetzt sondern durch inline Assembler ersetzt. Diese sind somit im allgemeinen schneller als alle in C möglichen implementierungen.

Zeile 37: in allen Stl Klassen heißt diese Methode size. Es ist immer sinnvoll sich an Standardbezeichnungsschemen zu halten, dies macht die Klase leichter benutzbar.

Die Typkonvertierungen über streamoperatoren finde ich etwas komisch und habe ich so noch nie gesehen.
Ich finde für Typkonvertierungen boost::lexical_cast sehr interessant. Man muss für seine Klasse nur streamoperatoren definieren und kann von und nach allen Klassen konvertieren die dies auch tun.

Deine Änderungen finde ich aus folgenden Punkten problematisch:
Eine Klasse sollte niemals ihre Implmentierungsdetails nach aussen geben. Es sollten also höchstens Zeiger auf konstante Daten zurückgegeben werden. Desweiteren würde ich bei einem string kosntruktor erwarten das er eine string repräsentation des übergebenen erstellt. Dieser Destruktor sollte, wenn unbedingt nötig, als explicit deklariert werden.

An der StringHelper Klasse finde ich den zyklische Bezug zur String Klasse problemetisch. Wenn du die Klasse irgendwann mal auslagern musst weil du sie auch woanders verwendest kann dir das Probleme machen. Wobei die Lösung hier recht einfach ist, du musst als Parameter nur char pointer anstatt String´s verwenden.

Ich definiere mir den Additionsoperator und geben ein neues Objekt zurück, damit die Daten des Ursprungstrings nicht verändert werden. (Temporäre String verkettung). Meines Wissenstandes nach muss ich ja dafür ein neues String Objekt erzeugen, welches ja dann aber leider nicht gelöscht wird... und da liegt der Hase im Pfeffer, wie umgehe ich das?

Die Operatoren Überladung:

String& operator+(const char *text)
        {
            char *tmp;
            int Len=getLength()+StringHelper::getLength(text);
            tmp=new char[Len+1];
            strcpy(tmp,this->data);
            strcat(tmp,text);
            //delete vBuf;
            //vBuf=tmp;
            return *(new String(tmp));
        };

        String& operator+(const String *text)
        {
            char *tmp;
            int Len=getLength()+text->getLength();
            tmp=new char[Len+1];
            strcpy(tmp,this->data);
            strcat(tmp,text->data);
            return *(new String(tmp));
        };

Ich weiß das es nicht gut ist ein neues Objekt zurück zu geben, aber das muss ich ja, da ich keine lokalen Referenzen weitergeben darf geschweige denn das Ausgangsobjekt verändern will...

Bin dankbar für jeden Tipp.

MFG
Blackskyliner

aber schau mal auch hier vorbei: http://tutorial.schornboeck.net/los/string.htm

Meines Wissenstandes nach muss ich ja dafür ein neues String Objekt erzeugen, welches ja dann aber leider nicht gelöscht wird... und da liegt der Hase im Pfeffer, wie umgehe ich das?

Arbeite mit automatischen Objekten, nicht mit dynamisch angeforderten.

String& operator+(const char *text)

String& ist definitiv der falsche Rückgabetyp. Dass besitzende Referenzen auf von new angeforderten Speicher verweisen, ist zudem sehr unüblich.

// += als Memberfunktion, gibt Referenz auf eigenes Objekt zurück.
String& String::operator+= (const char* rhs)
{
    // ...
    return *this;
}

// + als freie Funktion, greift auf += zu.
String operator+ (const String& lhs, const char* rhs)
{
    String tmp(lhs);
    tmp += rhs;
    return tmp;
}

Zur Operatorüberladung kannst du dir diesen Artikel durchlesen.

Die impliziten Konvertierungsoperatoren dürften relativ schnell zu Problemen führen.

String s;
long double foo = s;