029
02.06.2005, 13:15 Uhr
Lumina
|
@virtual:
Der operator ist von meinem Prof und der Indexoperator auch, nur nicht in derselben Implementierung. Durchs Debuggen haben wir das festgestellt, dass die beiden sich nicht mögen. Das ist also keine Frage, sondern Aussage. Dafür will ich keine Funktion schreiben.
| C++: |
// Operatoren:
//operator const char* () const { return(str);} // Typkonvertierungsoperator,
// verträgt sich nicht mit Indexoperator!
|
Solche Funktionen wie upper, lower reverse für die char* will ich nicht private machen, weil ich sonst ja nicht z.B. einen einzelnen Großbuchstaben zu nem Kleinbuchstaben oder umgekehrt machen kann. Bei reverse möchte ich ja auch nicht nur einen CString umdrehen können, sondern auch eine normale Zeichenkette.
Den Rest, was die Funktionen machen und was die Namen angeht, siehst du im neuen Header:
Weitere Operatoren sind in Planung.
| C++: |
// Definition der Klasse CString
#ifndef CSTRING_H
#define CSTRING_H
#include <iostream.h>
class CString
{
public:
CString(); // Standardkonstruktor
CString(const char*); // Typumwandlungskonstruktor
CString(const CString&); // Copy-Konstruktor
~CString(); // Destruktor
// Operatoren:
//operator const char* () const { return(str);} // Typkonvertierungs-
// operator; verträgt sich nicht
// mit Indexoperator!
CString& operator=(const CString&); // Zuweisungen
CString& operator=(const char*);
// Konkatenieren zweier Strings
friend CString operator+(const CString&, const CString&);
friend ostream& operator<<(ostream&, const CString&); // Ausgabe
// Indexoperator
char& operator[](unsigned);
// eigene Operatoren:
//*****************************************************************
// werden ergänzt---- in Bearbeitung...
// eigene Methoden:
//*****************************************************************
CString& Rep(unsigned nmal);
int mystrlen(const char*);
int CStringLen();
// Anmerkung: Die Bildung von CStringCat und CStringCpy mit
// mystrcat und mystrcpy ist nicht möglich, weil die temporäre
// Zeichenkette in den Unterfunktionen richtig erstellt würde,
// aber nach deren Verlassen nicht mehr existiert und somit
// bewirkt der Aufruf der Unterfunktionen in CStringCat und
// CStringCpy "nur" Rechenzeit!
void CStringCat(const CString& src); // Hängt alle Zeichen von src an this an.
void CStringCpy(const CString& src); // Kopiert alle Zeichen von src nach this.
int mystrcmp(char* str1, char* str2); // Vergleicht str1 mit str2
int CStringCmp(CString& cstr1, CString& cstr2); // Vergleicht cstr1 mit cstr2
int lower(int); // Macht einen Großbuchstaben klein
void lower(char*); // Macht aus vielen Großbuchstaben Kleinbuchstaben
CString lower(); // Macht aus this mit Großbuchstaben nur Kleinbuchstaben
int upper(int); // Macht einen Kleinbuchstaben groß
void upper(char*); // Macht aus vielen Kleinbuchstaben Großbuchstaben
CString upper(); // Macht aus this mit Kleinbuchstaben nur Großbuchstaben
void reverse(char*); // Kehrt eine Zeichenkette um: "hallo" -> "ollah"
CString reverse(); // Kehrt this um
int mystrindex(const char* s, const char* t); // Liefert Index von t in s, bei Fehlen -1
int CStringIndex(const CString& cstr); // Liefert Index von cstr in this, bei Fehlen -1
int CStringIndex(const char* str); // Liefert Index von str in this, bei Fehlen -1
int mystrrindex(const char* s, const char* t); // Liefert VON RECHTS HER den
// Index von t in s, bei Fehlen -1
int CStringLastIndex(const CString&); // Liefert VON RECHTS HER den Index von
// cstr in this, bei Fehlen -1
int CStringLastIndex(const char*); // Liefert VON RECHTS HER den Index
// von str in this, bei Fehlen -1
void removeSpaces(); // Entfernt alle Leerzeichen aus this
CString trim(); // Entfernt alle Whitespaces am Ende von this
void removeFirst(const char* s); // Entfernt s aus this an erster Fundstelle
void removeLast(const char* s); // Entfernt s aus this an letzter Fundstelle
void removeAll(const char* s); // Entfernt s aus this an allen Fundstellen
CString removeChars(CString& rStr2); // Entfernt aus this alle jedes Zeichen, die
// in rStr2 vorkommen
CString removeChars(const char* chars); // Entfernt aus this alle jedes Zeichen, die
// in chars vorkommen
void replaceFirst(const char* old, const char* news); // Ersetzt old durch news
// an erster Fundstelle
void replaceLast(const char* old, const char* news); // Ersetzt old durch news
// an letzter Fundstelle
void replaceAll(const char* old, const char* news); // Ersetzt old durch news an
// allen Fundstellen
long my_strcspn(CString& rStr2); // Zählt alle Zeichen von this mit Ausnahme
// solcher, die in rStr2 enthalten sind
long my_strcspn(const char* chars); // Zählt alle Zeichen von this mit Ausnahme
// solcher, die in chars enthalten sind
bool startsWith(const char* prefix); // Prüft, ob this mit prefix anfängt
bool endsWith(const char* suffix); // Prütt, ob this mit suffix endet
char& charAt(const unsigned index); // Liefert das Zeichen an der Stelle index
unsigned countAll(const char* s); // Zählt, wie oft s in this vorkommt
CString substring(const unsigned fromIndex, const unsigned toIndex);
// Erzeugt aus this einen neuen
// CString von fromIndex bis toIndex
CString substring(const unsigned fromIndex);
// Erzeugt aus this einen neuen CString
// von fromIndex bis zur Nullterminierung
private:
char* str; // Zeiger auf Stringanfang
unsigned len; // enthaelt Stringlaenge
};
#endif
|
Was soll eigentlich rot13 machen?! und toInt und toDouble sind zwar an sich gute Vorschläge, kommen aber in einem extra Teil in der Prüfung von unserem Prof, also nicht in dieser Klasse. Lass mich einfach weiter von der JAVA-String-Klasse inspirieren...
--
*******************************************
Willst du glücklich sein im Leben, trage bei zu and'rer Glück,
denn die Freude, die wir geben, kehrt ins eig'ne Herz zurück!
*******************************************
Dieser Post wurde am 02.06.2005 um 13:19 Uhr von Lumina editiert. |
