![]() | Patrick's Programming Library Version 6.4.21 - Dokumentation |
String-Klasse mit WideChars im Unicode-Format. Mehr ...
Öffentliche Typen | |
enum | PPLDataType { UNKNOWN =0, CINT =2, CSTRING =4, CASSOCARRAY =5, CBINARY =6, CWSTRING =8, CARRAY =9, CBOOL =10, CDATETIME =11 } |
Enumeration der verschiedenen Datenobjekte, die in der Library verwendet werden. Mehr ... | |
Öffentliche Methoden | |
int | AddChar (wchar_t c) |
Einzelnes Zeichen anfügen. Mehr ... | |
void | Chomp () |
Schneidet Returns und Linefeeds am Anfanng und Ende des Strings ab. Mehr ... | |
void | Chop (int chars=1) |
Schneidet Zeichen am Ende des Strings ab. Mehr ... | |
void | Clear () |
Löscht den Inhalt des Strings. Mehr ... | |
int | ConcatChar (wchar_t c) |
Einzelnes Zeichen anfügen. Mehr ... | |
void | Cut (int position) |
Schneidet den String an einer bestimmten Stelle ab. Mehr ... | |
int | DataType () const |
Liefert den Datentyp des Objekts zurück. Mehr ... | |
int | Delete (int pos, int num) |
Teil des Strings löschen. Mehr ... | |
int | Find (const char *str, int pos) const |
Sucht nach einem String. Mehr ... | |
int | Find (const CWString &search, int pos) const |
Sucht nach einem String. Mehr ... | |
const void * | GetBuffer () const |
Pointer auf die Unicode-Version des Strings holen. Mehr ... | |
wchar_t | GetChar (int pos) const |
Zeichen an einer bestimmten Stelle auslesen. Mehr ... | |
CWString | GetMD5 () const |
const char * | GetPtr () |
Pointer auf die UTF-8-Version des Strings holen. Mehr ... | |
const wchar_t * | GetWPtr () const |
void | HexDump () const |
Macht einen Hexdump des Strings auf STDOUT. Mehr ... | |
void | ImportBuffer (wchar_t *buffer, size_t bytes) |
Externen Buffer übernehmen. Mehr ... | |
int | InsertChar (wchar_t c, int pos) |
Zeichen an einer bestimmten Stelle einfügen. Mehr ... | |
int | Instr (const char *str, int pos=0) const |
int | Instr (const wchar_t *str, int pos=0) const |
int | Instr (const CWString &str, int pos=0) const |
int | Instr (const CString &str, int pos=0) const |
int | IsFalse () const |
Prüft, ob der String "unwahr" ist. Mehr ... | |
int | IsTrue () const |
Prüft, ob der String "wahr" ist. Mehr ... | |
int | IsType (int type) const |
void | LCase () |
Wandelt alle Zeichen des Strings in Kleinbuchstaben um. Mehr ... | |
CWString | Left (int len) const |
void | LTrim () |
Schneidet Leerzeichen, Tabs Returns und Linefeeds am Anfang des Strings ab. Mehr ... | |
void | LTrim (wchar_t c) |
Schneidet das angegebene Zeichen am Anfang des Strings ab. Mehr ... | |
void | LTrim (const char *str) |
Schneidet die definierten Zeichen am Anfang des Strings ab. Mehr ... | |
int | MD5 (CWString &str) |
int | MD5 (const char *str, int size=-1) |
MD5-Summe für einen String errechnen. Mehr ... | |
int | MD5 () |
MD5 Summe für den enthaltenen String errechnen. Mehr ... | |
CWString | Mid (int start, int len=-1) const |
CWString & | operator= (const CBinary &str) |
void | Print (bool attach_newline=false) const |
String auf STDOUT ausgeben. Mehr ... | |
CWString & | Repeat (int num) |
CWString & | Repeat (const char *str, int num) |
CWString & | Repeat (const wchar_t *str, int num) |
CWString & | Repeat (const wchar_t ascii, int num) |
Füllt den String mit einem Zeichen. Mehr ... | |
CWString & | Repeat (const CWString &str, int num) |
CWString & | Repeat (const CString &str, int num) |
CWString & | Replace (const char *str, const char *byStr) |
Ersetzt einen Teilstring durch einen anderen. Mehr ... | |
CWString & | Replace (const CWString &str, const CWString &byStr) |
Ersetzt einen Teilstring durch einen anderen. Mehr ... | |
CWString & | ReplaceLetterList (const CWString &letters, wchar_t replacement) |
int | Reserve (int chars) |
Reserviert Speicher für den String. Mehr ... | |
CWString | Right (int len) const |
void | RTrim () |
Schneidet Leerzeichen, Tabs Returns und Linefeeds am Ende des Strings ab. Mehr ... | |
void | RTrim (wchar_t c) |
Schneidet das angegebene Zeichen am Ende des Strings ab. Mehr ... | |
void | RTrim (const char *str) |
Schneidet die definierten Zeichen am Ende des Strings ab. Mehr ... | |
int | SetChar (wchar_t c) |
String mit einem einzelnen Wide-Character belegen. Mehr ... | |
int | SetChar (wchar_t c, int pos) |
Einzelnes Zeichen an einer bestimmten Position überschreiben. Mehr ... | |
int | SetExtEncoding (const char *encoding) |
Encoding für Stringübergabe festlegen. Mehr ... | |
void | Shl (wchar_t c, int size) |
Schiebt den String nach links. Mehr ... | |
void | Shr (wchar_t c, int size) |
Schiebt den String nach rechts. Mehr ... | |
int | StrCaseCmp (const char *str, int size=0) const |
Führt einen Vergleich mit einem anderen String durch, wobei Gross-/Kleinschreibung ignoriert wird. Mehr ... | |
int | StrCaseCmp (const wchar_t *str, int size=0) const |
Führt einen Vergleich mit einem anderen String durch, wobei Gross-/Kleinschreibung ignoriert wird. Mehr ... | |
int | StrCaseCmp (const CString &str, int size=0) const |
Führt einen Vergleich mit einem anderen String durch, wobei Gross-/Kleinschreibung ignoriert wird. Mehr ... | |
int | StrCaseCmp (const CWString &str, int size=0) const |
Führt einen Vergleich mit einem anderen String durch, wobei Gross-/Kleinschreibung ignoriert wird. Mehr ... | |
int | StrCmp (const char *str, int size=0) const |
Führt einen Vergleich mit einem anderen String durch. Mehr ... | |
int | StrCmp (const wchar_t *str, int size=0) const |
Führt einen Vergleich mit einem anderen String durch. Mehr ... | |
int | StrCmp (const CString &str, int size=0) const |
Führt einen Vergleich mit einem anderen String durch. Mehr ... | |
int | StrCmp (const CWString &str, int size=0) const |
Führt einen Vergleich mit einem anderen String durch. Mehr ... | |
void | StripSlashes () |
CWString | SubStr (int start, int len=-1) const |
bool | ToBool () const |
CBinary | ToCBinary () const |
CString | ToCString () const |
double | ToDouble () const |
float | ToFloat () const |
int | ToInt () const |
pplint64 | ToInt64 () const |
long | ToLong () const |
long long | ToLongLong () const |
ppluint32 | ToUInt () const |
ppluint64 | ToUInt64 () const |
void | Trim () |
Schneidet Leerzeichen, Tabs Returns und Linefeeds am Anfang und Ende des Strings ab. Mehr ... | |
void | Trim (wchar_t c) |
Schneidet das angegebene Zeichen am Anfang und Ende des Strings ab. Mehr ... | |
void | Trim (const char *str) |
Schneidet bestimmte Zeichen am Anfang und Ende des Strings ab. Mehr ... | |
void | TrimL (int chars) |
void | TrimR (int chars) |
void | UCase () |
Wandelt alle Zeichen des Strings in Grossbuchstaben um. Mehr ... | |
void | UCWords () |
Anfangsbuchstaben der Wörter groß Mehr ... | |
Konstruktoren | |
Folgende Konstruktoren stehen zur Verfügung: | |
CWString () | |
Konstruktor: Leeren String erzeugen. Mehr ... | |
CWString (const char *str) | |
Konstruktor: String aus einem "const char *" erstellen. Mehr ... | |
CWString (const wchar_t *str) | |
Konstruktor: String aus einem "const wchar_t *" erstellen. Mehr ... | |
CWString (const CString *str) | |
Konstruktor der String-Klasse. Mehr ... | |
CWString (const CString &str) | |
Konstruktor der String-Klasse. Mehr ... | |
CWString (const CWString *str) | |
Konstruktor der String-Klasse. Mehr ... | |
CWString (const CWString &str) | |
Konstruktor der String-Klasse. Mehr ... | |
CWString (const std::wstring &str) | |
CWString (const wchar_t c) | |
Konstruktor der String-Klasse. Mehr ... | |
Destruktor | |
~CWString () | |
Destruktor der String-Klasse. Mehr ... | |
String Informationen | |
size_t | Size () const |
Gibt die Anzahl Bytes zurück, die durch den String belegt werden. Mehr ... | |
size_t | Length () const |
Gibt die Länge des Strings zurück. Mehr ... | |
size_t | Len () const |
Gibt die Länge des Strings zurück. Mehr ... | |
int | IsNumeric () const |
Prüft, ob der String nummerisch ist. Mehr ... | |
int | IsInteger () const |
Prüft, ob der String einen Integer Wert enthält. Mehr ... | |
int | IsEmpty () const |
Prüft, ob der String leer ist. Mehr ... | |
int | NotEmpty () const |
Prüft, ob der String Daten enthält. Mehr ... | |
int | Capacity () const |
Maximale Stringgröße ohne neuen Speicher zu allokieren. Mehr ... | |
Daten setzen | |
Mit folgenden Funktionen wird der String mit Daten belegt | |
void | HexDump (const void *buffer, int bytes, bool skipheader=false) |
Hexdump eines Speicherbereichs im String ablegen. Mehr ... | |
int | Set (const char *text, int size=-1) |
Belegt den String mit einem 0-terminierten UTF-8 String. Mehr ... | |
int | Set (const wchar_t *text, int size=-1) |
Belegt den String mit einem Wide-Character Wert. Mehr ... | |
int | Set (const CString *str, int size=-1) |
Belegt den String mit dem Inhalt eines CString. Mehr ... | |
int | Set (const CString &str, int size=-1) |
Belegt den String mit dem Inhalt eines CString. Mehr ... | |
int | Set (const CWString *str, int chars=-1) |
Belegt den String mit dem Inhalt eines anderen CWString. Mehr ... | |
int | Set (const CWString &str, int chars=-1) |
Belegt den String mit dem Inhalt eines anderen CWString. Mehr ... | |
int | Setf (const char *fmt,...) |
Erzeugt einen formatierten String. Mehr ... | |
int | Setf (const wchar_t *fmt,...) |
Erzeugt einen formatierten String. Mehr ... | |
int | Sprintf (const char *fmt,...) |
Erzeugt einen formatierten String. Mehr ... | |
int | VaSprintf (const char *fmt, va_list args) |
Erzeugt einen formatierten String. Mehr ... | |
int | Vasprintf (const char *fmt, va_list args) |
Erzeugt einen formatierten String. Mehr ... | |
int | Strcpy (const char *str) |
Belegt den String mit einem 0-terminierten C-String. Mehr ... | |
int | Strncpy (const char *str, int size) |
Belegt den String mit einem 0-terminierten UTF-8 String. Mehr ... | |
int | Copy (const char *str, int size=-1) |
Belegt den String mit einem 0-terminierten UTF-8 String. Mehr ... | |
int | Copy (const CString &str, int size=-1) |
Belegt den String mit dem Inhalt eines CString. Mehr ... | |
int | Import (const char *encoding, void *buffer, int bytes=-1) |
Importiert einen String der im angegebenen Charset vorliegt. Mehr ... | |
String verlängern | |
int | Add (const char *str, int size=-1) |
UTF-8-String anhängen. Mehr ... | |
int | Concat (const char *text, int size=-1) |
Fügt einen String an das Ende des vorhandenen an. Mehr ... | |
int | Concat (const wchar_t *text, int size=-1) |
Fügt einen Wide-Character String an den bestehenden an. Mehr ... | |
int | Concat (CString *str, int size=-1) |
Fügt einen String an das Ende des vorhandenen an. Mehr ... | |
int | Concat (CWString *str, int size=-1) |
Fügt einen String an das Ende des vorhandenen an. Mehr ... | |
int | Concat (CString str, int size=-1) |
Fügt einen String an das Ende des vorhandenen an. Mehr ... | |
int | Concat (CWString str, int size=-1) |
Fügt einen String an das Ende des vorhandenen an. Mehr ... | |
int | Concatf (const char *fmt,...) |
Fügt einen formatierten String an das Ende des vorhandenen an. Mehr ... | |
int | Concatf (const wchar_t *fmt,...) |
Fügt einen formatierten String an das Ende des vorhandenen an. Mehr ... | |
Operatoren | |
operator const char * () | |
Liefert einen const char-Pointer auf die UTF-8-Version des String zurück. Mehr ... | |
operator const wchar_t * () const | |
Liefert einen const wchar_t-Pointer auf die Unicode-Version des String zurück. Mehr ... | |
wchar_t | operator[] (int pos) |
Zeichen an einer bestimmten Stelle auslesen. Mehr ... | |
CWString & | operator= (char *str) |
CWString & | operator= (const char *str) |
CWString & | operator= (const CWString &str) |
CWString & | operator= (const CWString *str) |
CWString & | operator= (const CString &str) |
CWString & | operator= (const CString *str) |
CWString & | operator= (const wchar_t c) |
Unicode-Zeichen zuweisen. Mehr ... | |
CWString & | operator= (const wchar_t *str) |
CWString & | operator+= (const char *str) |
CWString & | operator+= (const wchar_t *str) |
CWString & | operator+= (const wchar_t c) |
CWString & | operator+= (const CWString &str) |
CWString & | operator+= (const CString &str) |
bool | operator< (const CWString &str) const |
bool | operator<= (const CWString &str) const |
bool | operator== (const CWString &str) const |
bool | operator!= (const CWString &str) const |
bool | operator>= (const CWString &str) const |
bool | operator> (const CWString &str) const |
operator int () const | |
Liefert den Integer-Wert des Strings zurück. Mehr ... | |
operator unsigned int () const | |
Liefert den Integer-Wert des Strings zurück. Mehr ... | |
Regular Expressions | |
void | PregEscape () |
Fügt dem String Escape-Zeichen zu, zur Verwendung in einem Match. Mehr ... | |
int | PregMatch (const char *expression, CArray *res=NULL) |
Der String wird anhand einer Regular Expression durchsucht. Mehr ... | |
const char * | GetMatch (int index) const |
int | PregReplace (const char *expression, const char *replace, int maxreplace=0) |
Es wird ein Suchen und Ersetzen anhand einer Regular Expression durchgeführt. Mehr ... | |
int | PregReplace (const char *expression, CString &replace, int maxreplace=0) |
Es wird ein Suchen und Ersetzen anhand einer Regular Expression durchgeführt. Mehr ... | |
int | PregReplace (const char *expression, CWString &replace, int maxreplace=0) |
Es wird ein Suchen und Ersetzen anhand einer Regular Expression durchgeführt. Mehr ... | |
Geschützte Attribute | |
ppluint8 | type |
Private Methoden | |
void | Init () |
Interne Funktion: Initialisierung des Strings. Mehr ... | |
int | InitExportEncoding (const char *encoding) |
Encoding für Export einstellen. Mehr ... | |
int | InitImportEncoding (const char *encoding) |
Encoding für Import einstellen. Mehr ... | |
void | ReCalcLen () |
Private Attribute | |
wchar_t * | buffer |
size_t | buffersize |
size_t | bufferused |
char * | extbuffer |
size_t | extbuffersize |
char | extencoding [32] |
void * | iconvexport |
void * | iconvimport |
size_t | len |
CArray * | matches |
Diese Klasse bietet die gleiche Funktionalität, wie die ppl6::CString -Klasse, verwaltet Ihre Daten aber nicht in als Multibyte-Zeichen in der UTF-8 Kodierung, sondern als Wide-Characters in Unicode-Kodierung. Mit Ihr lassen sich daher problemlos alle Zeichen der Welt verarbeiten.
Unter Windows sind Wide-Characters 16 Bit breit, unter Unix in der Regel 32 Bit.
Für den Im- und Export von anderen Kodierungen wird die ICONV-Library verwendet.
|
inherited |
Enumeration der verschiedenen Datenobjekte, die in der Library verwendet werden
Aufzählungswerte | |
---|---|
UNKNOWN |
Unbekannter Datentyp. |
CINT |
Klasse vom Typ CInt. |
CSTRING |
Klasse vom Typ CString. |
CASSOCARRAY |
Klasse vom Typ CAssocArray. |
CBINARY |
Klasse vom Typ CBinary. |
CWSTRING |
Klasse vom Typ CWString. |
CARRAY |
Klasse vom Typ CArray. |
CBOOL |
Klasse vom Typ CBool. |
CDATETIME |
Klasse vom Typ CDateTime. |
ppl6::CWString::CWString | ( | ) |
Erzeugt einen Leeren String
ppl6::CWString::CWString | ( | const char * | str | ) |
Erzeugt einen neuen String mit dem Inhalt von str
str | ist ein const char * auf einen 0-terminierten String im UTF-8-Format. |
ppl6::CWString::CWString | ( | const wchar_t * | str | ) |
Erzeugt einen neuen String mit dem Inhalt von str
str | ist ein const wchar_t * auf einen 0-terminierten String im Wide-Character Format (Unicode). |
ppl6::CWString::CWString | ( | const CString * | str | ) |
Erzeugt einen neuen String mit dem Inhalt von str
str | ist ein Pointer auf eine andere String-Klasse. |
ppl6::CWString::CWString | ( | const CString & | str | ) |
Erzeugt einen neuen String mit dem Inhalt von str
str | ist eine andere Instanz der String-Klasse. |
ppl6::CWString::CWString | ( | const CWString * | str | ) |
Erzeugt einen neuen String mit dem Inhalt von str
str | ist ein Pointer auf eine andere String-Klasse. |
ppl6::CWString::CWString | ( | const CWString & | str | ) |
Erzeugt einen neuen String mit dem Inhalt von str
str | ist eine andere Instanz der String-Klasse. |
ppl6::CWString::CWString | ( | const std::wstring & | str | ) |
ppl6::CWString::CWString | ( | const wchar_t | c | ) |
Erzeugt einen neuen String mit dem Inhalt des angegebenen Zeichens c
c | ist der Unicode des gewünschten Zeichens |
ppl6::CWString::~CWString | ( | ) |
Der Destruktor gibt alle von dieser Instanz verwendeten Speicherbereiche wieder frei.
int ppl6::CWString::Add | ( | const char * | str, |
int | size = -1 |
||
) |
Mit dieser Funktion der übergebene String an den bereits vorhandenen angehangen
[in] | str | Ein Pointer auf einen 0-terminierten C-String im UTF-8-Format |
[in] | size | Optionaler Parameter, der die Anzahl zu importierender Zeichen angibt. Ist der Wert nicht angegeben, wird der komplette String übernommen. Ist der Wert größer als der angegebene String, wird er ignoriert und der komplette String importiert. |
int ppl6::CWString::AddChar | ( | wchar_t | c | ) |
Mit dieser Funktion wird ein einzelnes Zeichen an den String angefügt.
[in] | c | Unicode des gewünschten Zeichens |
int ppl6::CWString::Capacity | ( | ) | const |
Mit dieser Funktion kann man feststellen, wieviele Zeichen der String maximal groß werden darf, ohne dass neuer Speicher allokiert werden muss.
void ppl6::CWString::Chomp | ( | ) |
void ppl6::CWString::Chop | ( | int | chars = 1 | ) |
void ppl6::CWString::Clear | ( | ) |
Der Inhalt des Strings wird gelöscht und seine Länge auf 0 gesetzt. Außerden werden alle belegten Speicherblöcke freigegeben.
int ppl6::CWString::Concat | ( | const char * | text, |
int | size = -1 |
||
) |
int ppl6::CWString::Concat | ( | const wchar_t * | text, |
int | size = -1 |
||
) |
[in] | text | Pointer auf einen Wide-Character String |
[in] | size | Die Anzahl Zeichen (nicht Bytes) im String, die kopiert werden sollen. |
int ppl6::CWString::Concat | ( | CString * | str, |
int | size = -1 |
||
) |
int ppl6::CWString::Concat | ( | CWString * | str, |
int | size = -1 |
||
) |
int ppl6::CWString::Concat | ( | CString | str, |
int | size = -1 |
||
) |
int ppl6::CWString::Concat | ( | CWString | str, |
int | size = -1 |
||
) |
int ppl6::CWString::ConcatChar | ( | wchar_t | c | ) |
Mit dieser Funktion wird ein einzelnes Zeichen an den String angefügt.
[in] | c | Unicode des gewünschten Zeichens |
int ppl6::CWString::Concatf | ( | const char * | fmt, |
... | |||
) |
int ppl6::CWString::Concatf | ( | const wchar_t * | fmt, |
... | |||
) |
int ppl6::CWString::Copy | ( | const char * | str, |
int | size = -1 |
||
) |
Mit dieser Funktion wird dem String ein Wert zugewiesen.
[in] | str | Ein Pointer auf einen UTF-8 kodierten C-String, der in die String-Klasse kopiert werden soll. |
[in] | size | Optionaler Parameter, der die Anzahl zu importierender Zeichen angibt. Ist der Wert nicht angegeben, wird der komplette String übernommen. Ist der Wert größer als der angegebene String, wird er ignoriert und der komplette String importiert. |
int ppl6::CWString::Copy | ( | const CString & | str, |
int | size = -1 |
||
) |
Mit dieser Funktion wird dem String ein Wert zugewiesen.
[in] | str | Ein Pointer auf eine CString-Klasse |
[in] | size | Optionaler Parameter, der die Anzahl zu importierender Zeichen angibt. Ist der Wert nicht angegeben, wird der komplette String übernommen. Ist der Wert größer als der angegebene String, wird er ignoriert und der komplette String importiert. |
void ppl6::CWString::Cut | ( | int | position | ) |
Der String wird an einer bestimmten Stelle einfach abgeschnitten
position | Die Position, an der der String abgeschnitten wird. Bei Angabe von 0 ist der String anschließend komplett leer. Ist position größer als die Länge des Strings, passiert nichts. |
|
inherited |
Diese Funktion liefert den Datentyp des Objekts zurück.
int ppl6::CWString::Delete | ( | int | pos, |
int | num | ||
) |
Mit dieser Funktion kann man einen beliebig langen Teil des Strings ab einer gewünschten Position löschen. Alle Zeichen rechts davon werden nach links verschoben.
[in] | pos | Startposition, ab der gelöscht werden soll |
[in] | num | Anzahl Zeichen, die gelöscht werden sollen |
int ppl6::CWString::Find | ( | const char * | str, |
int | pos | ||
) | const |
Find sucht nach dem Suchstring str ab der gewünschten Position pos.
int ppl6::CWString::Find | ( | const CWString & | search, |
int | pos | ||
) | const |
Find sucht nach dem Suchstring str ab der gewünschten Position pos.
const void * ppl6::CWString::GetBuffer | ( | ) | const |
Diese Funktion liefert einen Pointer auf die Unicode-Rohdaten zurück.
wchar_t ppl6::CWString::GetChar | ( | int | pos | ) | const |
Mit dieser Funktion kann ein einzelnes Zeichen an einer bestimmten Stelle des Strings ausgelesen werden.
pos | Position innerhalb des String beginnend bei 0. Bei negativen Werten wird die Position vom Ende des Strings berechnet. Ein Wert von -1 würde daher das letzte Zeichen des Strings zurückliefern. |
pos
vorhanden, wird dessen Unicode-Wert zurückgeliefert. Ist das Zeichen nicht im String enthalten, wird 0 zurückgegeben. const char * ppl6::CWString::GetMatch | ( | int | index | ) | const |
Liefert mit PregMatch gefundene Ergebnisse zurück
index | ist ein Index auf die Ergebnisse. 0 liefert immer den kompletten String zurück, 1 den ersten Match, 2 den zweiten usw. |
CWString ppl6::CWString::GetMD5 | ( | ) | const |
const char * ppl6::CWString::GetPtr | ( | ) |
Diese Funktion wandelt den aktuellen String in eine UTF-8-Version um und liefert einen Pointer darauf zurück. Der Speicherbereich des Strings wird von der Klasse selbst verwaltet und darf von der Anwendung weder verändert noch freigegeben werden.
Für die UTF-8-Version wird ein eigener Speicherblock reserviert, der von der Klasse selbst verwaltet wird. Er wird automatisch gelöscht, wenn die Klasse gelöscht wird.
Verändert sich der Inhalt des Wide-Strings, wird die UTF-8-Version nicht automatisch angepaßt. Erst bei einem erneuten Aufruf von CWString::GetPtr wird der String erneut umgerechnet.
const wchar_t * ppl6::CWString::GetWPtr | ( | ) | const |
void ppl6::CWString::HexDump | ( | ) | const |
Der Inhalt des aktuellen Strings wird als HexDump auf STDOUT ausgegeben.
void ppl6::CWString::HexDump | ( | const void * | buffer, |
int | bytes, | ||
bool | skipheader = false |
||
) |
Diese Funktion speichert den HexDump des angegebenen Speicherbereichs im String.
[in] | buffer | Pointer auf den Beginn des Speicherbereichs, der gedumpt werden soll |
[in] | bytes | Anzahl Bytes, die gedumpt werden sollen |
[in] | skipheader | Optionaler Schalter, der angibt, ob vor dem Dump ein Header ausgegeben werden soll (Default=false) |
int ppl6::CWString::Import | ( | const char * | encoding, |
void * | buffer, | ||
int | bytes = -1 |
||
) |
Diese Funktion importiert einen String, der in einem beliebigen Charset vorliegt.
encoding | Name der Kodierung, in der der zu importierende String vorliegt (z.B. "ISO-8859-15") |
buffer | Pointer auf den Speicherbereich, an dem der zu importierende String beginnt. Sofern der Parameter len nicht angegeben wurde, muss dieser mit einem 0-Byte enden |
bytes | Optionaler Parameter, der die Länge des Strings in Byte angibt |
void ppl6::CWString::ImportBuffer | ( | wchar_t * | buffer, |
size_t | bytes | ||
) |
Mit dieser Funktion kann ein externer Buffer in den String übernommen werden. Dazu muss die Anwendung zunächst Speicher mit malloc
allokieren und diesen mit einem gültigen Wide Character String versehen. Dieser muss mit einem 0-Wert enden. Der Pointer auf den Beginn des Speichers und die allokierte Größe wird dann mit dieser Funktion in den String importiert. Die Verwaltung des Speicherblocks geht dabei an die Stringklasse über, darf also nicht mehr von der Anwendung verändert oder gelöscht werden!
Danach prüft die Funktion noch die tatsächliche Länge des Strings durch Aufruf der Funktion ReCalcLen, für den Fall dass mehr Speicher allokiert wurde, als tatsächlich gebraucht wurde.
Falls der String vor Aufruf dieser Funktion noch Daten enthalten hat, werden diese ordnungsgemäß gelöscht.
[in] | buffer | Pointer auf den Speicherbereich, ab dem der String beginnt |
[in] | bytes | Anzahl Bytes, die beim malloc allokiert wurden. Dies muss zwingend ein Vielfaches von sizeof(wchar_t) sein! |
|
private |
Diese Funktion wird intern von den Konstruktoren aufgerufen, um alle internen Variablen und Puffer auf NULL zu setzen
|
private |
Diese Funktion wird intern aufgerufen, um die iconv-Funktion für den Export von UTF-8 Strings zu initialisieren.
|
private |
Diese Funktion wird intern aufgerufen, um die iconv-Funktion für den Import von UTF-8 Strings zu initialisieren.
int ppl6::CWString::InsertChar | ( | wchar_t | c, |
int | pos | ||
) |
Diese Funktion fügt ein einzelnes Zeichen an einer bestimmten Position des Strings ein. Alle Zeichen rechts davon werden dabei um eine Position nach rechts verschoben.
[in] | c | Unicode des gewünschten Zeichens |
[in] | pos | Position an der das Zeichen eingefügt werden soll. Ist der Wert negativ, wird die Position vom Ende des Strings berechnet. -1 wäre dabei das letzte Zeichen des Strings. Eine besondere Behandlung wird durchgeführt, wenn pos mit der Länge des Strings übereinstimmt. In diesem Fall wird die Funktion CWString::AddChar aufgerufen und das Zeichen am Ende angehangen. |
int ppl6::CWString::Instr | ( | const char * | str, |
int | pos = 0 |
||
) | const |
int ppl6::CWString::Instr | ( | const wchar_t * | str, |
int | pos = 0 |
||
) | const |
int ppl6::CWString::Instr | ( | const CWString & | str, |
int | pos = 0 |
||
) | const |
int ppl6::CWString::Instr | ( | const CString & | str, |
int | pos = 0 |
||
) | const |
int ppl6::CWString::IsEmpty | ( | ) | const |
Diese Funktion prüft, ob der String Zeichen enthält
int ppl6::CWString::IsFalse | ( | ) | const |
Diese Funktion überprüft den aktuellen String, ob er "unwahr" ist. Dies ist der Fall, wenn eine der folgenden Bedingungen erfüllt ist:
int ppl6::CWString::IsInteger | ( | ) | const |
int ppl6::CWString::IsNumeric | ( | ) | const |
int ppl6::CWString::IsTrue | ( | ) | const |
Diese Funktion überprüft den aktuellen String, ob er "wahr" ist. Dies ist der Fall, wenn eine der folgenden Bedingungen erfüllt ist:
|
inherited |
void ppl6::CWString::LCase | ( | ) |
Diese Funktion wandelt alle Zeichen des Strings in Kleinbuchstaben um. Die genaue Funktionsweise hängt davon ab, welche Spracheinstellungen aktiv sind, genauer vom Wert "LC_CTYPE".
CWString ppl6::CWString::Left | ( | int | len | ) | const |
size_t ppl6::CWString::Len | ( | ) | const |
Diese Funktion gibt die Anzahl Zeichen zurück, die im String enthalten sind.
size_t ppl6::CWString::Length | ( | ) | const |
Diese Funktion gibt die Anzahl Zeichen zurück, die im String enthalten sind.
void ppl6::CWString::LTrim | ( | ) |
void ppl6::CWString::LTrim | ( | wchar_t | c | ) |
void ppl6::CWString::LTrim | ( | const char * | str | ) |
int ppl6::CWString::MD5 | ( | CWString & | str | ) |
int ppl6::CWString::MD5 | ( | const char * | str, |
int | size = -1 |
||
) |
Errechnet die MD5-Summe für den angegebenen String
str | Pointer auf einen String. Dieser muss mit einem 0-Byte enden, sofern der Parameter size nicht angegeben wurde |
size | Optionaler Parameter, der die Größe des Strings in Bytes angibt. |
wchar_t
(Unicode) vor, sondern nimmt den String so wie er ist int ppl6::CWString::MD5 | ( | ) |
Diese Funktion berechnet die MD5-Summe für den enthaltenen String und speichert das Ergebnis als neuen String-Wert
CWString ppl6::CWString::Mid | ( | int | start, |
int | len = -1 |
||
) | const |
int ppl6::CWString::NotEmpty | ( | ) | const |
Diese Funktion prüft, ob der String Zeichen enthält
ppl6::CWString::operator const char * | ( | ) |
Pointer auf die UTF-8-Version des Strings holen. Diese Funktion wandelt den aktuellen String in eine UTF-8-Version um und liefert einen Pointer darauf zurück. Der Speicherbereich des Strings wird von der Klasse selbst verwaltet und darf von der Anwendung weder verändert noch freigegeben werden.
Für die UTF-8-Version wird ein eigener Speicherblock reserviert, der von der Klasse selbst verwaltet wird. Er wird automatisch gelöscht, wenn die Klasse gelöscht wird.
Verändert sich der Inhalt des Wide-Strings, wird die UTF-8-Version nicht automatisch angepaßt. Erst bei einem erneuten Aufruf von CWString::GetPtr wird der String erneut umgerechnet.
ppl6::CWString::operator const wchar_t * | ( | ) | const |
ppl6::CWString::operator int | ( | ) | const |
ppl6::CWString::operator unsigned int | ( | ) | const |
bool ppl6::CWString::operator!= | ( | const CWString & | str | ) | const |
CWString & ppl6::CWString::operator+= | ( | const char * | str | ) |
CWString & ppl6::CWString::operator+= | ( | const wchar_t * | str | ) |
CWString & ppl6::CWString::operator+= | ( | const wchar_t | c | ) |
bool ppl6::CWString::operator< | ( | const CWString & | str | ) | const |
bool ppl6::CWString::operator<= | ( | const CWString & | str | ) | const |
CWString & ppl6::CWString::operator= | ( | char * | str | ) |
CWString & ppl6::CWString::operator= | ( | const char * | str | ) |
CWString & ppl6::CWString::operator= | ( | const wchar_t | c | ) |
Der String wird mit dem angegebenen Zeichen belegt
.
c | ist der Unicode des gewünschten Zeichens |
CWString & ppl6::CWString::operator= | ( | const wchar_t * | str | ) |
bool ppl6::CWString::operator== | ( | const CWString & | str | ) | const |
bool ppl6::CWString::operator> | ( | const CWString & | str | ) | const |
bool ppl6::CWString::operator>= | ( | const CWString & | str | ) | const |
wchar_t ppl6::CWString::operator[] | ( | int | pos | ) |
Mit diesem Operator kann ein einzelnes Zeichen an einer bestimmten Stelle des Strings ausgelesen werden.
pos | Position innerhalb des String beginnend bei 0. Bei negativen Werten wird die Position vom Ende des Strings berechnet. Ein Wert von -1 würde daher das letzte Zeichen des Strings zurückliefern. |
pos
vorhanden, wird dessen Unicode-Wert zurückgeliefert. Ist das Zeichen nicht im String enthalten, wird 0 zurückgegeben. void ppl6::CWString::PregEscape | ( | ) |
Der Befehl scannt den String nach Zeichen mit besonderer Bedeutung in einer Perl-Regular-Expression und escaped sie mit einem Slash. Das Ergebnis kann dann in einer Regular Expression verwendet werden.
Folgende Zeichen werden escaped: - + \ * /
int ppl6::CWString::PregMatch | ( | const char * | expr, |
CArray * | res = NULL |
||
) |
Durchsucht den String anhand einer Perl-Expression
[in] | expr | Ist eine Perl-kompatible Regular Expression im UTF-8-Format, die mit Slash (/) beginnt und endet. Optional können nach dem schließenden Slash folgende Optionen angegeben werden: |
i
caselessm
multilinex
extendeds
dotall8
UTF8a
anchoredu
ungreedy[out] | res | ist ein Optionales Array, in dem die gefundenen Matches gespeichert werden. Wird res nicht angegeben, werden die Ergebnisse intern gespeichert und können mit der Funktion GetMatch ausgelesen werden. Die Ergebnisse werden im Array im UTF-8-Format abgelegt. |
true(1)
zurück, wenn ein Match gefunden wurde, ansonsten false(0)
int ppl6::CWString::PregReplace | ( | const char * | expr, |
const char * | replace, | ||
int | maxreplace = 0 |
||
) |
expr | is a perl compatible regular expression, starting and ending with slash (/). |
i
caselessm
multilinex
extendeds
dotall8
UTF8a
anchoredu
ungreedyreplace | ist ein Pointer auf eine Stringklasse, die den Text enthält, der anstelle des Matches eingesetzt wird. Werden in der Expression Klammern zum capturen verwendet, können diese Werte mit $1 bis $9 im Replace-String verwendet werden. |
maxreplace | ist optional. Wenn vorhanden, werden nur soviele Matches ersetzt, wi mit maxreplace angegeben. Wurden zum Beispiel 10 Matches gefunden, aber maxreplace wurde mit 5 angegeben, werden nur die ersten 5 Matches ersetzt. |
true(1)
zurück, wenn ein Match gefunden wurde, ansonsten false(0)
int ppl6::CWString::PregReplace | ( | const char * | expr, |
CString & | replace, | ||
int | maxreplace = 0 |
||
) |
[in] | expr | is a perl compatible regular expression, starting and ending with slash (/). |
i
caselessm
multilinex
extendeds
dotall8
UTF8a
anchoredu
ungreedy[in] | replace | ist ein Pointer auf eine Stringklasse, die den Text enthält, der anstelle des Matches eingesetzt wird. Werden in der Expression Klammern zum capturen verwendet, können diese Werte mit $1 bis $9 im Replace-String verwendet werden. |
[in] | maxreplace | ist optional. Wenn vorhanden, werden nur soviele Matches ersetzt, wi mit maxreplace angegeben. Wurden zum Beispiel 10 Matches gefunden, aber maxreplace wurde mit 5 angegeben, werden nur die ersten 5 Matches ersetzt. |
true(1)
zurück, wenn ein Match gefunden wurde, ansonsten false(0)
int ppl6::CWString::PregReplace | ( | const char * | expr, |
CWString & | replace, | ||
int | maxreplace = 0 |
||
) |
[in] | expr | is a perl compatible regular expression, starting and ending with slash (/). |
i
caselessm
multilinex
extendeds
dotall8
UTF8a
anchoredu
ungreedy[in] | replace | ist ein Pointer auf eine Stringklasse, die den Text enthält, der anstelle des Matches eingesetzt wird. Werden in der Expression Klammern zum capturen verwendet, können diese Werte mit $1 bis $9 im Replace-String verwendet werden. |
[in] | maxreplace | ist optional. Wenn vorhanden, werden nur soviele Matches ersetzt, wi mit maxreplace angegeben. Wurden zum Beispiel 10 Matches gefunden, aber maxreplace wurde mit 5 angegeben, werden nur die ersten 5 Matches ersetzt. |
true(1)
zurück, wenn ein Match gefunden wurde, ansonsten false(0)
void ppl6::CWString::Print | ( | bool | attach_newline = false | ) | const |
Diese Funktion gibt den aktuellen String auf STDOUT aus. Dazu ist es notwendig den String vom internen Unicode-Format in das Encoding des Betriebssystems umzurechnen. Da dieses von den lokalen Einstellungen des Betriebssystems und des Users abhängig ist, wird die Environment-Variable "LANG" ausgewertet. Ist diese nicht gesetzt oder enthält ein unbekanntes Encoding, wird der String immer in UTF-8 ausgegeben.
attach_newline | Ein optionaler Parameter, der angibt, ob nach der Ausgabe ein Zeilenumbruch angehangen werden soll (default=false) |
|
private |
CWString & ppl6::CWString::Repeat | ( | int | num | ) |
CWString & ppl6::CWString::Repeat | ( | const char * | str, |
int | num | ||
) |
CWString & ppl6::CWString::Repeat | ( | const wchar_t * | str, |
int | num | ||
) |
CWString & ppl6::CWString::Repeat | ( | const wchar_t | ascii, |
int | num | ||
) |
Der String wird mit einem gewünschten Zeichen gefüllt
ascii | Der ASCII-Code des Zeichens, mit dem der String gefüllt werden soll |
num | Die Länge des gewünschten Strings |
CWString & ppl6::CWString::Replace | ( | const char * | str, |
const char * | byStr | ||
) |
int ppl6::CWString::Reserve | ( | int | chars | ) |
Reserviert Speicher fuer den String. Ein eventuell schon vorhandener String geht dabei nicht verloren. Wenn ein größerer String aus vielen kleinen Einzelteilen zusammengesetzt werden soll, bringt der Aufruf dieser Funktion einen kleinen Performance-Vorteil, da nicht so häufig (im Idealfall garnicht) Speicher neu allokiert werden muß.
[in] | chars | Anzahl Zeichen, für die Speicher allokiert werden soll. |
Ist der Puffer des Strings bereits größer wie gewünscht, bleibt der Puffer unverändert.
CWString ppl6::CWString::Right | ( | int | len | ) | const |
void ppl6::CWString::RTrim | ( | ) |
void ppl6::CWString::RTrim | ( | wchar_t | c | ) |
void ppl6::CWString::RTrim | ( | const char * | str | ) |
int ppl6::CWString::Set | ( | const char * | text, |
int | size = -1 |
||
) |
Mit Set wird dem String ein Wert zugewiesen.
[in] | text | Ein Pointer auf einen UTF-8 kodierten C-String, der in die String-Klasse kopiert werden soll. |
[in] | size | Optionaler Parameter, der die Anzahl zu importierender Zeichen angibt. Ist der Wert nicht angegeben, wird der komplette String übernommen. Ist der Wert größer als der angegebene String, wird er ignoriert und der komplette String importiert. |
int ppl6::CWString::Set | ( | const wchar_t * | text, |
int | size = -1 |
||
) |
Mit dieser Funktion wird dem String ein Wert zugewiesen.
[in] | text | Pointer auf einen Wide-Character String |
[in] | size | Die Anzahl Zeichen (nicht Bytes) im String, die kopiert werden sollen. Wird der Parameter nicht angegeben, wird der komplette String übernommen. Ist size länger als der in text enthaltene String, wird nur bis zum 0-Byte kopiert. |
int ppl6::CWString::Set | ( | const CString * | str, |
int | size = -1 |
||
) |
Mit dieser Funktion wird dem String ein Wert zugewiesen.
[in] | str | Pointer auf einen CString |
[in] | size | Optionaler Parameter, der die Anzahl zu importierender Zeichen angibt. Ist der Wert nicht angegeben, wird der komplette String übernommen. Ist der Wert größer als der angegebene String, wird er ignoriert und der komplette String importiert. |
int ppl6::CWString::Set | ( | const CString & | str, |
int | size = -1 |
||
) |
Mit dieser Funktion wird dem String ein Wert zugewiesen.
[in] | str | CString-Objekt |
[in] | size | Optionaler Parameter, der die Anzahl zu importierender Zeichen angibt. Ist der Wert nicht angegeben, wird der komplette String übernommen. Ist der Wert größer als der angegebene String, wird er ignoriert und der komplette String importiert. |
int ppl6::CWString::Set | ( | const CWString * | str, |
int | chars = -1 |
||
) |
Mit dieser Funktion wird dem String ein Wert zugewiesen.
[in] | str | Pointer auf einen Wide-Character String |
[in] | chars | Die Anzahl Zeichen (nicht Bytes) im String, die kopiert werden sollen. Wird der Parameter nicht angegeben, wird der komplette String übernommen. Ist chars länger als der in str enthaltene String, wird nur bis zum 0-Byte kopiert. |
int ppl6::CWString::Set | ( | const CWString & | str, |
int | chars = -1 |
||
) |
Mit dieser Funktion wird dem String ein Wert zugewiesen.
[in] | str | Pointer auf einen Wide-Character String |
[in] | chars | Die Anzahl Zeichen (nicht Bytes) im String, die kopiert werden sollen. Wird der Parameter nicht angegeben, wird der komplette String übernommen. Ist chars länger als der in str enthaltene String, wird nur bis zum 0-Byte kopiert. |
int ppl6::CWString::SetChar | ( | wchar_t | c | ) |
Mit dieser Funktion wird der String mit einem einzelnen Wide-Character im Unicode-Format belegt.
[in] | c | Unicode des gewünschten Zeichens |
int ppl6::CWString::SetChar | ( | wchar_t | c, |
int | pos | ||
) |
Mit dieser Funktion kann ein einzelnes Zeichen an einer bestimmten Position des Strings überschrieben werden.
[in] | c | Unicode des gewünschten Zeichens |
[in] | pos | Position innerhalb des Strings, wobei 0 das erste Zeichen bedeutet. Ist der Wert negativ, wird die Position vom Ende des Strings berechnet. -1 wäre dabei das letzte Zeichen des Strings. Eine besondere Behandlung wird durchgeführt, wenn pos mit der Länge des Strings übereinstimmt. In diesem Fall wird die Funktion CWString::AddChar aufgerufen und das Zeichen am Ende angehangen. |
int ppl6::CWString::SetExtEncoding | ( | const char * | encoding | ) |
Standardmäßig erwartet die Klasse bei allen "char*" oder "const char*" Parametern, dass der String UTF-8 kodiert ist. Ist dies nicht der Fall, kann mit dieser Funktion eine beliebige andere Kodierung festgelegt werden.
encoding | Ein String im US-ASCII-Format, der den Namen der Kodierung enthält. Die Klasse verwendet intern die iconv-Library, so dass alle Kodierungen möglich sind, die von dieser unterstützt werden. Unter UNIX kann man sich durch Aufruf von "iconv -l" alle möglichen Kodierungen anzeigen lassen. |
int ppl6::CWString::Setf | ( | const char * | fmt, |
... | |||
) |
int ppl6::CWString::Setf | ( | const wchar_t * | fmt, |
... | |||
) |
void ppl6::CWString::Shl | ( | wchar_t | c, |
int | size | ||
) |
Der String wird um die mit size
angegebenen Zeichen nach links verschoben und rechts mit dem durch c
angegebenen Zeichen aufgefüllt.
c | Das Zeichen, mit dem der String auf der rechten Seite aufgefüllt werden soll. Wird der Wert 0 verwendet, findet keine Auffüllung statt, d.h. der String verkürzt sich einfach. |
size | Die Anzahl Zeichen, um die der String nach links verschoben werden soll. Ist size größer als die Länge des Strings, wird der String komplett geleert und ist anschließend so groß wie size, sofern c>0 war. |
void ppl6::CWString::Shr | ( | wchar_t | c, |
int | size | ||
) |
Der String wird um die mit size
angegebenen Zeichen nach rechts verschoben und links mit dem durch c
angegebenen Zeichen aufgefüllt.
c | Das Zeichen, mit dem der String auf der linken Seite aufgefüllt werden soll. c muß größer 0 sein. |
size | Die Anzahl Zeichen, um die der String nach rechts verschoben werden soll. Ist size größer als die Länge des Strings, wird der String komplett geleert und ist anschließend so groß wie size. |
size_t ppl6::CWString::Size | ( | ) | const |
Diese Funktion gibt die Anzahl Bytes zurück, die durch den String belegt werden. Das schließende Null-Byte wird dabei nicht mitgezählt.
int ppl6::CWString::Sprintf | ( | const char * | fmt, |
... | |||
) |
int ppl6::CWString::StrCaseCmp | ( | const char * | str, |
int | size = 0 |
||
) | const |
int ppl6::CWString::StrCaseCmp | ( | const wchar_t * | str, |
int | size = 0 |
||
) | const |
int ppl6::CWString::StrCaseCmp | ( | const CString & | str, |
int | size = 0 |
||
) | const |
int ppl6::CWString::StrCaseCmp | ( | const CWString & | str, |
int | size = 0 |
||
) | const |
int ppl6::CWString::StrCmp | ( | const char * | str, |
int | size = 0 |
||
) | const |
int ppl6::CWString::StrCmp | ( | const wchar_t * | str, |
int | size = 0 |
||
) | const |
int ppl6::CWString::StrCmp | ( | const CString & | str, |
int | size = 0 |
||
) | const |
int ppl6::CWString::StrCmp | ( | const CWString & | str, |
int | size = 0 |
||
) | const |
int ppl6::CWString::Strcpy | ( | const char * | str | ) |
Mit dieser Funktion wird dem String ein Wert zugewiesen.
[in] | str | Pointer auf einen 0-terminierten C-String im UTF-8-Format |
void ppl6::CWString::StripSlashes | ( | ) |
int ppl6::CWString::Strncpy | ( | const char * | str, |
int | size | ||
) |
Mit dieser Funktion wird dem String ein Wert zugewiesen.
[in] | str | Ein Pointer auf einen UTF-8 kodierten C-String, der in die String-Klasse kopiert werden soll. |
[in] | size | Optionaler Parameter, der die Anzahl zu importierender Zeichen angibt. Ist der Wert nicht angegeben, wird der komplette String übernommen. Ist der Wert größer als der angegebene String, wird er ignoriert und der komplette String importiert. |
CWString ppl6::CWString::SubStr | ( | int | start, |
int | len = -1 |
||
) | const |
bool ppl6::CWString::ToBool | ( | ) | const |
CBinary ppl6::CWString::ToCBinary | ( | ) | const |
CString ppl6::CWString::ToCString | ( | ) | const |
double ppl6::CWString::ToDouble | ( | ) | const |
float ppl6::CWString::ToFloat | ( | ) | const |
int ppl6::CWString::ToInt | ( | ) | const |
pplint64 ppl6::CWString::ToInt64 | ( | ) | const |
long ppl6::CWString::ToLong | ( | ) | const |
long long ppl6::CWString::ToLongLong | ( | ) | const |
ppluint32 ppl6::CWString::ToUInt | ( | ) | const |
ppluint64 ppl6::CWString::ToUInt64 | ( | ) | const |
void ppl6::CWString::Trim | ( | ) |
void ppl6::CWString::Trim | ( | wchar_t | c | ) |
void ppl6::CWString::Trim | ( | const char * | str | ) |
void ppl6::CWString::TrimL | ( | int | chars | ) |
Schneidet Zeichen auf der linken Seite des Strings ab
chars | gibt an, wieviele Zeichen abgeschnitten werden sollen |
void ppl6::CWString::TrimR | ( | int | chars | ) |
Schneidet Zeichen auf der rechten Seite des Strings ab
chars | gibt an, wieviele Zeichen abgeschnitten werden sollen |
void ppl6::CWString::UCase | ( | ) |
Diese Funktion wandelt alle Zeichen des Strings in Großbuchstaben um. Die genaue Funktionsweise hängt davon ab, welche Spracheinstellungen aktiv sind, genauer vom Wert "LC_CTYPE".
void ppl6::CWString::UCWords | ( | ) |
int ppl6::CWString::VaSprintf | ( | const char * | fmt, |
va_list | args | ||
) |
Erzeugt einen formatierten String. Erzeugt einen formatierten String
fmt | Der Formatstring |
args | Pointer auf Liste der Parameter. Muss zuvor mit va_start initialisiert worden sein. |
int ppl6::CWString::Vasprintf | ( | const char * | fmt, |
va_list | args | ||
) |
Erzeugt einen formatierten String
fmt | Der Formatstring |
args | Pointer auf Liste der Parameter. Muss zuvor mit va_start initialisiert worden sein. |
Viele Funktionen verwenden einen Formatierungsstring gefolgt von einer variablen Anzahl Parametern. Das nachfolgende Kapitel beschreibt, welche Zeichen und Flags im Formatstring verwendet werden können.
Der Formatstring ist eine Zeichenkette, die, so vorhanden, in ihrem initialen Shift-Zustand beginnt und endet. Der Formatstring setzt sich zusammen aus Null oder mehr Anweisun- gen: normale Zeichen (nicht %), welche unverändert zum Ausgabekanal kopiert werden; und Umwandlungsspezifikationen, welche jeweils null oder mehr Argumente fordern. Jede Umwandlungsspezifikation wird durch das Zeichen % eingeleitet und endet mit einem Umwandlungsspezifikator. Dazwischen können (in dieser Ordung) null oder mehr Flags, eine optionale minimale Feldbreite, eine optionale Genauigkeit und ein optionaler Längenmodifikator.
Die Argumente müssen (nach type promotion) genau zu den Umwandlungsspezifikatoren passen. Standardmäßig werden die Argumente in der Reihenfolge benutzt, in der sie angegeben sind, wobei jeder ‘*’ und jeder Umwandlungsspezifikator das nächste Argument abfragt (und es ist ein Fehler, wenn nicht ausreichend Argumente gegeben sind). Man kann auch explizit angeben, welches Argument genommen wird, an jeder Stelle wo ein ein Argument erforderlich ist, indem man ‘%m$’ anstelle von ‘*’ schreibt, wobei die Dezimalzahl m die Position des gewünschten Arguments in der Argumentenliste angibt, beginnend mit 1. Damit sind printf("\%*d", width, num); und printf("\%2$*1$d", width, num); äquivalent. Der zweite Stil erlaubt wiederholte Referenzen auf das gleiche Argument. Der C99-Standard schließt den Stil mit ‘$’ nicht mit ein, er stammt aus der Single Unix Specification. Wenn der Stil, der ‘$’ benutzt, eingesetzt wird, muss er durchgehend für alle Umwandlungen, die ein Argument nehmen, und alle Breiten- und Genauigkeitsargumente verwendet werden, darf aber mit ‘%%’, das kein Argument konsumiert, vermischt werden. Es darf keine Lücken in der Zahl der Argumente, die mit ‘$’ spezifiziert werden, geben; zum Beispiel muss, wenn Argument 1 und 3 auftreten, auch Argument 2 irgendwo im Formatstring erwähnt werden.
Für einige numerische Umwandlungen wird ein Radixzeichen ("Dezimalkomma") oder ein Tausender-Gruppierungszeichen verwendet. Des tatsächlich benutzte Zeichen hängt vom LC_NUMERIC-Teil der Locale ab. Die POSIX-Locale benutzt ‘.’ als Radixzeichen und hat kein Gruppierungszeichen. Damit resultiert printf("\%’.2f", 1234567.89); in ‘1234567.89’ in der POSIX-Locale, in ‘1234567,89’ in der Locale nl_NL und in ‘1.234.567,89’ in der Locale da_DK.
Das Zeichen ‘%’ wird von null oder mehr der folgenden Flags gefolgt:
#
gibt an, dass der Wert in eine ‘‘alternative Form’’ gewandelt werden soll. Bei der Umwandlung o wird das erste Zeichen der Ausgabe eine Null (indem ‘0’ vorangestellt wird, wenn der Wert nicht schon Null war). Bei den Umwandlungen x und X wird einem Ergebnis ungleich Null der String ‘0x’ (oder ‘0X’ bei X) vorangestellt. Bei den Umwandlungen a, A, e, E, f, F, g und G enthält das Ergebnis immer einen Dezimaltrennzeichen, auch wenn ihm keine Ziffern folgen. (Normalerweise tritt ein Dezimaltrennzeichen nur in Ergebnissen auf, wenn ihm eine Ziffer folgt.) Bei den Umwandlungen g und G werden nachfolgende Nullen nicht aus dem Ergebnis entfernt, wie sie es normalerweise würden. Für andere Umwandlungen ist das Ergebis undefiniert.0
Auffüllen mit Nullen. Bei den Umwandlungen d, i, o, u, x, X, a, A, e, E, f, F, g und G wird der umgewandelte Wert links mit Nullen, nicht mit Leerzeichen aufgefüllt. Werden sowohl 0 als auch - angegeben, so wird 0 ignoriert. Wenn eine Genauigkeit bei einer numerischen Umwandlung (d, i, o, u, x und X), angegeben ist, wird das Flag 0 ignoriert. Für andere Umwandlungen ist das Ergebis undefiniert.-
Linksbündige Ausgabe des umgewandelten Wertes an der Feldgrenze gesetzt wird. (Standard ist rechtsbündige Ausrichtung.) Außer bei der Umwandlung n wird der umgewandelte Wert rechts mit Leerzeichen aufgefüllt statt links mit Leerzeichen oder Nullen. Ein - übersteuert ein 0 falls beide angegeben sind.‘
’ (ein Leerzeichen) gibt an, dass ein Leerzeichen vor einer positiven Zahl bleiben soll, die durch einen Vorzeichenwechsel entstanden ist.+
gibt an, dass vor alle durch Vorzeichenwechel entstandenen Zahlen das Vorzeichen (‘+’ oder ‘-’) gesetzt wird. Standardmäßig wird ein Vorzeichen nur für negative Zahlen verwendet. Ein + übersteuert ein Leerzeichen, falls beide angegeben sind.Die obigen fünf Flags werden vom C-Standard definiert. Die SUSv2 spezifiziert ein weiteres Flag.
´
Für dezimalen Umwandlungen (i, d, u, f, F, g, G) gibt an, dass die Ausgabe bei einem numerischen Argument guppiert werden soll, wenn die lokale Spracherweiterung dieses angibt. Beachte, dass viele Versionen vom gcc diese Option nicht parsen kann und stattdessen eine Warnung ausgeben. SUSv2 schließt %’F nicht mit ein.glibc 2.2 fügt ein weiteres Flag hinzu.
I
Für dezimale Ganzzahlumwandlungen (i, d, u) benutzt die Ausgabe die alternativen Ausgabeziffern der Locale, wenn es solche gibt (zum Beispiel arabische Ziffern). Allerdings schließt die Bibliothek keine Locale-Definitionen mit ein, die outdigits definieren.Eine optionale Dezimalzahl, die die minimale Feldbreite angibt. Wenn der umgewandelte Wert weniger Zeichen als die Feldbreite hat, wird er links mit Leerzeichen aufgefüllt (oder rechts, wenn das Flag für Linksbündigkeit gesetzt ist). Statt einer Dezimalzahl kann auch ‘*’ oder ‘*m$’ (für eine Dezimalzahl m) angegeben werden, um zu spezifizieren, dass die Feldbreite im nächsten (oder m-ten) Argument gegeben ist, welches den Type int haben muss. Eine negative Feldbreite wird als Flag ‘-’ gefolgt von einer positiven Breite interpretiert. In keinem Fall resultiert eine nichtexistierende oder kleine Feldbreite im Abschneiden eines Feldes; ist das Ergebnis einer Umwandlung breiter als die Feldbreite, so wird das Feld erweitert, um das Ergebnis aufzunehmen.
Eine optionale Genauigkeit in der Form eines Punkts (‘.’) gefolgt von einer optionalen Zahl. Statt einer Dezimalzahl kann auch ‘*’ oder ‘*m$’ (für eine Dezimalzahl m) angegeben werden, um zu spezifizieren, dass die Genauigkeit im nächsten (oder m-ten) Argument gegeben ist, welches den Type int haben muss. Wenn die Zahl weggelassen wird oder es eine negative Zahle ist, wird eine Genauigkeit von Null angenommen. Dies gibt die minimale Anzahl der Ziffern an, die bei den Umwandlungen d, i, o, u, x und X erscheinen, bzw. die Anzahl der Ziffern nach dem Dezimaltrennzeichen bei a, A, e, E, f und F , die maximale Anzahl von signifikanten Ziffern bei g und G , oder die maximale Anzahl von auszugebenden Zeichen eines Strings bei s und S.
Im folgenden steht "Ganzzahlumwandlung" für d, i, o, u, x oder X.
hh
Eine folgende Ganzzahlumwandlung entspricht einem Argument vom Typ signed char oder unsigned char, oder eine folgende n-Umwandlung entspricht einem Zeiger auf ein signed-char-Argument.h
Eine folgende Ganzzahlumwandlung entspricht einem Argument vom Typ short int oder unsigned short int, oder eine folgende n-Umwandlung entspricht einem Zeiger auf ein short-int-Argument.l
Eine folgende Ganzzahlumwandlung entspricht einem Argument vom Typ long int oder unsigned long int, oder eine folgende n-Umwandlung entspricht einem Zeiger auf ein long-int-Argument, oder eine folgende c-Umwandlung entspricht einem Zeiger auf ein wchar_t-Argument,ll
Eine folgende Ganzzahlumwandlung entspricht einem Argument vom Typ long long int oder unsigned long long int, oder eine folgende n-Umwandlung entspricht einem Zeiger auf ein long-long-int-Argument.L
Eine folgende a-, A-, e-, E-, f-, F-, g- oder G-Umwandlung entspricht einem long double-Argument. (C99 erlaubt %LF, aber SUSv2 nicht.)q
(‘quad’. Nur BSD 4.4 und Linux libc5. Nicht benutzen.) Dies ist ein Synonym für ll.j
Eine folgende Ganzzahlumwandlung entspricht einem Argument vom Typ intmax_t oder uintmax_t.z
Eine folgende Ganzzahlumwandlung entspricht einem Argument vom Typ size_t oder ssize_t. (Linux libc5 hat Z in dieser Bedeutung. Nicht benutzen.)t
Eine folgende Ganzzahlumwandlung entspricht einem Argument vom Typ ptrdiff_t. SUSv2 kennt nur die Längenmodifikatoren h (in hd, hi, ho, hx, hX, hn) und l (in ld, li, lo, lx, lX, ln, lc, ls) und L (in Le, LE, Lf, Lg, LG).
Ein Zeichen, das den Typ der anzuwendenden Umwandlung angibt. Die Umwandlungsspezifika- toren und ihre Bedeutung sind:
d
,i Das Argument int (oder eine entsprechende Variante) wird umgewandelt in eine vorzeichenbehaftete Dezimalzahl. Die Genauigkeit, sofern vorhanden, gibt die minimale Anzahl vor Ziffern an, die auftreten muss; wenn der umgewandelte Wert weniger Ziffern benötigt, wird er links mit Nullen aufgefüllt. Die voreingestellte Genauigkeit ist 1. Wird 0 mit einer expliziten Genauigkeit 0 gedruckt, so ist die Ausgabe leer.o
,u,x,X Das unsigned-int-Argument wird in eine vorzeichenlose Oktal- (o), Dezimal- (u), oder Hexadezimalzahl (x und X) umgewandelt. Die Buchstaben abcdef werden für Umwandlungen x benutzt; die Buchstaben ABCDEF für Umwandlungen X. Die Genauigkeit, sofern vorhanden, gibt die minimale Anzahl vor Ziffern an, die auftreten muss; wenn der umgewandelte Wert weniger Ziffern benötigt, wird er links mit Nullen aufgefüllt. Die voreingestellte Genauigkeit ist 1. Wird 0 mit einer expliziten Genauigkeit 0 gedruckt, so ist die Ausgabe leer.e
,E Das Argument double wird gerundet und in das Format [-]d.ddde±dd umgewandelt, wobei eine Ziffer vor dem Dezimaltrennzeichen erscheint und die Anzahl der Ziffern dahinter der Genauigkeit entspricht; wenn die Genauigkeit fehlt, wird sie als 6 angenommen; wenn die Genauigkeit Null ist, erscheint kein Dezimaltrennzeichen. Eine Umwandlung E benutzt den Buchstaben E (in Gegensatz zu e), um den Exponenten einzuleiten. Der Exponent enthält immer mindestens zwei Ziffern; wenn der Wert Null ist, ist der Exponent 00.f
,F Das Argument double wird gerundet und umgewandelt in dezimale Notation im Format [-]ddd.ddd, wobei die Anzahl der Ziffern hinter dem Dezimaltrennzeichen der Genauigkeit entspricht. Wenn die Genauigkeit fehlt, wird sie als 6 angenommen; wenn die Genauigkeit Null ist, erscheint kein Dezimaltrennzeichen. Wenn ein Dezimaltrennzeichen erscheint, befindet sich mindestens eine Ziffer davor.(SUSv2 kennt F nicht und sagt, dass Zeichenkettenrepräsentationen für Unendlich und NaN (Not a Number - keine Zahl) vorhanden sein können. Der C99-Standard spezifiziert ‘[-]inf’ oder ‘[-]infinity’ für Unendlich, und eine Zeichenkette beginnend mit ‘nan’ für NaN im Falle von f, und ‘[-]INF’ oder ‘[-]INFINITY’ oder ‘NAN’ im Falle von F.)
g
, G Das Argument double wird umgewandelt in das Format f oder e (oder F oder E für die Umwandlung G). Die Genauigkeit gibt die Anzahl der signifikanten Stellen an. Wenn die Genauigkeit fehlt, werden 6 Ziffern zurückgegeben; wenn die Genauigkeit Null ist, wird sie als 1 angenommen. Form e wird benutzt, wenn der Exponent kleiner als -4 oder größer als oder gleich der Genauigkeit ist. Nachfolgende Nullen im Bruchteil werden entfernt; ein Dezimaltrennzeichen erscheint nur, wenn es von mindestens einer Ziffer gefolgt wird.a
,A (C99; nicht in SUSv2) Für die Umwandlung a wird das double-Argument in hexadezimale Notation gebracht (unter Benutzung der Buchstaben abcdef) in der Form [-]0xh.hhhhp±d; für A sind dagegen der Präfix 0X, die Buchstaben ABCDEF und das Exponententrennzeichen P. Vor dem Dezimaltrennzeichen ist eine hexadezimale Ziffer, die Anzahl der Stellen dahinter entspricht der Genauigkeit. Die standardmäßige Genauigkeit genügt für eine exakte Repräsentation des Wertes, wenn eine exakte Repräsentation zur Basis 2 existiert und ist sonstigenfalls groß genug, um Werte vom Typ double zu unterscheiden. Die Ziffer vor dem Dezimaltrennzeichen ist unspezifiziert für nichtnormalisierte Zahlen, und nicht Null, aber ansonsten unspezifiziert, für normalisierte Zahlen.c
Wenn kein Modifikator l vorhanden ist, wird das Argument int umgewandelt in einen unsigned char und das resultierende Zeichen ausgegeben. Wenn ein l vorhanden ist, wird das wint_t-Argument (breites Zeichen) mit einem Ruf der Funktion wcrtomb zu einer Multibyte-Folge umgewandelt, mit der Konvertierung beginnend im initialen Zustand, und die resultierende Multibyte-Zeichenkette wird ausgegeben.s
Wenn kein Modifikator l vorhanden ist, wird das Argument const char * erwartet als ein Zeiger auf ein Array vom Typ Character (Zeiger auf einen String). Zeichen aus diesem Array werden bis zu (aber nicht einschliesslich) des terminierenden NUL- Zeichens ausgegeben; wenn eine Genauigkeit angegeben ist, werden nicht mehr Zeichen als die angegebene Anzahl ausgegeben. Wenn eine Genauigkeit angegeben ist braucht kein Null-Zeichen vorhanden zu sein; wenn die Genauigkeit nicht angegeben ist oder größer als die Array-Größe ist, muss das Array ein beendendes Zeichen NUL enthalten. Wenn ein l vorhanden ist, wird das const-wchar_t-*-Argument als ein Zeiger auf ein Array von breiten Zeichen erwartet. Breite Zeichen aus dem Array werden zu Multibyte-Zeichen umgewandelt (jedes mit einem Ruf von wcrtomb, beginnend im initialen Zustand vor dem ersten breiten Zeichen), bis zu und einschließlich des terminierenden breiten NUL-Zeichens. Wenn eine Genauigkeit angegeben ist, werden nicht mehr Bytes als die angegebene Anzahl ausgegeben, aber es werden keine partiellen Multibyte-Zeichen ausgegeben. Man beachte, dass die Genauigkeit die Anzahl der Bytes, nicht der breiten Zeichen oder Bildschirmpositionen angibt. Das Array muss ein terminierendes breites NUL-Zeichen enthalten, wenn nicht eine Genauigkeit gegeben ist, die so klein ist, dass die Zahl der geschriebenen Bytes sie übersteigt, bevor das Ende des Arrays erreicht ist.p
Das Zeiger-Argument void * wird hexadezimal ausgegeben (wie bei %#x oder %#lx).n
Die Anzahl der bis hierhin ausgegebenen Zeichen wird in dem Integer gespeichert, der durch das Zeiger-Argument int * (bzw. Äquivalent) gegeben ist. Kein Argument wird umgewandelt.%
Ein ‘%’ wird ausgegeben. Kein Argument wird umgewandelt. Die komplette Umwandlungsspezifikation ist ‘%%’.
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
protectedinherited |