+operator ueberladen

Meep Meep

heisst das dann, das ich TxlString = char + TxlString ueberhaupt nicht verwenden kann ? oder wie war das zuverstehen ?

vorhin hatte ich in meiner normalen operator+ funktion nen fehler drinnen gehabt. scheinbar kann man gar kein temp. objekt zurueckgeben und damit weiterarbeiten. wie kann man sowas sont noch loesen ?
bei String , AnsiString funktioniert das doch auch.

Meep Meep

HumeSikkins

Meep Meep schrieb:

heisst das dann, das ich TxlString = char + TxlString ueberhaupt nicht verwenden kann ? oder wie war das zuverstehen ?

Wie war das doch gleich mit links und rechts? Vielleicht hilft ein Bild:

[...............] = [...............]
      ^                      ^
      |                      |
Hier ist links         Hier ist rechts

wie kann man sowas sont noch loesen

Wie man dein Problem löst wurde hier bereits mehrfach gesagt. Vielleicht solltest du nochmal tief Luft holen, dann die Antworten nochmal langsam lesen und wenn dann das Verständnis einsetzt mit dem Programmieren beginnen.
Wenn es dann immer noch nicht klappt, poste dein *konkretes* Problem, also inklusive etwaiger Compilerfehler.

PS: Es gibt keinen Grund den operator+ zu einem friend zu machen

PPS: Mein letzter Beitrag richtete sich an Jester. Du kannst ihn also getrost ignorieren.

Meep Meep

hi HumeSikkins

wo links und rechts liegt, weiß ich schon seit geraumer zeit.

mein problem:

zuerst meine neugeschriebene klasse:

// h-datei

class TxlStrings
{
   private:
      // Methoden

      // Variablen
      unsigned int size;

   public:
      // Konstruktor und Destruktor
      TxlStrings(void);
      TxlStrings(char *t_char);
      ~TxlStrings(void);

      // Methoden
      unsigned int Size(void) { return size; }
      TxlStrings operator=(char *t_char);
      TxlStrings operator=(const TxlStrings &t_string);
      TxlStrings operator+(const TxlStrings &t_string);

      // Variablen
      char *string;

};

// cpp-datei

TxlStrings::TxlStrings(void)
{
   size = 0;
   string = 0;
}

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

TxlStrings::TxlStrings(char *t_char)
{
   unsigned int size = strlen(t_char) + 1;
   string = new char[size];
   memcpy(string, t_char, size);
}

TxlStrings TxlStrings::operator=(char *t_char)
{
   unsigned int t_size = strlen(t_char) + 1;
   if(size < t_size)
   {
      if(string)
         delete[] string;
      size = t_size;
      string = new char[size];
      memcpy(string, t_char, size);
   }
   else
   {
      size = t_size;
      memcpy(string, t_char, size);
   }
   return *this;
}

TxlStrings TxlStrings::operator=(const TxlStrings &t_string)
{
   if(size < t_string.size)
   {
      if(string)
         delete[] string;
      size = t_string.size;
      string = new char[size];
      memcpy(string, t_string.string, size);
   }
   else
   {
      size = t_string.size;
      memcpy(string, t_string.string, size);
   }
   return *this;
}

TxlStrings TxlStrings::operator+(const TxlStrings &t_string)
{
   TxlStrings t_str ;
   t_str.string = new char[t_string.size + size - 1];
   memcpy(t_str.string, string, size - 1);
   memcpy(t_str.string + size - 1, t_string.string, t_string.size);
   return t_str;
}

der operator+ funktioniert jedoch nicht. er gibt mir scheinbar nix mehr zurueck.

TxlStrings a = "test1";
TxlStrings b = "test2";
TxlStrings c = a + b;
ShowMessage(c.string);  // (1)

da kommt bei (1) dann garnix. der operator+ uebergibt sozusagen der variablen c nix.

keine fehlermeldung oder sonstiges.

HumeSikkins

Oh man. Back to square one.
Waren wir zwischendurch nicht schon mal soweit, den Operator+ *nicht* als Member zu implementieren?

Wo ist dein Copy-Ctor?

Meep Meep

so hab jetzt den operator+ folgend global geschrieben:

TxlStrings operator+(const TxlStrings &l_string, const TxlStrings &r_string )
{
   TxlStrings t_str;
   ShowMessage(IntToStr(l_string.size + r_string.size - 1));
   char *test = new char[l_string.size + r_string.size - 1];
   t_str.size = l_string.size + r_string.size - 1;
   t_str.string = new char[l_string.size + r_string.size - 1];
   memcpy(t_str.string, l_string.string, l_string.size - 1);
   memcpy(t_str.string + l_string.size - 1, r_string.string, r_string.size);
   return t_str;
}

// copy construktor

TxlStrings::TxlStrings(TxlStrings &t_string)
{
   size = t_string.size;
   string = new char[size];
   memcpy(string, t_string.string, size);
}

aendert aber nix an der tatsache, das er entweder nix oder nur wirres zeugs ausgibt. geschweige ich mach nen operator+ fuer (char*,TxlStrings).

Meep Meep

Nutze halt mal ein bisschen mehr die Konstruktoren und bereits fertige Operatoren.

inline const String operator+(const String &s1, const String &s2)
{
    String tmp(s1);   // Kopierkonstruktor
    tmp += s2;
    return tmp;
}

// Jetzt musst du natürlich noch += definieren ;). Oder willst du
// für jeden Operator einen fetten Block Anweisungen mit memcpy
// schreiben, bis irgendwann doch ein Fehler drin ist?

Bei MIR sieht das jetzt nachfolgend so aus:

void String::operator+= (const String &otherString)
{
	(*this) += otherString.data;
}

Und das ruft wiederum diese Operation auf:

void String::operator+= (TCHAR *otherString)
{
	// Erforderliche Gesamtlänge bestimmen:
	const int length = (int)_tcslen(data) + (int)_tcslen(otherString) + 1;

	// In einem temporärem String zusammenfügen:
	TCHAR *temp = new TCHAR[length];
	_tcscpy(temp, data);
	_tcscat(temp, otherString);

	// Den String in das L-Value Objekt übertragen:
	delete[] data;
	data = new TCHAR[length];
	_tcscpy(data, temp);

	// Temprären String löschen:
	delete[] temp;
}

Und das ist die einzige Stelle überhaupt, wo ich wirklich was arbeite. Alle anderen Operationen beziehen sich darauf.

Meep Meep

also irgendwie schein ich in einer fremden sprache zu schreiben.

inline const String operator+(const String &s1, const String &s2) 
{ 
    String tmp(s1);   // Kopierkonstruktor 
    tmp += s2; 
    return tmp; 
}

damit ist es leider nicht getan. der operator+ uebergibt mir naemlich nichts. das ist das problem dabei.

da bekomm ich meistens nur wirres zeugs.

ich hab ja mit den operatoren schon gearbeitet. aber jetzt funkt garnix mehr.

ob ich da jetzt in jeder funktion immer wieder die memcpy´s von handschreibe oder nicht, is insofern egal.

sogar wenn ich mir beispiele aus dem inet rauskopiere gibts immer das gleiche problem, obwohl es nicht sein duerfte.

ich lass es einfach. bringt nix sich in sachen zuvertiefen fuer die man zu dumm is.

Meep Meep

nman

Meep Meep schrieb:

also irgendwie schein ich in einer fremden sprache zu schreiben.

inline const String operator+(const String &s1, const String &s2) 
{ 
    String tmp(s1);   // Kopierkonstruktor 
    tmp += s2; 
    return tmp; 
}

Dann lass mich mal Dolmetscher spielen:

inline const String operator+(const String &s1, const String &s2) 
{ 
    String tmp(s1);   // Du erstellst ein lokales String-Objekt
                      // (passenderweise heißt es sogar tmp)
    tmp += s2;
    return tmp;       // Du gibst das lokale String Objekt zurück
} // Das lokale String-Objekt das Du zurückgegeben hast wird zerstört

Meep Meep

so n mist. war fast alles umsonst. auch eure hilfe (trotzdem danke).

nach nem neustart des rechners, funktionierten ploetzlich die sachen.

irgendwie scheint der rechner ne macke gehabt zuhaben.
wahrscheinlich sind 11-12 tage dauerbetrieb doch net so gesund zusein, fuern den blechtrottel.

naja danke euch. hab auf jedenfall einiges dazugelernt.

Meep Meep