#include <iostream>

using namespace std;

class CTString  
{
public:
   // Konstruktoren
   CTString();
   CTString(const char *);
   // Kopierkonstruktor
   CTString(const CTString &);

   // Destruktor
   ~CTString ();

	// "normale" Methoden
	bool SetZeichenkette(const char*); // false, wenn kein Speicher vorhanden
	const char* GetZeichenkette();
	int GetLaenge ();

	// String einfügen
    // false, wenn kein Speicher vorhanden
	bool Insert ( int, const char* ); 
	bool Insert ( int, const CTString& );
	// String Anhängen
    // false, wenn kein Speicher vorhanden
	bool Add    ( const char* );
	bool Add    ( const CTString & );

	// Operatoren
	CTString& operator= ( const char* );
	CTString& operator= ( const CTString& );
	// Ein Zeichen zuweisen
	CTString& operator= ( char );
	// ASCII-Wert eines Zeichens zuweisen
	CTString& operator= ( int );

    // Anhängen
	CTString& operator += ( const CTString& );
	CTString& operator += ( const char* );

private:
   // Attribute
   char *m_szZeichenkette; //eigentlicher Stringpointer soll gekapselt sein
   unsigned int m_nLaenge; // Laenge des String

   // nützliche Funktionen
   // Bestimmt die Länge eines beliebigen Strings (strlen() aus string.h)
   unsigned int StrLaenge ( const char* );
};

deine aufgabe habe ich so weit verstanden, dass du eine string-klasse schreiben sollst und dafuer schon den klassenstumpf vorgegeben bekommen hast.

char *m_szZeichenkette haelt dabei einen pointer zur eigentlichen zeichenkette.
die ganzen memberfunktionen sollst du so schreiben, dass m_szZeichenkette nur ueber diese memberfunktionen manipuliert wird.
dazu hast du unter anderem konstruktoren, einen destruktor und operatoren zu schreiben.

als erstes faengst du mit den konstruktoren und dem destruktor an, damit m_szZeichenkette mit etwas sinnvollem belegt ist und du weitermachen kannst.

bis wann muss die aufgabe fertig sein?

int GetLaenge ();

hinschreiben?

Fragt
Werner

#include<iostream>
#include "Tstring.h"
// 1.Konstruktor
Tstring::Tstring()
{
     //Adresse auf Null setzen             
     String = NULL;
     Stringlaenge =0;      
}
//2. Konstruktor
Tstring::Tstring(const char *str)
{
    //Adresse auf NUll setzen                    
    String = NULL;            
    //Setstring aufrufen um den an den K. übergebenen String in das Attribut String zu schreiben       
    Setstring(str);                   
}
//3. Kopierkonstruktor
Tstring::Tstring(Tstring & str)
{
    //Adresse auf NUll setzen                    
    String = NULL;            
    //Setstring aufrufen um den an den K. übergebenen String in das Attribut String zu schreiben       
    Setstring(str.String);                   
}
//Destruktor
Tstring::~Tstring()
{
    free(String);
    Stringlaenge = 0;
}
// Ersatz für die Funktion "strlen"
unsigned int Tstring::AnzahlZeichen(const char *str)
{
         unsigned int len= 0;
         while(str[len] !='\0')
         {
                        len++;
         }
         return len;
}

bool Tstring::Setstring(const char *str)
{
     Stringlaenge = AnzahlZeichen(str);
     //Prüft ob String vorhanden und reserviert den Speicher 
     if (String == NULL)
     {
         String =(char*) malloc ((Stringlaenge +1) * sizeof (char));
     }
     else
     {             
         String =(char*) realloc(String,(Stringlaenge+1) * sizeof (char));
     }
     // Prüft ob Speicher reserviert werden konnte 
     if (String != NULL)
     {
               //Koppiert alle Zeichen inklusive /0
               for(unsigned int i=0;i<=Stringlaenge;i++)
               {
                   String[i]=str[i];                          
               }
               return true;
     }
     else
     {
         return false;
     }
}
//Einfüge Methode
bool Tstring::Einfuegen(unsigned int position, const char *str)
{
     unsigned int len = AnzahlZeichen(str);
     //Prüft ob Speicher reserviert wurde und reserviert Speicher 
      if (String == NULL)
     {
         String =(char*) malloc ((Stringlaenge+len+1) * sizeof (char));
     }
     else
     {             
         String =(char*) realloc(String,(Stringlaenge+len+1) * sizeof (char));
     }
     // Prüft ob Speicher reserviert werden konnte 
     if (String != NULL)
     {
      // position= position -1 damit das Zeichen an der angegeben Stelle nicht vergessen wird 
      position -= 1; 

      for ( int i = Stringlaenge; i >=position; i-- )
      {
         String[i+len] = String[i];
      }
      for ( int i = position; i <position +len; i++ )
      { 
         String[i] = str[i-position];
      }
      // Neue Länge 
     Stringlaenge +=len; //Stringlaenge = Stringlaenge +len
     return true;
     }
     else
     {
         return false;
     }    
}
//Anhaenge Methode
bool Tstring::Anhaengen(const char *str)
{
     return Einfuegen(Stringlaenge,str);
}
const char *Tstring::Getstring(void)
{    
     if(Stringlaenge >0)
     {
     return String;
     }
     else
     { 
         return "Noch kein String vorhanden";
     }
}
unsigned int Tstring::Getstringlaenge(void)
{
         return Stringlaenge;
}

// Operatoren
Tstring &Tstring::operator= ( const char* str)
{
     this->Setstring(str);
     return *this;   
}
Tstring &Tstring::operator=(const Tstring & str)
{
     this->Setstring(str.String);
     return *this;      
}
 // Ein Zeichen zuweisen	         
Tstring &Tstring::operator= ( char str)
{
      char ttt[2];
      ttt[0]=str;
      ttt[1]='\0';
      Setstring(ttt);
}
// ASCII-Wert eines Zeichens zuweisen
Tstring &Tstring::operator= ( int)
{

}
//Anfüge Operatoren 
Tstring &Tstring::operator += ( const Tstring & str)
{
        this->Anhaengen(str.String);
        return *this;
} 
Tstring &Tstring::operator += ( const char* str )
{
        this->Anhaengen(str);
        return *this;       
}

hallo habe das alles geschafft aber komme hier nicht weiter bitte um hilfe.

Schon nicht schlecht; schau'n wir mal ...

tiamo schrieb:

#include<iostream>
#include "Tstring.h"
// 1.Konstruktor
Tstring::Tstring()
{
     //Adresse auf Null setzen             
     String = NULL;
     Stringlaenge =0;      
}
//2. Konstruktor
Tstring::Tstring(const char *str)
{
    //Adresse auf NUll setzen                    
    String = NULL;            
    //Setstring aufrufen um den an den K. übergebenen String in das Attribut String zu schreiben       
    Setstring(str);                   
}
//3. Kopierkonstruktor
Tstring::Tstring(Tstring & str)
{
    //Adresse auf NUll setzen                    
    String = NULL;            
    //Setstring aufrufen um den an den K. übergebenen String in das Attribut String zu schreiben       
    Setstring(str.String);                   
}

Nicht so schön ist, dass Du den Namen der String-Klasse und den Namen der Member-Variblen geändert hast - das erschwert auch den Antwortenden die Arbeit. Ich nutze bei meinen Antworten die Namen aus Deinem ersten Posting.
Bei Konstruktoren bitte immer die Initialisierungsliste benutzen. Das sieht so aus

// 1.Konstruktor
CTString::CTString()
    : m_szZeichenkette( 0 )
    , m_nLaenge( 0 )
{}
//2. Konstruktor
CTString::CTString(const char *str)
    : m_szZeichenkette( 0 )
    , m_nLaenge( 0 )
{
    //Setstring aufrufen um den an den K. übergebenen String in das Attribut String zu schreiben       
    Setstring(str);                   
}
//3. Kopierkonstruktor
CTString::CTString( const CTString& str)
    : m_szZeichenkette( 0 )
    , m_nLaenge( 0 )
{
    //Setstring aufrufen um den an den K. übergebenen String in das Attribut String zu schreiben       
    Setstring(str.m_szZeichenkette);                   
}

Den Kopie-Konstruktor immer mit einer const Referenz versehen; das übergebende Objekt wird schließlich dabei nicht verändert.
Bei Setstring musst Du immer die Länge des Strings feststellen, obwohl diese u.U. bereits bekannt ist. Besser wäre

bool CTString::Setstring(const char *str, unsigned int laenge )
{
    // usw..

Die betroffenen Kopierkonstruktoren ändern sich dann zu

//2. Konstruktor
CTString::CTString(const char *str)
    : m_szZeichenkette( 0 )
    , m_nLaenge( 0 )
{
    //Setstring aufrufen um den an den K. übergebenen String in das Attribut String zu schreiben       
    Setstring(str, StrLaenge(str));                   
}
//3. Kopierkonstruktor
CTString::CTString( const CTString& str)
    : m_szZeichenkette( 0 )
    , m_nLaenge( 0 )
{
    //Setstring aufrufen um den an den K. übergebenen String in das Attribut String zu schreiben       
    Setstring(str.m_szZeichenkette,str.m_nLaenge );                   
}

Die Methode 'StrLaenge' sollte übrigens static sein, da sie keine Member benötigt; oder noch besser zu einer loaklen Funktion werden, die nur in TString.cpp vorkommt.

tiamo schrieb:

//Destruktor
Tstring::~Tstring()
{
    free(String);
    Stringlaenge = 0;
}
// Ersatz für die Funktion "strlen"
unsigned int Tstring::AnzahlZeichen(const char *str)
{
         unsigned int len= 0;
         while(str[len] !='\0')
         {
                        len++;
         }
         return len;
}

bool Tstring::Setstring(const char *str)
{
     Stringlaenge = AnzahlZeichen(str);
     //Prüft ob String vorhanden und reserviert den Speicher 
     if (String == NULL)
     {
         String =(char*) malloc ((Stringlaenge +1) * sizeof (char));
     }
     else
     {             
         String =(char*) realloc(String,(Stringlaenge+1) * sizeof (char));
     }
     // Prüft ob Speicher reserviert werden konnte 
     if (String != NULL)
     {
               //Koppiert alle Zeichen inklusive /0
               for(unsigned int i=0;i<=Stringlaenge;i++)
               {
                   String[i]=str[i];                          
               }
               return true;
     }
     else
     {
         return false;
     }
}

Die 'NULL' stammt noch von C und kann in C++ getrost durch eine '0' ersetzt werden. Das gleiche gilt für alloc und free. In C++ wäre das durch new und delete zu ersetzen. Auch für den void-Parameter in leeren Parameter-Listen gilt: der kann in C++ weggelassen werden.

tiamo schrieb:

Tstring &Tstring::operator=(const Tstring & str)
{
     this->Setstring(str.String);
     return *this;      
}

Der Assignment-operator fehlte in Deinem OP; ist aber bitter notwendig

tiamo schrieb:

// ASCII-Wert eines Zeichens zuweisen
Tstring &Tstring::operator= ( int)
{
        
        
}

ich sehe keinen Unterschied zu der Zuweisung eines char's. Also z.B.:

CTString::CTSring& operator=( int c )
{
    return (*this) = char( c );
}

Fehlt jetzt noch was?

Gruß
Werner