glib provides a number of functions for string handling; some are unique to glib, and some solve portability concerns. They all interoperate nicely with the glib memory allocation routines.
For those interested in a better string than gchar*, there’s also a GString type. It isn’t covered in this book, but documentation is available at http://www.gtk.org/.
[code lang=”cpp”]#include <glib.h>
gint g_snprintf(gchar* buf, gulong n, const gchar* format, …);
gint g_strcasecmp(const gchar* s1, const gchar* s2);
gint g_strncasecmp(const gchar* s1, const gchar* s2, guint n);
[/code]
Figure 2-7. Portability Wrappers
One of the annoying things about C is that it provides the crash-causing, security- hole-creating, generally evil sprintf(), but the relatively safe and widely implemented snprintf() is a vendor extension. g_snprintf() wraps native snprintf() on platforms that have it, and provides an implementation on those that don’t. So you can say goodbye to sprintf() forever. Even better: classically, snprintf() does not guarantee that it will NULL-terminate the buffer it fills. g_snprintf() does.
g_strcasecmp() and g_strncasecmp() perform a case-insensitive comparison of two strings, optionally with a maximum length. strcasecmp() is available on many platforms but not universally, so using glib instead is advisable.
The functions in Figure 2-8 modify a string in-place: the first two convert the string to lowercase or uppercase, respectively, while g_strreverse() reverses its characters. g_strchug() and g_strchomp() “chug” the string (remove leading spaces), or “chomp” it (remove trailing spaces). These last two return the string, in addition to modifying it in-place; in some cases it may be convenient to use the return value. There is a macro, g_strstrip(), which combines both functions to remove both leading and trailing spaces; it is used just as the individual functions are.
[code lang=”cpp”]
#include <glib.h>
void g_strdown(gchar* string);
void g_strup(gchar* string);
void g_strreverse(gchar* string);
gchar* g_strchug(gchar* string);
gchar* g_strchomp(gchar* string);
[/code]
Figure 2-8. In-place string modifications
Figure 2-9 shows a few more semi-standard functions glib wraps. g_strtod is like strtod()—it converts string nptr to a double—with the exception that it will also at- tempt to convert the double in the “C” locale if it fails to convert it in the user ’s default locale. *endptr is set to the first unconverted character, i.e. any text after the number representation. If conversion fails, *endptr is set to nptr. endptr may be NULL, causing it to be ignored.
g_strerror() and g_strsignal() are like their non-g_ equivalents, but portable. (They return a string representation for an errno or a signal number.)
[code lang=”cpp”]
#include <glib.h>
gdouble g_strtod(const gchar* nptr, gchar** endptr);
gchar* g_strerror(gint errnum);
gchar* g_strsignal(gint signum);
[/code]
Figure 2-9. String Conversions
Figure 2-10 shows glib’s rich array of functions for allocating strings. Unsurprisingly, g_strdup() and g_strndup() produce an allocated copy of str or the first n characters of str. For consistency with the glib memory allocation functions, they return NULL if passed a NULL pointer. The printf() variants return a formatted string. g_strescape escapes any \ characters in its argument by inserting another \ before them, returning the escaped string. g_strnfill() returns a string of size length filled with fill_char. g_strdup_printf() deserves a special mention; it is a simpler way to handle this common piece of code:
[code lang=”cpp”]
gchar* str = g_malloc(256);
g_snprintf(str, 256, "%d printf-style %s", 1, "format");
[/code]
Instead you could say this, and avoid having to figure out the proper length of the buffer to boot:
[code lang=”cpp”]
gchar* str = g_strdup_printf("%d printf-style %s", 1, "format");
[/code]
[code lang=”cpp”]
#include <glib.h>
gchar* g_strdup(const gchar* str);
gchar* g_strndup(const gchar* format, guint n);
gchar* g_strdup_printf(const gchar* format, …);
gchar* g_strdup_vprintf(const gchar* format, va_list args);
gchar* g_strescape(gchar* string);
gchar* g_strnfill(guint length, gchar fill_char);
[/code]
Figure 2-10. Allocating Strings
glib provides some convenient functions for concatenating strings, shown in Figure
2-11. g_strconcat() returns a newly-allocated string created by concatenating each
of the strings in the argument list. The last argument must be NULL, so g_strconcat()
knows when to stop. g_strjoin() is similar, but separator is inserted between each
string. If separator is NULL, no separator is used.
[code lang=”cpp”]
#include <glib.h>
gchar* g_strconcat(const gchar* string1, …);
gchar* g_strjoin(const gchar* separator, …);
[/code]
Figure 2-11. Concatenating strings
Finally, Figure 2-12 summarizes a few routines which manipulate NULL-terminated arrays of strings. g_strsplit() breaks string at each delimiter, returning a newly- allocated array. g_strjoinv() concatenates each string in the array with an optional separator, returning an allocated string. g_strfreev() frees each string in the array and then the array itself.
[code lang=”cpp”]
#include <glib.h>
gchar** g_strsplit(const gchar* string, const gchar* delimiter, gint max_tokens);
gchar* g_strjoinv(const gchar* separator, gchar** str_array);
void g_strfreev(gchar** str_array);
[/code]
Figure 2-12. Manipulating NULL-terminated string vectors
Source: Havoc Pennington. 1999. GTK Gnome Application Development. New York: New Riders Publishing