PPL6-Icon Patrick's Programming Library Version 6.4.21 - Dokumentation
ppl6::CWString Klassenreferenz

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
 
CWStringoperator= (const CBinary &str)
 
void Print (bool attach_newline=false) const
 String auf STDOUT ausgeben. Mehr ...
 
CWStringRepeat (int num)
 
CWStringRepeat (const char *str, int num)
 
CWStringRepeat (const wchar_t *str, int num)
 
CWStringRepeat (const wchar_t ascii, int num)
 Füllt den String mit einem Zeichen. Mehr ...
 
CWStringRepeat (const CWString &str, int num)
 
CWStringRepeat (const CString &str, int num)
 
CWStringReplace (const char *str, const char *byStr)
 Ersetzt einen Teilstring durch einen anderen. Mehr ...
 
CWStringReplace (const CWString &str, const CWString &byStr)
 Ersetzt einen Teilstring durch einen anderen. Mehr ...
 
CWStringReplaceLetterList (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 ...
 
CWStringoperator= (char *str)
 
CWStringoperator= (const char *str)
 
CWStringoperator= (const CWString &str)
 
CWStringoperator= (const CWString *str)
 
CWStringoperator= (const CString &str)
 
CWStringoperator= (const CString *str)
 
CWStringoperator= (const wchar_t c)
 Unicode-Zeichen zuweisen. Mehr ...
 
CWStringoperator= (const wchar_t *str)
 
CWStringoperator+= (const char *str)
 
CWStringoperator+= (const wchar_t *str)
 
CWStringoperator+= (const wchar_t c)
 
CWStringoperator+= (const CWString &str)
 
CWStringoperator+= (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
 
CArraymatches
 

Ausführliche Beschreibung

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.

Dokumentation der Aufzählungstypen

enum ppl6::CVar::PPLDataType
inherited

Enumeration der verschiedenen Datenobjekte, die in der Library verwendet werden

Seit
Wurde mit Version 6.3.0 eingeführt.
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.

Beschreibung der Konstruktoren und Destruktoren

ppl6::CWString::CWString ( )

Erzeugt einen Leeren String

ppl6::CWString::CWString ( const char *  str)

Erzeugt einen neuen String mit dem Inhalt von str

Parameter
strist ein const char * auf einen 0-terminierten String im UTF-8-Format.
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
ppl6::CWString::CWString ( const wchar_t *  str)

Erzeugt einen neuen String mit dem Inhalt von str

Parameter
strist 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

Parameter
strist ein Pointer auf eine andere String-Klasse.
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
ppl6::CWString::CWString ( const CString str)

Erzeugt einen neuen String mit dem Inhalt von str

Parameter
strist eine andere Instanz der String-Klasse.
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
ppl6::CWString::CWString ( const CWString str)

Erzeugt einen neuen String mit dem Inhalt von str

Parameter
strist ein Pointer auf eine andere String-Klasse.
ppl6::CWString::CWString ( const CWString str)

Erzeugt einen neuen String mit dem Inhalt von str

Parameter
strist 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

Parameter
cist der Unicode des gewünschten Zeichens
ppl6::CWString::~CWString ( )

Der Destruktor gibt alle von dieser Instanz verwendeten Speicherbereiche wieder frei.

Dokumentation der Elementfunktionen

int ppl6::CWString::Add ( const char *  str,
int  size = -1 
)

Mit dieser Funktion der übergebene String an den bereits vorhandenen angehangen

Parameter
[in]strEin Pointer auf einen 0-terminierten C-String im UTF-8-Format
[in]sizeOptionaler 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
int ppl6::CWString::AddChar ( wchar_t  c)

Mit dieser Funktion wird ein einzelnes Zeichen an den String angefügt.

Parameter
[in]cUnicode des gewünschten Zeichens
Rückgabe
Die Funktion liefert true (1) zurück, wenn der String mit dem Zeichen belegt werden konnte. Bei einem Fehler wird 0 zurückgegeben.
Siehe auch
Die Funktion ist identisch mit CWString::ConcatChar und dem Operator CWString::operator+=(const wchar_t c)
int ppl6::CWString::Capacity ( ) const
Beschreibung:
Die Stringfunktion verwaltet intern einen Speicherblock, der größer ist, als für den aktuellen Inhalt erforderlich wäre. Das hat den Vorteil, dass bei Änderungen am String in den meisten Fällen kein neuer Speicher allokiert werden muß, da noch genug Reserve vorhanden ist. Dadurch wird der Speicher weniger fragmentiert und man gewinnt etwas an Performance.

Mit dieser Funktion kann man feststellen, wieviele Zeichen der String maximal groß werden darf, ohne dass neuer Speicher allokiert werden muss.

Rückgabe
Anzahl Zeichen, die in den aktuellen Puffer passen (ohne terminierenden 0-Wert)
Zu beachten
Beim Import von Strings in einer anderen Kodierung (insbesondere bei Multibyte-Encodings wie UTF-8), geht die Klasse immer vom "worst case" aus und errechnet mehr Speicherbedarf als wahrscheinlich notwendig wäre. Dadurch kommt es vor, dass dennoch neuer Speicher allokiert wird, obwohl der String in den vorhandenen passen würde.
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.

Rückgabe
Nichts
int ppl6::CWString::Concat ( const char *  text,
int  size = -1 
)
int ppl6::CWString::Concat ( const wchar_t *  text,
int  size = -1 
)
Parameter
[in]textPointer auf einen Wide-Character String
[in]sizeDie 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.

Parameter
[in]cUnicode des gewünschten Zeichens
Rückgabe
Die Funktion liefert true (1) zurück, wenn der String mit dem Zeichen belegt werden konnte. Bei einem Fehler wird 0 zurückgegeben.
Siehe auch
Die Funktion ist identisch mit CWString::AddChar und dem Operator CWString::operator+=(const wchar_t c)
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.

Parameter
[in]strEin Pointer auf einen UTF-8 kodierten C-String, der in die String-Klasse kopiert werden soll.
[in]sizeOptionaler 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
int ppl6::CWString::Copy ( const CString str,
int  size = -1 
)

Mit dieser Funktion wird dem String ein Wert zugewiesen.

Parameter
[in]strEin Pointer auf eine CString-Klasse
[in]sizeOptionaler 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
void ppl6::CWString::Cut ( int  position)

Der String wird an einer bestimmten Stelle einfach abgeschnitten

Parameter
positionDie 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.
int CVar::DataType ( ) const
inherited

Diese Funktion liefert den Datentyp des Objekts zurück.

Rückgabe
ID aus der Enumeration CVar::PPLDataType
Seit
Wurde mit Version 6.3.0 eingeführt.
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.

Parameter
[in]posStartposition, ab der gelöscht werden soll
[in]numAnzahl Zeichen, die gelöscht werden sollen
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück. Im Fehlerfall wird false (0) zurückgegeben, der String könnte aber teilweise schon manipuliert worden sein.
int ppl6::CWString::Find ( const char *  str,
int  pos 
) const

Find sucht nach dem Suchstring str ab der gewünschten Position pos.

Rückgabe
Liefert die Position innerhalb des Strings, an der der Suchstring gefunden wurde oder -1 wenn er nicht gefunden wurde.
int ppl6::CWString::Find ( const CWString search,
int  pos 
) const

Find sucht nach dem Suchstring str ab der gewünschten Position pos.

Rückgabe
Liefert die Position innerhalb des Strings, an der der Suchstring gefunden wurde oder -1 wenn er nicht gefunden wurde.
const void * ppl6::CWString::GetBuffer ( ) const

Diese Funktion liefert einen Pointer auf die Unicode-Rohdaten zurück.

Rückgabe
Pointer auf die Unicode-Version des Strings
wchar_t ppl6::CWString::GetChar ( int  pos) const

Mit dieser Funktion kann ein einzelnes Zeichen an einer bestimmten Stelle des Strings ausgelesen werden.

Parameter
posPosition 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.
Rückgabe
Ist das Zeichen an der Stelle 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

Parameter
indexist ein Index auf die Ergebnisse. 0 liefert immer den kompletten String zurück, 1 den ersten Match, 2 den zweiten usw.
Rückgabe
Die Funktion liefert einen const char * zurück, sofern der Match vorhanden ist, ansonsten NULL.
Zu beachten
Diese Funktion ist nur verfügbar, wenn PPL mit dem Configure-Flag –with-pcre konfiguriert und kompiliert wurde.
Falls kein UTF-8 angegeben wird, das System auf dem das Programm läuft aber UTF-8 in LC_CTYPE konfiguriert hat, wird automatisch UTF-8 verwendet.
Falls UTF-8 verwendet wird, der zu vergleichende String aber ungültiges UTF-8 enthält, macht die Funktion ein Fallback auf Singlebyte-Zeichen.
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.

Rückgabe
Pointer auf die UTF-8-Version des Strings
Bemerkungen
Die Funktion ruft iconv auf, um den aktuellen Wide-String in eine UTF-8-Version umzuwandeln. Dieser wird als Pointer zurückgegeben und kann von der Anwendung zum Beispiel innerhalb eines printf verwendet 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.

Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
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.

Parameter
[in]bufferPointer auf den Beginn des Speicherbereichs, der gedumpt werden soll
[in]bytesAnzahl Bytes, die gedumpt werden sollen
[in]skipheaderOptionaler 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.

Parameter
encodingName der Kodierung, in der der zu importierende String vorliegt (z.B. "ISO-8859-15")
bufferPointer auf den Speicherbereich, an dem der zu importierende String beginnt. Sofern der Parameter len nicht angegeben wurde, muss dieser mit einem 0-Byte enden
bytesOptionaler Parameter, der die Länge des Strings in Byte angibt
Rückgabe
Die Funktion liefert true (1) zurück, wenn der String erfolgreich importiert werden konnte, andernfalls false (0).
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.

Parameter
[in]bufferPointer auf den Speicherbereich, ab dem der String beginnt
[in]bytesAnzahl Bytes, die beim malloc allokiert wurden. Dies muss zwingend ein Vielfaches von sizeof(wchar_t) sein!
Zu beachten
Falls der String nicht mit einem 0-Wert beendet wurde, wird automatisch das letzte Zeichen des Buffers auf 0 gesetzt. Das könnte einen ungewollten Effekt haben, falls das Zeichen an dieser Stelle wichtig war. Es sollte daher immer mindestens sizeof(wchar_t) Bytes mehr allokiert werden, als tatsächlich benötigt wird.
Seit
Diese Funktion wurde mit Version 6.3.0 eingeführt
void ppl6::CWString::Init ( )
private

Diese Funktion wird intern von den Konstruktoren aufgerufen, um alle internen Variablen und Puffer auf NULL zu setzen

int ppl6::CWString::InitExportEncoding ( const char *  encoding)
private

Diese Funktion wird intern aufgerufen, um die iconv-Funktion für den Export von UTF-8 Strings zu initialisieren.

int ppl6::CWString::InitImportEncoding ( const char *  encoding)
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.

Parameter
[in]cUnicode des gewünschten Zeichens
[in]posPosition 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.
Rückgabe
Die Funktion liefert true (1) zurück, wenn das Zeichen eingefügt werden konnte. Im Fehlerfall wird false (0) zurückgegeben, der String könnte aber teilweise schon manipuliert worden sein.
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

Rückgabe
Ist der String leer, liefert die Funktion true (1) zurück, sonst false.
Siehe auch
CWString::NotEmpty
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:

  • Der String zeigt auf NULL
  • Die Länge des Strings ist 0
  • Der String enthält die Ziffer 0
  • Der String enthält nicht das Wort "true", "wahr", "yes" oder "ja" (Gross-/Kleinschreibung egal)
Rückgabe
Liefert true (1) zurück, wenn der String "unwahr" ist, sonst false (0). Ein Fehlercode wird nicht gesetzt
Siehe auch
CWString::IsTrue()
int ppl6::CWString::IsInteger ( ) const
Beschreibung:
Diese Funktion prüft, ob im String einen integer Wert enthält, also nur die Ziffern 0-9 und optional ein Minus am Anfang enthalten sind
Rückgabe
Ist der String ein Integer, wird 1 zurückgegeben. Ist er es nicht oder ist der String leer, wird 0 zurückgegeben.
int ppl6::CWString::IsNumeric ( ) const
Beschreibung:
Diese Funktion prüft, ob im String nur nummerische Zeichen vorhanden sind, also die Ziffern 0-9, Punkt, Komma und Minus.
Rückgabe
Ist der String nummerisch, wird 1 zurückgegeben. Ist er es nicht oder ist der String leer, wird 0 zurückgegeben.
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:

  • Der String enthält eine Ziffer ungleich 0
  • Der String enthält das Wort "true" (Gross- oder Kleingeschrieben)
  • Der String enthält das Wort "wahr" (Gross- oder Kleingeschrieben)
  • Der String enthält das Wort "yes" (Gross- oder Kleingeschrieben)
  • Der String enthält das Wort "ja" (Gross- oder Kleingeschrieben)
Rückgabe
Liefert true (1) zurück, wenn der String "wahr" ist, sonst false (0). Ein Fehlercode wird nicht gesetzt
Siehe auch
CWString::IsFalse()
int CVar::IsType ( int  type) const
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".

Achtung
Unter UNIX (und möglicherweise anderen Betriebssystemen) werden die Lokalisationseinstellungen der Umgebung nicht automatisch übernommen, sondern stehen standardmäßig auf "C". Dadurch werden nur US-ASCII (ASCII 32 bis 127) umgewandelt. Man sollte daher nach Programmstart mit "setlocale" die gewünschte Spracheinstellung vornehmen.
Beispiel:
#include <locale.h>
...
setlocale(LC_CTYPE,"de_DE.UTF-8");
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.

Rückgabe
Gibt Anzahl im String enthaltener Zeichen zurück, oder 0, wenn der String Leer ist.
Siehe auch
size_t ppl6::CWString::Length ( ) const

Diese Funktion gibt die Anzahl Zeichen zurück, die im String enthalten sind.

Rückgabe
Gibt Anzahl im String enthaltener Zeichen zurück, oder 0, wenn der String Leer ist.
Siehe auch
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

Parameter
strPointer auf einen String. Dieser muss mit einem 0-Byte enden, sofern der Parameter size nicht angegeben wurde
sizeOptionaler Parameter, der die Größe des Strings in Bytes angibt.
Rückgabe
Die Funktion liefert true (1) zurück, wenn die MD5-Summe erfolgreich errechnet wurde, andernfalls false (0).
Bemerkungen
Diese Funktion nimmt keine Konvertierung nach 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

Rückgabe
Liefert true (1) zurück, wenn die MD5-Summe erfolgreich berechnet wurde, sonst false (0).
Achtung
Der Ursprüngliche Inhalt dieses Strings wird durch die MD5-Summe ersetzt und geht somit verloren!
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

Rückgabe
Enthält der String Daten (Länge > 0), liefert die Funktion true (1) zurück, sonst false.
Siehe auch
CWString::IsEmpty
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.

Rückgabe
Pointer auf die UTF-8-Version des Strings
Bemerkungen
Die Funktion ruft iconv auf, um den aktuellen Wide-String in eine UTF-8-Version umzuwandeln. Dieser wird als Pointer zurückgegeben und kann von der Anwendung zum Beispiel innerhalb eines printf verwendet 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.

Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
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)
CWString & ppl6::CWString::operator+= ( const CWString str)
CWString & ppl6::CWString::operator+= ( const CString str)
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 CWString str)
CWString & ppl6::CWString::operator= ( const CWString str)
CWString & ppl6::CWString::operator= ( const CString str)
CWString & ppl6::CWString::operator= ( const CString str)
CWString& ppl6::CWString::operator= ( const CBinary str)
CWString & ppl6::CWString::operator= ( const wchar_t  c)

Der String wird mit dem angegebenen Zeichen belegt.

Parameter
cist 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.

Parameter
posPosition 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.
Rückgabe
Ist das Zeichen an der Stelle 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

Parameter
[in]exprIst 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 caseless
    If this bit is set, letters in the pattern match both upper and lower case letters. It is equivalent to Perl's /i option, and it can be changed within a pattern by a (?i) option setting. In UTF-8 mode, PCRE always understands the concept of case for characters whose values are less than 128, so caseless matching is always possible. For characters with higher values, the concept of case is supported if PCRE is compiled with Unicode property support, but not otherwise. If you want to use caseless matching for characters 128 and above, you must ensure that PCRE is compiled with Unicode property support as well as with UTF-8 support.
  • m multiline
    By default, PCRE treats the subject string as consisting of a single line of characters (even if it actually contains newlines). The "start of line" metacharacter (^) matches only at the start of the string, while the "end of line" metacharacter ($) matches only at the end of the string, or before a terminating newline. This is the same as Perl. When "m" it is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the subject string, respectively, as well as at the very start and end. This is equivalent to Perl's /m option, and it can be changed within a pattern by a (?m) option setting. If there are no "\n" characters in a subject string, or no occurrences of ^ or $ in a pattern, setting "m" has no effect.
  • x extended
    If this is set, whitespace data characters in the pattern are totally ignored except when escaped or inside a character class. Whitespace does not include the VT character (code 11). In addition, characters between an unescaped # outside a character class and the next newline character, inclusive, are also ignored.
  • s dotall
    If this bit is set, a dot metacharater in the pattern matches all characters, including newlines. Without it, newlines are excluded. This option is equivalent to Perl's /s option, and it can be changed within a pattern by a (?s) option setting. A negative class such as [^a] always matches a newline character, independent of the setting of this option.
  • 8 UTF8
    This option causes PregMatch to regard both the pattern and the subject as strings of UTF-8 characters instead of single-byte character strings. However, it is available only when PCRE is built to include UTF-8 support. If not, the use of this option provokes an error. Details of how this option changes the behaviour of PCRE are given in the section on UTF-8 support in the main pcre page.
  • a anchored
    If this bit is set, the pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched (the "subject string"). This effect can also be achieved by appropriate constructs in the pattern itself, which is the only way to do it in Perl.
  • u ungreedy
    This option inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?". It is not compatible with Perl. It can also be set by a (?U) option setting within the pattern.
Parameter
[out]resist 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.
Rückgabe
Liefert true(1) zurück, wenn ein Match gefunden wurde, ansonsten false(0)
Bemerkungen
Der String wird intern zuerst nach UTF-8 kodiert, bevor die pcre-Funktionen aufgerufen werden.
Zu beachten
Diese Funktion ist nur verfügbar, wenn PPL mit dem Configure-Flag –with-pcre konfiguriert und kompiliert wurde.
Falls kein UTF-8 angegeben wird, das System auf dem das Programm läuft aber UTF-8 in LC_CTYPE konfiguriert hat, wird automatisch UTF-8 verwendet.
Falls UTF-8 verwendet wird, der zu vergleichende String aber ungültiges UTF-8 enthält, macht die Funktion ein Fallback auf Singlebyte-Zeichen.
int ppl6::CWString::PregReplace ( const char *  expr,
const char *  replace,
int  maxreplace = 0 
)
Parameter
expris a perl compatible regular expression, starting and ending with slash (/).
  • i caseless
    If this bit is set, letters in the pattern match both upper and lower case letters. It is equivalent to Perl's /i option, and it can be changed within a pattern by a (?i) option setting. In UTF-8 mode, PCRE always understands the concept of case for characters whose values are less than 128, so caseless matching is always possible. For characters with higher values, the concept of case is supported if PCRE is compiled with Unicode property support, but not otherwise. If you want to use caseless matching for characters 128 and above, you must ensure that PCRE is compiled with Unicode property support as well as with UTF-8 support.
  • m multiline
    By default, PCRE treats the subject string as consisting of a single line of characters (even if it actually contains newlines). The "start of line" metacharacter (^) matches only at the start of the string, while the "end of line" metacharacter ($) matches only at the end of the string, or before a terminating newline. This is the same as Perl. When "m" it is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the subject string, respectively, as well as at the very start and end. This is equivalent to Perl's /m option, and it can be changed within a pattern by a (?m) option setting. If there are no "\n" characters in a subject string, or no occurrences of ^ or $ in a pattern, setting "m" has no effect.
  • x extended
    If this is set, whitespace data characters in the pattern are totally ignored except when escaped or inside a character class. Whitespace does not include the VT character (code 11). In addition, characters between an unescaped # outside a character class and the next newline character, inclusive, are also ignored.
  • s dotall
    If this bit is set, a dot metacharater in the pattern matches all characters, including newlines. Without it, newlines are excluded. This option is equivalent to Perl's /s option, and it can be changed within a pattern by a (?s) option setting. A negative class such as [^a] always matches a newline character, independent of the setting of this option.
  • 8 UTF8
    This option causes PregMatch to regard both the pattern and the subject as strings of UTF-8 characters instead of single-byte character strings. However, it is available only when PCRE is built to include UTF-8 support. If not, the use of this option provokes an error. Details of how this option changes the behaviour of PCRE are given in the section on UTF-8 support in the main pcre page.
  • a anchored
    If this bit is set, the pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched (the "subject string"). This effect can also be achieved by appropriate constructs in the pattern itself, which is the only way to do it in Perl.
  • u ungreedy
    This option inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?". It is not compatible with Perl. It can also be set by a (?U) option setting within the pattern.
Parameter
replaceist 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.
maxreplaceist 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.
Rückgabe
Liefert true(1) zurück, wenn ein Match gefunden wurde, ansonsten false(0)
Zu beachten
Diese Funktion ist nur verfügbar, wenn PPL mit dem Configure-Flag –with-pcre konfiguriert und kompiliert wurde.
Falls kein UTF-8 angegeben wird, das System auf dem das Programm läuft aber UTF-8 in LC_CTYPE konfiguriert hat, wird automatisch UTF-8 verwendet.
Falls UTF-8 verwendet wird, der zu vergleichende String aber ungültiges UTF-8 enthält, macht die Funktion ein Fallback auf Singlebyte-Zeichen.
int ppl6::CWString::PregReplace ( const char *  expr,
CString replace,
int  maxreplace = 0 
)
Parameter
[in]expris a perl compatible regular expression, starting and ending with slash (/).
  • i caseless
    If this bit is set, letters in the pattern match both upper and lower case letters. It is equivalent to Perl's /i option, and it can be changed within a pattern by a (?i) option setting. In UTF-8 mode, PCRE always understands the concept of case for characters whose values are less than 128, so caseless matching is always possible. For characters with higher values, the concept of case is supported if PCRE is compiled with Unicode property support, but not otherwise. If you want to use caseless matching for characters 128 and above, you must ensure that PCRE is compiled with Unicode property support as well as with UTF-8 support.
  • m multiline
    By default, PCRE treats the subject string as consisting of a single line of characters (even if it actually contains newlines). The "start of line" metacharacter (^) matches only at the start of the string, while the "end of line" metacharacter ($) matches only at the end of the string, or before a terminating newline. This is the same as Perl. When "m" it is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the subject string, respectively, as well as at the very start and end. This is equivalent to Perl's /m option, and it can be changed within a pattern by a (?m) option setting. If there are no "\n" characters in a subject string, or no occurrences of ^ or $ in a pattern, setting "m" has no effect.
  • x extended
    If this is set, whitespace data characters in the pattern are totally ignored except when escaped or inside a character class. Whitespace does not include the VT character (code 11). In addition, characters between an unescaped # outside a character class and the next newline character, inclusive, are also ignored.
  • s dotall
    If this bit is set, a dot metacharater in the pattern matches all characters, including newlines. Without it, newlines are excluded. This option is equivalent to Perl's /s option, and it can be changed within a pattern by a (?s) option setting. A negative class such as [^a] always matches a newline character, independent of the setting of this option.
  • 8 UTF8
    This option causes PregMatch to regard both the pattern and the subject as strings of UTF-8 characters instead of single-byte character strings. However, it is available only when PCRE is built to include UTF-8 support. If not, the use of this option provokes an error. Details of how this option changes the behaviour of PCRE are given in the section on UTF-8 support in the main pcre page.
  • a anchored
    If this bit is set, the pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched (the "subject string"). This effect can also be achieved by appropriate constructs in the pattern itself, which is the only way to do it in Perl.
  • u ungreedy
    This option inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?". It is not compatible with Perl. It can also be set by a (?U) option setting within the pattern.
Parameter
[in]replaceist 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]maxreplaceist 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.
Rückgabe
Liefert true(1) zurück, wenn ein Match gefunden wurde, ansonsten false(0)
Zu beachten
Diese Funktion ist nur verfügbar, wenn PPL mit dem Configure-Flag –with-pcre konfiguriert und kompiliert wurde.
Falls kein UTF-8 angegeben wird, das System auf dem das Programm läuft aber UTF-8 in LC_CTYPE konfiguriert hat, wird automatisch UTF-8 verwendet.
Falls UTF-8 verwendet wird, der zu vergleichende String aber ungültiges UTF-8 enthält, macht die Funktion ein Fallback auf Singlebyte-Zeichen.
int ppl6::CWString::PregReplace ( const char *  expr,
CWString replace,
int  maxreplace = 0 
)
Parameter
[in]expris a perl compatible regular expression, starting and ending with slash (/).
  • i caseless
    If this bit is set, letters in the pattern match both upper and lower case letters. It is equivalent to Perl's /i option, and it can be changed within a pattern by a (?i) option setting. In UTF-8 mode, PCRE always understands the concept of case for characters whose values are less than 128, so caseless matching is always possible. For characters with higher values, the concept of case is supported if PCRE is compiled with Unicode property support, but not otherwise. If you want to use caseless matching for characters 128 and above, you must ensure that PCRE is compiled with Unicode property support as well as with UTF-8 support.
  • m multiline
    By default, PCRE treats the subject string as consisting of a single line of characters (even if it actually contains newlines). The "start of line" metacharacter (^) matches only at the start of the string, while the "end of line" metacharacter ($) matches only at the end of the string, or before a terminating newline. This is the same as Perl. When "m" it is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the subject string, respectively, as well as at the very start and end. This is equivalent to Perl's /m option, and it can be changed within a pattern by a (?m) option setting. If there are no "\n" characters in a subject string, or no occurrences of ^ or $ in a pattern, setting "m" has no effect.
  • x extended
    If this is set, whitespace data characters in the pattern are totally ignored except when escaped or inside a character class. Whitespace does not include the VT character (code 11). In addition, characters between an unescaped # outside a character class and the next newline character, inclusive, are also ignored.
  • s dotall
    If this bit is set, a dot metacharater in the pattern matches all characters, including newlines. Without it, newlines are excluded. This option is equivalent to Perl's /s option, and it can be changed within a pattern by a (?s) option setting. A negative class such as [^a] always matches a newline character, independent of the setting of this option.
  • 8 UTF8
    This option causes PregMatch to regard both the pattern and the subject as strings of UTF-8 characters instead of single-byte character strings. However, it is available only when PCRE is built to include UTF-8 support. If not, the use of this option provokes an error. Details of how this option changes the behaviour of PCRE are given in the section on UTF-8 support in the main pcre page.
  • a anchored
    If this bit is set, the pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched (the "subject string"). This effect can also be achieved by appropriate constructs in the pattern itself, which is the only way to do it in Perl.
  • u ungreedy
    This option inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?". It is not compatible with Perl. It can also be set by a (?U) option setting within the pattern.
Parameter
[in]replaceist 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]maxreplaceist 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.
Rückgabe
Liefert true(1) zurück, wenn ein Match gefunden wurde, ansonsten false(0)
Zu beachten
Diese Funktion ist nur verfügbar, wenn PPL mit dem Configure-Flag –with-pcre konfiguriert und kompiliert wurde.
Falls kein UTF-8 angegeben wird, das System auf dem das Programm läuft aber UTF-8 in LC_CTYPE konfiguriert hat, wird automatisch UTF-8 verwendet.
Falls UTF-8 verwendet wird, der zu vergleichende String aber ungültiges UTF-8 enthält, macht die Funktion ein Fallback auf Singlebyte-Zeichen.
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.

Parameter
attach_newlineEin optionaler Parameter, der angibt, ob nach der Ausgabe ein Zeilenumbruch angehangen werden soll (default=false)
void ppl6::CWString::ReCalcLen ( )
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

Parameter
asciiDer ASCII-Code des Zeichens, mit dem der String gefüllt werden soll
numDie Länge des gewünschten Strings
Rückgabe
liefert einen neuen String zurück
CWString & ppl6::CWString::Repeat ( const CWString str,
int  num 
)
CWString & ppl6::CWString::Repeat ( const CString str,
int  num 
)
CWString & ppl6::CWString::Replace ( const char *  str,
const char *  byStr 
)
CWString & ppl6::CWString::Replace ( const CWString str,
const CWString byStr 
)
CWString & ppl6::CWString::ReplaceLetterList ( const CWString letters,
wchar_t  replacement 
)
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ß.

Parameter
[in]charsAnzahl Zeichen, für die Speicher allokiert werden soll.
Rückgabe
Liefert true (1) zurück, wenn der gewünschte Speicher allokiert werden konnte, sonst false (0).
Bemerkungen
Es ist zu beachten, dass die CWString-Klasse den String intern als Unicode im Datentyp wchar_t speichert. Dieser ist in der Regel 16 (Windows) oder 32-Bit (Unix) breit. Der Speicherbedarf errechnet sich daher aus Anzahl Zeichen * 2 bzw. *4.

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.

Parameter
[in]textEin Pointer auf einen UTF-8 kodierten C-String, der in die String-Klasse kopiert werden soll.
[in]sizeOptionaler 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
int ppl6::CWString::Set ( const wchar_t *  text,
int  size = -1 
)

Mit dieser Funktion wird dem String ein Wert zugewiesen.

Parameter
[in]textPointer auf einen Wide-Character String
[in]sizeDie 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
int ppl6::CWString::Set ( const CString str,
int  size = -1 
)

Mit dieser Funktion wird dem String ein Wert zugewiesen.

Parameter
[in]strPointer auf einen CString
[in]sizeOptionaler 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
int ppl6::CWString::Set ( const CString str,
int  size = -1 
)

Mit dieser Funktion wird dem String ein Wert zugewiesen.

Parameter
[in]strCString-Objekt
[in]sizeOptionaler 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
int ppl6::CWString::Set ( const CWString str,
int  chars = -1 
)

Mit dieser Funktion wird dem String ein Wert zugewiesen.

Parameter
[in]strPointer auf einen Wide-Character String
[in]charsDie 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
int ppl6::CWString::Set ( const CWString str,
int  chars = -1 
)

Mit dieser Funktion wird dem String ein Wert zugewiesen.

Parameter
[in]strPointer auf einen Wide-Character String
[in]charsDie 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
int ppl6::CWString::SetChar ( wchar_t  c)

Mit dieser Funktion wird der String mit einem einzelnen Wide-Character im Unicode-Format belegt.

Parameter
[in]cUnicode des gewünschten Zeichens
Rückgabe
Die Funktion liefert true (1) zurück, wenn der String mit dem Zeichen belegt werden konnte.
int ppl6::CWString::SetChar ( wchar_t  c,
int  pos 
)

Mit dieser Funktion kann ein einzelnes Zeichen an einer bestimmten Position des Strings überschrieben werden.

Parameter
[in]cUnicode des gewünschten Zeichens
[in]posPosition 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.
Rückgabe
Die Funktion liefert true (1) zurück, wenn der String mit dem Zeichen belegt werden konnte. Ist pos < 0 oder größer wie die aktuelle Stringinhalt, wird 0 zurückgegeben und der Fehlercode 436 gesetzt.
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.

Parameter
encodingEin 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.
Rückgabe
Wird die gewünschte Kodierung unterstützt, gibt die Funktion true (1) zurück, sonst false (0).
Beispiel:
s.SetExtEncoding("ISO-8859-15");
s.Set("Dieser Text ist ISO-8859-15 kodiert.");
Zu beachten
Möchte man das Encoding für alle CWStrings auf globaler Ebene ändern, kann man die Funktion ppl6::SetGlobalEncoding verwenden.
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.

Parameter
cDas 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.
sizeDie 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.

Parameter
cDas Zeichen, mit dem der String auf der linken Seite aufgefüllt werden soll. c muß größer 0 sein.
sizeDie 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.

Rückgabe
Gibt Anzahl Bytes zurück, die durch den String belegt werden oder 0, wenn der String Leer ist.
Siehe auch
int ppl6::CWString::Sprintf ( const char *  fmt,
  ... 
)
int ppl6::CWString::StrCaseCmp ( const char *  str,
int  size = 0 
) const
Rückgabe
Ist der String kleiner als der mit str angegebene, wird ein negativer Wert zurückgegeben, ist er identisch, wird 0 zurückgegeben, ist er größer, erfolgt ein positiver Return-Wert.
int ppl6::CWString::StrCaseCmp ( const wchar_t *  str,
int  size = 0 
) const
Rückgabe
Ist der String kleiner als der mit str angegebene, wird ein negativer Wert zurückgegeben, ist er identisch, wird 0 zurückgegeben, ist er größer, erfolgt ein positiver Return-Wert.
int ppl6::CWString::StrCaseCmp ( const CString str,
int  size = 0 
) const
Rückgabe
Ist der String kleiner als der mit str angegebene, wird ein negativer Wert zurückgegeben, ist er identisch, wird 0 zurückgegeben, ist er größer, erfolgt ein positiver Return-Wert.
int ppl6::CWString::StrCaseCmp ( const CWString str,
int  size = 0 
) const
Rückgabe
Ist der String kleiner als der mit str angegebene, wird ein negativer Wert zurückgegeben, ist er identisch, wird 0 zurückgegeben, ist er größer, erfolgt ein positiver Return-Wert.
int ppl6::CWString::StrCmp ( const char *  str,
int  size = 0 
) const
Rückgabe
Ist der String kleiner als der mit str angegebene, wird ein negativer Wert zurückgegeben, ist er identisch, wird 0 zurückgegeben, ist er größer, erfolgt ein positiver Return-Wert.
int ppl6::CWString::StrCmp ( const wchar_t *  str,
int  size = 0 
) const
Rückgabe
Ist der String kleiner als der mit str angegebene, wird ein negativer Wert zurückgegeben, ist er identisch, wird 0 zurückgegeben, ist er größer, erfolgt ein positiver Return-Wert.
int ppl6::CWString::StrCmp ( const CString str,
int  size = 0 
) const
Rückgabe
Ist der String kleiner als der mit str angegebene, wird ein negativer Wert zurückgegeben, ist er identisch, wird 0 zurückgegeben, ist er größer, erfolgt ein positiver Return-Wert.
int ppl6::CWString::StrCmp ( const CWString str,
int  size = 0 
) const
Rückgabe
Ist der String kleiner als der mit str angegebene, wird ein negativer Wert zurückgegeben, ist er identisch, wird 0 zurückgegeben, ist er größer, erfolgt ein positiver Return-Wert.
int ppl6::CWString::Strcpy ( const char *  str)

Mit dieser Funktion wird dem String ein Wert zugewiesen.

Parameter
[in]strPointer auf einen 0-terminierten C-String im UTF-8-Format
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
void ppl6::CWString::StripSlashes ( )
int ppl6::CWString::Strncpy ( const char *  str,
int  size 
)

Mit dieser Funktion wird dem String ein Wert zugewiesen.

Parameter
[in]strEin Pointer auf einen UTF-8 kodierten C-String, der in die String-Klasse kopiert werden soll.
[in]sizeOptionaler 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.
Rückgabe
Bei Erfolg liefert die Funktion true (1) zurück, sonst false (0).
Zu beachten
Bei erfolgreichem Setzen des Strings wird die Funktion CVar::Change aufgerufen, die ihrerseits eine Callback-Funktion aufruft, sofern diese definiert wurde.
Siehe auch
Zu beachten
Standardmäßig erwartet die Klasse bei Übergabe von "char *", "const char *" oder der CString-Klasse, dass die darin enthaltenen Strings UTF-8 kodiert sind. Dieses Verhalten kann man aber beliebig ändern.

Mit der Funktion ppl6::SetGlobalEncoding kann man das Encoding für alle CWStrings auf globaler Ebene ändern, mit der Memberfunction ppl6::CWString::SetExtEncoding kann man die Kodierung für eine einzelne Instanz der CWString-Klasse ändern.
Siehe auch
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

Parameter
charsgibt an, wieviele Zeichen abgeschnitten werden sollen
void ppl6::CWString::TrimR ( int  chars)

Schneidet Zeichen auf der rechten Seite des Strings ab

Parameter
charsgibt 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".

Achtung
Unter UNIX (und möglicherweise anderen Betriebssystemen) werden die Lokalisationseinstellungen der Umgebung nicht automatisch übernommen, sondern stehen standardmäßig auf "C". Dadurch werden nur US-ASCII (ASCII 32 bis 127) umgewandelt. Man sollte daher nach Programmstart mit "setlocale" die gewünschte Spracheinstellung vornehmen.
Beispiel:
#include <locale.h>
...
setlocale(LC_CTYPE,"de_DE.UTF-8");
void ppl6::CWString::UCWords ( )
Beschreibung:
Diese Funktion wandelt die Anfangsbuchstaben aller im String enthaltenen Wörter in Großbuchstaben um.
int ppl6::CWString::VaSprintf ( const char *  fmt,
va_list  args 
)

Erzeugt einen formatierten String. Erzeugt einen formatierten String

Parameter
fmtDer Formatstring
argsPointer auf Liste der Parameter. Muss zuvor mit va_start initialisiert worden sein.
Example:
void MyFunction(const char *fmt, ...)
{
CString String;
va_list args;
va_start(args, fmt);
String.VaSprintf(fmt,args);
va_end(args);
printf ("Ergebnis: %s",(char*)String);
}
int ppl6::CWString::Vasprintf ( const char *  fmt,
va_list  args 
)

Erzeugt einen formatierten String

Parameter
fmtDer Formatstring
argsPointer auf Liste der Parameter. Muss zuvor mit va_start initialisiert worden sein.
Example:
void MyFunction(const char *fmt, ...)
{
CWString String;
va_list args;
va_start(args, fmt);
String.VaSprintf(fmt,args);
va_end(args);
printf ("Ergebnis: %s",(char*)String);
}

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.

Format des Formatstrings

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.

Die Zeichen für die Flags

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.

Die Feldbreite

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.

Die Genauigkeit

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.

Der Längenmodifikator

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).
    

Der Umwandlungsspezifikator

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 ‘%%’.

Dokumentation der Datenelemente

wchar_t* ppl6::CWString::buffer
private
size_t ppl6::CWString::buffersize
private
size_t ppl6::CWString::bufferused
private
char* ppl6::CWString::extbuffer
private
size_t ppl6::CWString::extbuffersize
private
char ppl6::CWString::extencoding[32]
private
void* ppl6::CWString::iconvexport
private
void* ppl6::CWString::iconvimport
private
size_t ppl6::CWString::len
private
CArray* ppl6::CWString::matches
private
ppluint8 ppl6::CVar::type
protectedinherited

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Dateien: