Jetzt gehts es nicht mehr weiter.

Helium

Ich seh einen... Selbstzuweisung kracht.

tut mir leid. Meine Zauberkugel habe ich zu Hause. Hier kann ich nur davon ausgehen, was ich sehe und hier sehe ich einen operator =, der einem "string" einen "char *" zuweist. Was bei string.operator = (string) passiert kann ich so nicht sagen.

Jester

ups... nicht aufgepaßt... aber wenn das Teil eine Funktion bietet um an den Pointer zu kommen, dann kann man damit auf jeden Fall Mist bauen.

Helium

Ich hab da eine Idee: Der Copy-C'tor baut mist.

Das fehlt ja ganz in meiner Mängellsite:

string operator=(char* t) // sollte const string & zurückgeben und const char * empfangen

@Kast: Kannst du mal deinen Copy-C'tor posten?

operator void

Helium schrieb:

if(_string!=NULL) // Was soll der Test?
                delete[] _string; 

            ...

            _string=new char[l];

Ich will ja nicht wissen, was der Destruktor macht, wenn hier ein bad_alloc fliegt

Hi, also ich bin ja ganz neu in C/C++. Deshalb habe ich mir mal vorgenommen so eine String-Klasse selber zu coden um ein wenig Übung zu bekommen.

len() ist z.B. eine eigene Funktion.

int 
		string::len(){
			if(_string!=NULL)
			{
				int l=0;
				while (_string[l]){l++;}
				return l;
			}
			return 0;}

@operator void
was meinst du mit wenn ein "bad_alloc fliegt".

Und was ist ein Copy-C'tor?

PS: Ich möchte soviel wie möglich selber programmieren. Manche sitzen vor Kreuzworträtseln oder schauen Fern. Mir macht es Spass meinen Kopf über solche Sachen zu zerbrechen. Ich finde das ist besser als das beste Computerspiel

Das glaub ich dir ja, aber wenn du deinen String schon nullterminierst, dann kannst du ja wirklich strlen() benutzen.
Oder strcpy. Und wenn du das wirklich nicht willst, dann bau deine eigene private strcpy-Funktion zusammen. Aber ich würde nicht in jedem Operator/Methode/wasweissich so ne umständliche for-Schleife machen, oder willst du jedesmal den Fehler in 50 Zeilen Code anstatt in 5 Zeilen suchen?

EDIT: Ein Copy-CTor ist ein Copy-Konstruktor, der ein Objekt der eigenen Klasse übernimmt (am besten als const Referenz) und anhand dieser Werte das eigene Objekt initialisiert.

Ja müsste ich mache. Doch zur Zeit habe ich Probleme rauszufinden warum das Programm abstürzt wenn ich einen eigenen Destruktor verwende

const string& operator=(const char* t)
		{	
			if(_string)
				delete[] _string;

			int l;

			l=len((char*)t)+1;

			_string=new char[l];

			l=0;

			while(t[l])
			{
				_string[l]=t[l];
				l++;
			}
			_string[l]='\0';

			return *this;
		}

const string& operator=(string st)
		{
			if(_string)
				delete[] _string;

			char* t=st._char();

			int l;

			l=len(t)+1;

			_string=new char[l];

			l=0;

			while(t[l])
			{
				_string[l]=t[l];
				l++;
			}
			_string[l]='\0';

			return *this;
		}

//  Destruktor
		string::~string()
		{
                      if(_string)
	                 delete[] _string;
		}

//  Konstruktor
	    string::string ()
		{
			_string = NULL;
		}

		string::string (char* t)
		{
			int l;

			l=len(t)+1;

			_string=new char[l];

			l=0;

			while(t[l])
			{
				_string[l]=t[l];
				l++;
			}
			_string[l]='\0';
		}

Genau das mein ich. Du hast lauter while-Schleifen, weil du das Kopieren nicht in eine eigene Methode auslagerst. Jetzt musst du dich durch 50 Zeilen Code quälen.
Außerdem kann irgendwas nicht stimmen, wenn du 2mal nen operator= hast und beide male ist der Code so lang. Mach mal den operator= erstmal für den string und beim operator= für const char* benutzt du den Konstruktor um dein char* in ein String-Objekt umzuwandeln und rufst dann damit den operator= für string wieder auf. So kannst du es mit jedem Datentyp machen und hast jedesmal nur nen 2-Zeiler. Und wenn wirklich dort der Fehler ist, musst du es nur an einer Stelle ausbessern.
Und wo stürzt er jetzt genau warum ab? Hast du mal mit dem Debugger gearbeitet?

Also der VC Compiler meldet: ...Code 3 (0x3) beendet ohne auf eine bestimmte Stelle im Code zu zeigen. Ich bekomme noch eine Meldung : Expression: _BLOCK_TYPE_IS_VALID(pHead->nBlockUse)

Das macht er nicht wenn ich den Destruktor so gestallte:

//  Destruktor
string::~string()
{
   if(_string)
      //delete[] _string;
}

Jester

Wenn das Problem beim Destruktor auftritt weiß ich woran es liegt. Der implizit generiert Copy-Konstruktor macht ne flache Kopie. Und dann ist das beim freigeben ein bißchen ungünstig.

MfG Jester

Gibt es ein Wörterbuch für C++? Was ist den eine flache Kopie, gibt es auch eine steile Kopie

Danke. Das war die Lösung. Eine tiefe Kopie Man lernt immer wieder was neues.

cu

Jester meint glaub ich, dass nur dein Objekt, das heisst der Zeiger und was du halt noch für Datenelemente hast, kopiert wird.
Aber der kopierte Zeiger zeigt natürlich immer noch auf das selbe mit new erstellte Array.
Also löscht der Destruktor das Array. Wenn du jetzt noch ne Kopie von dem Objekt hast, will dessen Destruktor auch das Array nochmal löschen -> bäng.

Allerdings schaut das für mich jetzt auf den ersten Blick schon so aus, als ob du das Array kopierst. Aber mach das besser nicht mit dem operator= sondern erstell einen Konstruktor string(string& otherString).

Und btw, "l" ist ein sehr schlechter Name für eine Variable.

Aaargh, jetzt warst du ein paar Sekunden schneller. Und ich meine natürlich string(const string& otherString)