Verstehe nicht wie diese Klasse funktioniert

#include<stdio.h>

class String
{
private:
	char*	_string;

public:
	String ():_string(0){}
	String (char* string):_string(string){}

	char* textout()
	{
		return _string;
	}

	int len()
	{
		int len=0;

		while (_string[len])
		{
			len++;
		}
		return len;
	}

	String operator = (char* string)
	{
		_string=string; 
		return *this;
	}
};

int main()
{
	String	string="Hallo Welt";
	printf("%s\n",string.textout());
	printf("%d\n",string.len());

	return 0;
}

Was sagt ihr zu dieser Lösung?

Sowas geht auch

String f()
{
	String temp;
	temp="Hallo Welt";
	return temp;
}

int main()
{
	String	string=f();//"Hallo Welt";
	printf("%s\n",string.textout());
	printf("%d\n",string.len());

	return 0;
}

So jetzt wollte ich z.B. 6 Zeichen von links aus ausgeben. Dazu hätte ich eine Funktion in C.

char* 
left(char* s, int a)
{
	char* t=(char*)malloc(a);
	int b=0;
	a--;

	while(b<=a)
	{
		t[b]=s[b];
		b++;
	}

	t[b]='\0';

	return t;
}

Ich habe es nicht hinbekommen das in die Klasse einzubauen. Wie würdet ihr das machen.

cu

So, was sagt ihr dazu. Ist das so ok?

#include<stdio.h>
#include<iostream.h>

class String
{
private:
	char*	_string;

public:
	String ():_string(){}
	String (char* string):_string(string){}

	char* textout()
	{
		return _string;
	}

	int len()
	{
		int len=0;
		while (_string[len])
		{
			len++;
		}
		return len;
	}

	String left(int a)
	{
		char* t = new char[a];
		int b=0;

		a--;

		while(b<=a) 
		{ 
			t[b]=_string[b]; 
			b++; 
		} 

		t[b]='\0';

		String string(t);

		return string;
	}

	String operator=(char* string){_string=string;return *this;}
};

int main()
{
	String	string="Hallo Welt";
	cout<<string.textout()<<endl;
	string="Dies ist der zweite Test";
	cout<<string.textout()<<endl;
	string="nochmal";
	cout<<string.textout()<<endl;
	cout<<string.len()<<endl;

	String links=string.left(4);
	cout<<links.textout()<<endl;

	return 0;
}

Arghhhh... Funktioniert doch nicht so wie ich dachte.

Wie müsste ich vorgehen damit sowas funktioniert?

Mystring f() { 
  char temp[] = "Hallo"; 
  Mystring result; 
  result = temp; 
  return result; 
}

Ich bekomme das alleine nicht hin

NobbZ

Du musst um result den SPeicherzuzuweisen new benutzen, so wie Du es dort benutzt wird der Speicher direkt wieder freigegeben wenn Du die FUnktion verlässt. MIt etwas glück bleibt zwar noch ne weile an der stelle "test\0" im Speicher stehen, aber da kann man sich auch nicht drauf verlassen. Und funktioniert denn Dein Zuweisungsoperator grundsätzlich schon? Kenne mich mit dem Überladen von Operatoren nicht aus kann daß daher icht beurteilen.

davie

du musst den inhalt, also das, worauf der zeiger zeigt, kopieren (strcpy/strncpy) und dann auf diesen speicher achten (also mit new[] anlegen, mit delete[] löschen)

String operator=(char* string)
{
     _string = new char[];
     while(stirng[l])
     {
          _string[l]=string[l];
          l++;
     }
     _string[l]='\0';
     return *this;
}

Müsste das nicht funktionieren?

Es geht nicht. Keine Vorschläge?

NobbZ

_string = new char[];

Du musst new noch sagen wieviel Speicher er reservieren soll... Und so reserviert er nur den Speichreplatz für einen Pointer auf char. Ich kenne mich mit new leider nicht so aus... Aber ich glaube das müsste so aussehen:

_string = new char[sizeof(string)];

Wie gesagt ist mal nen Schuss ins Blaue

*edit*
Schau am besten mal in eine Referenz Deiner Wahl wie new genau funktioniert. Hab gerade nix dabei, aber auf den von c-plusplus.net verlinkten tuts gab es etwas was pointer und new so erklärt hat, daß ich es auch (fast) verstanden hab

davie

nicht sizeof, sondern strlen(string) + 1 zeichen für '\0'.
Und keine Unterstriche als Beginn für Variablennamen verwenden!

Und wo soll ich den Speicher wieder freigebe? Ich habe schon so vieles ausprobiert. Auch im destruktor habe ich versucht mit delete Speicher freizugeben. Doch dann stürztz das Programm ab.

Ah und das funktioniert auch nicht so wie oben mit new.

string f() {
  char test[]="Hallo";
  string result(test);
  return result; 
}

davie

Du musst zwischen Kopierkonstruktor und Zuweisungsoperator unterscheiden.
Zuerst Speicher von der richtigen Größe anfordern (new char[size]),
dann den string kopieren (strcpy(m_string, string)) und beim Zuweisungsoperator eben zuerst den alten string mittels delete [] löschen.
Im Destruktor dann einfach mit delete [] löschen.
Poste Code, dann sagen wir dir, was genau nicht funktioniert.

c++eus

davie schrieb:

beim Zuweisungsoperator eben zuerst den alten string mittels delete [] löschen.

...zuallererst aber auf selbstzuweisung prüfen.

Jetzt geht es langsam voran.

string f() {
  char test[]="Hallo";
  string result(test);
  return result; 
}

string str=f();
.
.
.

Das geht jetzt.

So sehe die Konstruktoren aus:

string::string ():_string(0){_string = new char[];}
		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';
		}

Das sind die überladenen Operatoren:

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

			int l;

			l=len(t)+1; // len() ist eine eigene Funktion!!!

			_string=new char[l];

			l=0;

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

			return *this;
		}

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

Jetzt habe ich ein Problem beim Destruktor stürzt das Programm ab. bzw. das OS meldet sich zu Wort.

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

Ich weiss man soll keine Variablem mit einem Unterstrich beginnen. Aber alles nur zu Übung
Ich bin trotzdem für jeden Verbesserungshinweis dankbar.

PS:
Das sind noch Methoden die oben verwendet werde.

//  Zeiger auf char zurück geben
		char* 
		string::_char(void){
			return _string;}

//  Länge des Strings 
		int 
		string::len(){
			int l=0;
			while (_string[l]){l++;}
			return l;}

	//  Länge des Strings
		int 
		string::len(char* s){
			int l=0;
			while (s[l]){l++;}
			return l;}

Ich hoffe das war jetzt nicht zu viel

Vellas

Und was kommt für eine Meldung beim Destruktor? Der selbst sieht richtig aus.

Code-Hacker

Expression: _BLOCK_TYPE_IS_VALID(pHead->nBlockUse)

Ich konnte den Fehler lokalisieren.

Er liegt im diesem überladenen Operator:

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

			char* t=st._char();//char aus string holen!

			int l;

			l=len(t)+1;//Laenge von t

			_string=new char[l];

			l=0;

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

			return *this;
		}

Ich weiss nur nich wo genau