g_strdup ()

gchar*      g_strdup                        (const gchar *str);

Дублирует строку. Если параметр str равен NULL возвращает NULL. Возвращаемая строка должна освобождаться когда больше не нужна.

g_strndup ()

gchar*      g_strndup                       (const gchar *str,
                                             gsize n);

Дублирует первые n символов строки, возвращает вновь распределённый буфер длиной n + 1 символ который всегда nul-terminated. Если str меньше чем n символов, буфер дополняется нулями (nuls). Если str равен NULL возвращается NULL. Возвращаемая строка должна освобождаться когда больше не нужна.

g_strdupv ()

gchar**     g_strdupv                       (gchar **str_array);

Копирует NULL-завершённый массив строк. Новый массив освобождается сначала освобождая каждую строку, затем непосредственно сам массив. g_strfreev() делает это за вас. Если вызвать с значением NULL, g_strdupv() просто вернёт NULL.

g_strnfill ()

gchar*      g_strnfill                      (gsize length,
                                             gchar fill_char);

Создаёт новую строку длинной length символов на всю длину заполненную символами fill_char. Возвращаемая строка должна освобождаться когда больше не нужна.

g_stpcpy ()

gchar*      g_stpcpy                        (gchar *dest,
                                             const char *src);

Копирует nul-завершённую строку в буфер dest, включая замыкающий nul и возвращает указатель на завершающий nul байт. Это полезно при соединении нескольких строк вместе без необходимости неоднократного сканирования конца.

g_strstr_len ()

gchar*      g_strstr_len                    (const gchar *haystack,
                                             gssize haystack_len,
                                             const gchar *needle);

Ищет строку haystack до первого появления строки needle, ограничивая длину поиска значением haystack_len.

g_strrstr ()

gchar*      g_strrstr                       (const gchar *haystack,
                                             const gchar *needle);

Ищет строку haystack до последнего совпадения строки needle.

g_strrstr_len ()

gchar*      g_strrstr_len                   (const gchar *haystack,
                                             gssize haystack_len,
                                             const gchar *needle);

Ищет строку haystack до последнего совпадения строки needle, ограничивая длину поиска значением haystack_len.

g_str_has_prefix ()

gboolean    g_str_has_prefix                (const gchar *str,
                                             const gchar *prefix);

Определяет начинается ли строка str с префикса prefix.

Начиная с версии 2.2

g_str_has_suffix ()

gboolean    g_str_has_suffix                (const gchar *str,
                                             const gchar *suffix);

Определяет заканчивается ли строка str суффиксом suffix.

Начиная с версии 2.2

g_strlcpy ()

gsize       g_strlcpy                       (gchar *dest,
                                             const gchar *src,
                                             gsize dest_size);

Переносимая оболочка для вызова strlcpy() на системах которые имеют эту функцию она просто вызывает её, а на системах где нет strlcpy() эмулирует её. Копирует src в dest; dest гарантированно будет nul-завершённой; src должна быть nul-terminated; dest_size является размером буфера, а не количеством символов для копирования. Предостережение: strlcpy() более безопасна чем strcpy() или strncpy(), но если вы действительно хотите избежать проблем, то лучше используйте g_strdup().

g_strlcat ()

gsize       g_strlcat                       (gchar *dest,
                                             const gchar *src,
                                             gsize dest_size);

Переносимая оболочка функции strlcat(), на системах где нет этой функции она её эмулирует. Добавляет nul-завершённую строку src в dest, гарантирует nul-заврершённую dest. Полный размер dest не превышает dest_size. Предостережение: это возможно более безопасная альтернатива для strcat() или strncat(), но для действительно безопасного соединения лучше использовать g_strconcat().

g_strdup_printf ()

gchar*      g_strdup_printf                 (const gchar *format,
                                             ...);

Аналогична для стандартной C функции sprintf() но безопасней, так как она рассчитывает максимальное требуемое пространство и распределяет память содержащую результат. Возвращаемая строка должна освобождаться когда больше не нужна.

g_strdup_vprintf ()

gchar*      g_strdup_vprintf                (const gchar *format,
                                             va_list args);

Похожа на стандартную C функцию vsprintf() но безопасней, так как она рассчитывает максимальное требуемое свободное пространство и распределяет память содержащую результат. Возвращаемая строка должна освобождаться когда больше не нужна.

Смотрите также g_vasprintf(), которая отличается некоторой функциональностью, но дополняет возвращаемый результат длинной распредделённой строки.

g_printf ()

gint        g_printf                        (gchar const *format,
                                             ...);

Реализация стандартной функции printf() которая поддерживает параметры позиционирования, как определено в Single Unix Specification.

Начиная с версии 2.2

g_vprintf ()

gint        g_vprintf                       (gchar const *format,
                                             va_list args);

Реализация стандартной функции vprintf() которая поддерживает параметры позиционирования, как определено в Single Unix Specification.

Начиная с версии 2.2

g_fprintf ()

gint        g_fprintf                       (FILE *file,
                                             gchar const *format,
                                             ...);

Реализация стандартной функции fprintf() которая поддерживает параметры позиционирования, как определено в Single Unix Specification.

Начиная с версии 2.2

g_vfprintf ()

gint        g_vfprintf                      (FILE *file,
                                             gchar const *format,
                                             va_list args);

Реализация стандартной функции fprintf() которая поддерживает параметры позиционирования, как определено в Single Unix Specification.

Начиная с версии 2.2

g_sprintf ()

gint        g_sprintf                       (gchar *string,
                                             gchar const *format,
                                             ...);

Реализация стандартной функции sprintf() которая поддерживает параметры позиционирования, как определено в Single Unix Specification.

Начиная с версии 2.2

g_vsprintf ()

gint        g_vsprintf                      (gchar *string,
                                             gchar const *format,
                                             va_list args);

Реализация стандартной функции vsprintf() которая поддерживает параметры позиционирования, как определено в Single Unix Specification.

Начиная с версии 2.2

g_snprintf ()

gint        g_snprintf                      (gchar *string,
                                             gulong n,
                                             gchar const *format,
                                             ...);

Более безопасный вариант стандартной функции sprintf(). Гарантирует что вывод не превысит n символов (включая завершающий нулевой символ (nul character)), поэтому переполнение буфера невозможно.

Смотрите также g_strdup_printf().

В версиях GLib до 1.2.3, эта функция может возвращать -1 если вывод был усечён, а усечённая строка может быть не nul-завершённой. В версии до 1.3.12, эта функция возвращает длину строки вывода.

Возвращаемое значение g_snprintf() согласуется с функцией snprintf() как стандартизировано в ISO C99. Помните что это отличается от традиционной snprintf(), которая возвращает длину строки вывода.

Форматируемая строка может содержать параметры позиционирования, как определено в Single Unix Specification.

g_vsnprintf ()

gint        g_vsnprintf                     (gchar *string,
                                             gulong n,
                                             gchar const *format,
                                             va_list args);

Более безопасный вариант стандартной функции vsprintf(). Вывод гарантировано не превысит n символов (включая завершающий символ), поэтому переполнение буфера не возможно.

Смотрите также g_strdup_vprintf().

В версиях GLib до 1.2.3, эта функция может возвращать -1 если вывод был усечён, а усечённая строка может быть не nul-завершённой. В версии до 1.3.12, эта функция возвращает длину строки вывода.

Возвращаемое значение g_vsnprintf() согласуется с функцией vsnprintf() как стандартизировано в ISO C99. Помните что это отличается от традиционной vsnprintf(), которая возвращает длину строки вывода.

Форматируемая строка может содержать параметры позиционирования, как описано в Single Unix Specification.

g_vasprintf ()

gint        g_vasprintf                     (gchar **string,
                                             gchar const *format,
                                             va_list args);

Реализация функции GNU vasprintf() которая поддерживает параметры позиционирования, как описано в Single Unix Specification. Эта функция похожа на g_vsprintf(), но она распределяет строку содержащую вывод, а не помещает вывод в буфер распределённый вами заранее.

Начиная с версии 2.4

g_printf_string_upper_bound ()

gsize       g_printf_string_upper_bound     (const gchar *format,
                                             va_list args);

Расчитывает необходимое пространство необходимое для сохранения вывода функции sprintf().

g_ascii_isalnum ()

gboolean    g_ascii_isalnum                 (gchar c);

Определяет являются ли символы алфавитно-цифровыми.

В отличие от стандартной библиотечной C функции isalnum(), эта функция распознаёт только стандартные ASCII символы и игнорирует локаль, возвращает FALSE для всех не-ASCII символов. Также в отличие от стандартной библиотечной функции, эта принимает char, а не int, поэтому не вызывайте её в конце файла EOF и не нужно приводить к guchar перед помещением возможно не-ASCII символа.

g_ascii_isalpha ()

gboolean    g_ascii_isalpha                 (gchar c);

Определяет является ли символ алфавитным (то есть буквой).

В отличие от стандартной библиотечной функции isalpha(), эта распознаёт только стандартные ASCII буквы и игнорирует локаль, возвращает FALSE для всех не-ASCII символов. Также в отличие от стандартной библиотечной функции, эта принимает char, а не int, поэтому не вызывается в конце файла EOF и не требует приведения типа к guchar перед помещением возможно не-ASCII символа.

g_ascii_iscntrl ()

gboolean    g_ascii_iscntrl                 (gchar c);

Определяет является ли символ управляющим символом.

В отличие от стандартной библиотечной функции iscntrl(), эта рассматривает только стандартные символы управления ASCII и игнорирует локаль, возвращает FALSE для всех не-ASCII символов. Также в отличие от стандартной функции, эта принимает char, вместо int, поэтому не вызывается в конце файла EOF и не требует приведения типа к guchar перед помещением возможно не-ASCII символа.

g_ascii_isdigit ()

gboolean    g_ascii_isdigit                 (gchar c);

Определяет является ли символ цифрой (0-9).

В отличие от стандартной библиотечной функции isdigit(), эта принимает char, вместо int, поэтому не вызывается в конце файла EOF и не требует приведения типа к guchar перед помещением возможно не-ASCII символа.

g_ascii_isgraph ()

gboolean    g_ascii_isgraph                 (gchar c);

Определяет является ли символ печатным и не прбелом.

В отличие от стандартной библиотечной функции isgraph(), эта распознаёт только стандартные символы ASCII и игнорирует локаль, возвращает FALSE для всех не-ASCII символов. Также в отличие от стандартной библиотечной функции, эта принимает char, вместо int, поэтому не должна вызываться в конце файла EOF и не требует приведения типа к guchar перед помещением возможно не-ASCII символа.

g_ascii_islower ()

gboolean    g_ascii_islower                 (gchar c);

Определяет является ли символ буквой ASCII в нижнем регистре.

В отличие от стандартной библиотечной функции islower(), эта принимает только стандартные ASCII символы и игнорирует локаль (locale), возвращает FALSE для всех не-ASCII символов. Также в отличие от стандартной библиотечной функции, эта принимает char, а не int, поэтому не вызывайте её на EOF, и нет необходимости приведения к guchar перед помещением возможно не-ASCII символа в функцию.

g_ascii_isprint ()

gboolean    g_ascii_isprint                 (gchar c);

Определяет является ли символ печатным символом.

В отличие от стандартной библиотечной функции isprint(), эта принимает только стандартные ASCII символы и игнорирует локаль, возвращает FALSE для всех не-ASCII символов. Также в отличие от стандартной библиотечной функции, эта принимает char, а не int, поэтому не вызывайте её в EOF и не нужно приводить к guchar перед помещением возможно не-ASCII символа.

g_ascii_ispunct ()

gboolean    g_ascii_ispunct                 (gchar c);

Определяет является ли символ символом пунктуации.

В отличие от стандартной библиотечной функции ispunct(), это принимает только стандартные ASCII символы и игнорирует локаль, возвращает FALSE для всех не-ASCII символов. Также в отличие от стандартной библиотечной функции, эта принимает char, а не int, поэтому не вызывайте её в EOF и не нужно приводить к guchar перед помещением возможно не-ASCII символа.

g_ascii_isspace ()

gboolean    g_ascii_isspace                 (gchar c);

Определяет является ли символ символом табуляции, пробела или символом пустой строки (white-space character).

В отличие от стандартной библиотечной функции isspace(), эта принимает только стандартные ASCII символы white-space и игнорирует локаль, возвращает FALSE для всех не-ASCII символов. Также в отличие от стандартной библиотечной функции, эта принимает char, а не int, поэтому не вызывайте её в EOF и не нужно приводить тип к guchar перед помещением возможно не-ASCII символа.

g_ascii_isupper ()

gboolean    g_ascii_isupper                 (gchar c);

Определяет является ли символ символом ASCII верхнего регистра.

В отличие от стандартной библиотечной функции isupper(), это принимает только стандартные ASCII символы и игнорирует локаль, возвращает FALSE для всех не-ASCII символов. Также в отличие от стандартной библиотечной функции, эта принимает тип char, а не int, поэтому не вызывайте её в EOF и не нужно приводить тип к guchar перед помещением возможно не-ASCII символа.

g_ascii_isxdigit ()

gboolean    g_ascii_isxdigit                (gchar c);

Определяет является ли символ шестнадцатеричным-цифровым символом.

В отличие от стандартной библиотечной функции isxdigit(), эта принимает тип char, а не int, поэтому не нужно вызывать её в EOF и не нужно приводить тип к guchar перед помещением вохможно не-ASCII символа.

g_ascii_digit_value ()

gint        g_ascii_digit_value             (gchar c);

Определяет числовое значение символа в виде десятичной цифры. Отличается от g_unichar_digit_value() потому что принимает тип char, поэтому не беспокойтесь о дополнительном знаке (+ или -) если символы со знаком.

g_ascii_xdigit_value ()

gint        g_ascii_xdigit_value            (gchar c);

Определяет числовое значение символа как шестнадцатеричное число. Отличается от g_unichar_xdigit_value() так как принимает символ, поэтому нет смысла беспокоится о знаке если символы со знаком.

g_ascii_strcasecmp ()

gint        g_ascii_strcasecmp              (const gchar *s1,
                                             const gchar *s2);

Сравнивает две строки, игнорирует регистр ASCII символов.

В отличие от BSD функции strcasecmp(), эта принимает только стандартные ASCII буквы и игнорирует локаль, обрабатывая все не-ASCII байты как будто они не буквы.

Эта функция должна использоваться только в строках кодировка байт которых соответствует ASCII литерам всегда представляя самих себя. Это включает UTF-8 и ISO-8859-* символы, но не двойную кодировку байт как в Windows Codepage 932, где завершающий байт двух-байтовых символов включает все ASCII буквы. Если вы сравниваете две CP932 строки используя эту функцию, то вы получите неправильный результат.

g_ascii_strncasecmp ()

gint        g_ascii_strncasecmp             (const gchar *s1,
                                             const gchar *s2,
                                             gsize n);

Сравнивает s1 и s2, игнорирует регистр ASCII символов и любые символы после первых n в каждой строке.

В отличие от BSD функции strcasecmp(), эта функция понимает только стандартные ASCII буквы и игнорирует локаль, обрабатывая все не-ASCII символы как не буквы.

Тоже самое предупреждение как и для g_ascii_strcasecmp(): Используйте эту функцию только для строк известной кодировки где байты соответствуют ASCII литерам и представляют самих себя.

g_ascii_strup ()

gchar*      g_ascii_strup                   (const gchar *str,
                                             gssize len);

Конвертирует все символы нижнего регистра ASCII букв в верхний регистр букв ASCII.

g_ascii_strdown ()

gchar*      g_ascii_strdown                 (const gchar *str,
                                             gssize len);

Конвертирует все символы ASCII верхнего регистра в символы ASCII нижнего регистра.

g_ascii_tolower ()

gchar       g_ascii_tolower                 (gchar c);

Конвертирует символ в нижний регистр ASCII.

В отличие от стандартной библиотечной функции tolower(), эта принимает только стандартные ASCII буквы и игнорирует локаль, возвращает все не-ASCII символы не изменёнными, даже если они являются буквами нижнего регистра в специальном наборе символов. Также в отличие от стандартной библиотечной функции, эта принимает и возвращает тип char, а не int, поэтому не вызывайте её в EOF и не беспокойтесь о приведении типа к guchar перед помещением возможно не-ASCII символа.

g_ascii_toupper ()

gchar       g_ascii_toupper                 (gchar c);

Ковертирует символ в ASCII верхнего регистра.

В отличие от стандартной библиотечной функции toupper(), эта принимает только стандартные ASCII буквы и игнорирует локаль, возвращает все не-ASCII символы без изменений, даже если они являются символами верхнего регистра в специальном наборе символов. Также в отличие от стандартной библиотечной функции, эта принимает и возвращает тип char, а не int, поэтому не вызывайте её в EOF и не беспокойтесь о приведении типа к guchar перед помещением в неё возможно не-ASCII символа.

g_string_ascii_up ()

GString*    g_string_ascii_up               (GString *string);

Конвертирует все буквы ASCII нижнего регистра в буквы верхнего регистра ASCII.

g_string_ascii_down ()

GString*    g_string_ascii_down             (GString *string);

Конвертирует все буквы верхнего регистра ASCII в нижний регистр букв ASCII.

g_strup ()

gchar*      g_strup                         (gchar *string);

Конвертирует строку в верхний регистр.

g_strdown ()

gchar*      g_strdown                       (gchar *string);

Конвертирует строку в нижний регистр.

g_strcasecmp ()

gint        g_strcasecmp                    (const gchar *s1,
                                             const gchar *s2);

Не чувствительное к регистру сравнение строк, соответствует стандартной функции strcasecmp() на платформах которые поддерживают её.

g_strncasecmp ()

gint        g_strncasecmp                   (const gchar *s1,
                                             const gchar *s2,
                                             guint n);

Сравнение строк без учёта регистра, соответствует стандартной функции strncasecmp() на платформах которые её поддерживают. Она похожа на g_strcasecmp() за исключением того что сравнивает только первые n символов в строках.

g_strreverse ()

gchar*      g_strreverse                    (gchar *string);

Переворачивает строку. Например, g_strreverse ("abcdef") выдаст результат "fedcba".

Помните что g_strreverse() не работает в UTF-8 строках содержащих многобайтные символы. Для этих случаев используйте g_utf8_strreverse().

g_ascii_strtoll ()

gint64      g_ascii_strtoll                 (const gchar *nptr,
                                             gchar **endptr,
                                             guint base);

Конвертирует строку в значение gint64. Эта функция ведёт себя как стандартная функция strtoll() выполняемая в C локали. Она выполняет это без фактического изменения текущей локали, так как это было бы не потоко-безопасным (thread-safe).

Эта функция обычно используется когда читаются конфигурационные файлы или другой не пользовательский ввод который должен быть независим от локали. Для обработки пользовательского ввода вы должны обычно использовать чувствительную к локали (locale-sensitive) системную функцию strtoll().

Если текущее значение вызвало бы переполнение буфера, возвращается G_MAXINT64 или G_MININT64, а ERANGE сохраняется в errno. Если base вне допустимого диапазона, возвращается ноль, а EINVAL сохраняется в errno. Если преобразование строки не удалось, возвращается ноль, а endptr возвращает nptr (если endptr это не-NULL).

Начиная с версии 2.12

g_ascii_strtoull ()

guint64     g_ascii_strtoull                (const gchar *nptr,
                                             gchar **endptr,
                                             guint base);

Конвертирует строку в значение guint64. Эта функция ведёт себя также как стандартная strtoull() выполняющаяся в C локали. Она работает без фактического изменения текущей локали, так как это было бы не потоко-безопасным (thread-safe).

Эта функция обычно используется при чтении конфигурационных файлов или другого не пользовательского ввода который должен быть независимым от локали. Для обработки пользовательского ввода вы должны обычно использовать чувствительную к локали (locale-sensitive) системную функцию strtoull().

Если правильное значение вызывает переполнение буфера, то возвращается G_MAXUINT64, а ERANGE сохраняется в errno. Если base вне допустимого диапазона, возвращается ноль, а EINVAL сохраняется в errno. Если преобразование строки не удалось, возвращается ноль, а endptr возвращает nptr (если endptr не-NULL).

Начиная с версии 2.2

G_ASCII_DTOSTR_BUF_SIZE

#define G_ASCII_DTOSTR_BUF_SIZE (29 + 10)

Правильный размер буфера для помещения в g_ascii_dtostr(). Этого гарантированно достаточно для всего вывода функции в системах с 64bit IEEE-совместимым doubles.

Обычное использование выглядит так:

  char buf[G_ASCII_DTOSTR_BUF_SIZE];

  fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value));

g_ascii_strtod ()

gdouble     g_ascii_strtod                  (const gchar *nptr,
                                             gchar **endptr);

Конвертирует строку в gdouble значение. Эта функция ведёт себя как стандартная функция strtod() работающая в C лосали. Она работает без фактического изменения текущей локали, так как это было бы не потоко-безопасным (thread-safe).

Эта функция обычно используется когда читаются конфигурационные файлы или другой не пользовательский ввод который должен быть не зависим от локали. Для обработки ввода пользователя вы должны обычно использовать чувствительную к локали системную функцию strtod().

Для конвертации из gdouble в строку чувствительным к локали способом, используйте g_ascii_dtostr().

Если правильное значение вызвало бы переполнение буфера, возвращается плюс или минус HUGE_VAL (соответсвенно значению со знаком), а ERANGE сохраняется в errno. Если правильное значение вызвало бы антипереполнение буфера (underflow), возвращается ноль и ERANGE сохраняется в errno.

Эта функция сбрасывает errno перед вызовом strtod() так, чтобы вы могли надёжно обнаружить переполнение или антипереполнение буфера.

g_ascii_dtostr ()

gchar*      g_ascii_dtostr                  (gchar *buffer,
                                             gint buf_len,
                                             gdouble d);

Конвертирует gdouble в строку, используя '.' как десятичную точку.

Эта функция генерирует достаточно точно конвертированную с помощью g_ascii_strtod() строку, получая то же машинное число (machine-number) (на машинах с IEEE совместимым 64bit doubles). Гарантирует что результирующая строка не будет больше чем G_ASCII_DTOSTR_BUF_SIZE байт.

g_ascii_formatd ()

gchar*      g_ascii_formatd                 (gchar *buffer,
                                             gint buf_len,
                                             const gchar *format,
                                             gdouble d);

Конвертирует gdouble в строку, используя '.' как десятичную точку. Для форматирования числа вы помещаете строку формата в стиле printf(). Допускаются спецификаторы преобразования 'e', 'E', 'f', 'F', 'g' и 'G'.

Если вы просто хотите преобразовать в последовательную форму значение в строке, используйте g_ascii_dtostr().

g_strtod ()

gdouble     g_strtod                        (const gchar *nptr,
                                             gchar **endptr);

Конвертирует строку в gdouble значение. Она вызывает стандартную функцию strtod() для обработки конвертации, но если строка конвертирована не полностью она пытается конвертировать снова с помощью g_ascii_strtod() и возвращает лучшее соответствие.

Эта функция должна использоваться редко. В обычных ситуациях когда читаются числа не для применения человеком используется g_ascii_strtod(). Вы должны её использовать только когда знаете что ожидается оба формата чисел и в локали и в C формате. Убедитесь что вы не поместили строки такие как разделённые запятыми списки значений, так как запятая может интерпретироваться как десятичная точка в некоторых локалях, вызывая неожиданный результат.

g_strchug ()

gchar*      g_strchug                       (gchar *string);

Удаляет все символы табуляций (whitespace) из строки, но перемещает символы вперёд.

Эта функция не распределяет и не перераспределяет никакую память; она изменяет string на месте. Указатель на string возвращается чтобы позволить вложенные функции.

Также смотрите g_strchomp() и g_strstrip().

g_strchomp ()

gchar*      g_strchomp                      (gchar *string);

Удаляет замыкающие табуляции из строки.

Эта функция не распределяет и не перераспределяет никакую память; она изменяет string на месте. Указатель на string возвращается чтобы позволить вложенные функции.

Также смотрите g_strchug() и g_strstrip().

g_strstrip()

#define     g_strstrip( string )

Удаляет начальные и завершающие пробелы (whitespace) из строки. Смотрите g_strchomp() и g_strchug().

g_strdelimit ()

gchar*      g_strdelimit                    (gchar *string,
                                             const gchar *delimiters,
                                             gchar new_delimiter);

Конвертирует любые разделительные символы (delimiter characters) в string в new_delimiter. Любые найденные в string символы delimiters изменяются на new_delimiter. Изменяет строку string на месте и возвращает непосредственно string, а не копию. Возвращаемое значение позволяет вложение, такое как g_ascii_strup (g_strdelimit (str, "abc", '?')).

G_STR_DELIMITERS

#define	 G_STR_DELIMITERS	"_-|> <."

Стандартные разделительные символы используемые в g_strdelimit().

g_strescape ()

gchar*      g_strescape                     (const gchar *source,
                                             const gchar *exceptions);

Выводит специальные символы '\b', '\f', '\n', '\r', '\t', '\' и '"' в строке source и вставляет перед ними '\'. Дополнительно все символы в диапазоне 0x01-0x1F (все ниже SPACE) м в диапазоне 0x7F-0xFF (все не-ASCII символы) заменяются с помощью '\' сопровождаемого их восьмеричным представлением. Символы поставляемые в exceptions не выводятся.

g_strcompress() выполняет обратную конвертацию.

g_strcompress ()

gchar*      g_strcompress                   (const gchar *source);

Заменяет все escape-символы их однобайтными эквивалентами. Вы полняет обратную конвертацию для g_strescape().

g_strcanon ()

gchar*      g_strcanon                      (gchar *string,
                                             const gchar *valid_chars,
                                             gchar substitutor);

Каждый символ в string, если символ не valid_chars, заменяет символом substitutor. Изменяет строку string на месте и возвращает непосредственно string, а не копию. Возвращаемое значение допускает вложенность, такую как g_ascii_strup (g_strcanon (str, "abc", '?')).

g_strsplit ()

gchar**     g_strsplit                      (const gchar *string,
                                             const gchar *delimiter,
                                             gint max_tokens);

Разбивает строку на максимум max_tokens частей, используя разделитель delimiter. Если max_tokens достигнут, остаток строки string прикрепляется к последней лексеме.

Как специальный случай, результатом разбиения пустой строки "" является пустой вектор, а не вектор содержащий единственную строку. Причиной такого специального случая является то, что обычно представление пустого вектора полезнее чем обработка пустых элементов. Если вам нужно представить пустые элементы, вы должны проверить пустую строку перед вызовом g_strsplit().

g_strsplit_set ()

gchar**     g_strsplit_set                  (const gchar *string,
                                             const gchar *delimiters,
                                             gint max_tokens);

Разбивает string на множество лексем не содержащих любой из символов в delimiter. Лексемы это (возможно пустые) длинные строки которые не содержат любой из символов находящихся в delimiters. Если достигнут max_tokens, остаток предложения прикрепляется к последней лексеме.

Например результатом g_strsplit_set ("abc:def/ghi", ":/", -1) будет NULL-завершённый вектор содержащий дерево строк "abc", "def", и "ghi".

Результатом g_strsplit_set (":def/ghi:", ":/", -1) NULL-завершённый вектор содержащий четыре строки "", "def", "ghi", и "".

Как специальный случай, результатом разбиения пустой строки "" является пустой вектор, а не вектор содержащий единственную строку. Причиной такого специального случая является то, что обычно представление пустого вектора полезнее чем обработка пустых элементов. Если вам нужно представить пустые элементы, вы должны проверить пустую строку перед вызовом g_strsplit().

Помните что эта функция работает с байтами а не с символами, поэтому она не может использоваться для разграничения UTF-8 строк чем нибудь кроме ASCII символов.

Начиная с версии 2.4

g_strfreev ()

void        g_strfreev                      (gchar **str_array);

Освобождает NULL-завершённый массив строк, и непосредственно массив. Если вызвана для значения NULL, g_strfreev() просто возвращается.

g_strconcat ()

gchar*      g_strconcat                     (const gchar *string1,
                                             ...);

Соединяет все полученные строки в одну длинную строку. Возвращаемая строка должна быть освобождена когда больше не нужна.

g_strjoin ()

gchar*      g_strjoin                       (const gchar *separator,
                                             ...);

Объединяет множество строк вместе в форме одной длинной строки, с необязательным разделителем separator вставляемым между ними.

g_strjoinv ()

gchar*      g_strjoinv                      (const gchar *separator,
                                             gchar **str_array);

Объединяет множество строк вместе в форме одной длинной строки, с необязательным separator вставляемым между каждой из них.

g_strv_length ()

guint       g_strv_length                   (gchar **str_array);

Возвращает длину полученного NULL-завершённого массива строк str_array.

Начиная с версии 2.6

g_strerror ()

const gchar* g_strerror                     (gint errnum);

Возвращает строку соответствующую данному коду ошибки (error code), например "no such process". Эта функция включена так как не все платформы поддерживают функцию strerror().

g_strsignal ()

const gchar* g_strsignal                    (gint signum);

Возвращает строку описывающую полученный сигнал, например "Segmentation fault". Эта функция включена так как не на всех платформах поддерживается функция strsignal().