3. Hallo bin neu hier und benötige dringend Hilfe

Hallo bin neu hier und benötige dringend Hilfe

  • T

    Hallo erstmal.
    Wir machen in der Schule zur Zeit auch C++.
    Und jetzt haben wir eine Aufgabe bekommen.
    Und zwar soll es im Projekt sein, d.h. das eine CTString.h, CTString.cpp und main.cpp.
    Wir haben die CTString.h bekommen und sollen die CTString.cpp und main.cpp machen.
    Aber ich weiss nicht wo ich anfangen soll. Bitte um hilfe.

    #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* );
};
    0
  • C

    http://tutorial.schornboeck.net/operatoren_ueberladung.htm

    0
  • T

    Ich habe aber ehrlich gesagt nicht so viel davon verstanden was da in dem Link steht 😞 😞 😞

    0
  • C

    hast du in der schule nicht aufgepasst oder WO GENAU IST DEIN PROBLEM MIT DEM CODE?

    0
  • T

    Ehrlich gesagt nicht richtig aufgepasst leider 😞
    Wir müssen damit ein String einlesen und ausgeben. dann an den String etwas hinzufügen.....

    0
  • C

    okay. ich kann dir nicht alles erklaeren, was du zur loesung brauchst, sondern nur bei konkreten problemen helfen.
    fuer die grundlagen kannst du dieses online-tutorial benutzen:
    http://tutorial.schornboeck.net/oop.htm

    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?

    0
  • T

    bis Freitag

    0
  • ?

    75€ VHB 😃
    king-fred@web.de

    0
  • W

    mal ganz einfach angefangen:
    kannst Du die Implementierung von

    int GetLaenge ();

    hinschreiben?

    Fragt
    Werner

    0
  • T

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

    #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;       
}
    0
  • W

    tiamo schrieb:

    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

    0
Anmelden zum Antworten