cha-glib.html

gtk 开发手册和参考文档。 包括gtk glib gdk等

            </p>
          </div>
          <p>
            <a href="cha-glib.html#FL-STRFORMATS">Figure 9</a>
            shows a few more semi-standard functions glib wraps.
            <tt class="FUNCTION">g_strtod</tt> is like <tt class= 
            "FUNCTION">strtod()</tt>---it converts string <span
            class="STRUCTNAME">nptr</span> to a double---with the
            exception that it will also attempt to convert the
            double in the <tt class="APPLICATION">"C"</tt> locale
            if it fails to convert it in the user's default locale.
            <span class="STRUCTNAME">*endptr</span> is set to the
            first unconverted character, i.e. any text after the
            number representation. If conversion fails, <span
            class="STRUCTNAME">*endptr</span> is set to <span
            class="STRUCTNAME">nptr</span>. <span class=
            "STRUCTNAME">endptr</span> may be <span class= 
            "STRUCTNAME">NULL</span>, causing it to be ignored.
          </p>
          <p>
            <tt class="FUNCTION">g_strerror()</tt> and <tt class= 
            "FUNCTION">g_strsignal()</tt> are like their non-<span
            class="STRUCTNAME">g_</span> equivalents, but portable.
            (They return a string representation for an <span
            class="STRUCTNAME">errno</span> or a signal number.)
          </p>
          <div class="FIGURE">
            <a name="FL-STRFORMATS"></a>
            <div class="FUNCSYNOPSIS">
              <a name="FL-STRFORMATS.SYNOPSIS"></a>
              <table border="0" bgcolor="#E0E0E0" width="100%">
                <tr>
                  <td>
<pre class="FUNCSYNOPSISINFO">
#include &lt;glib.h&gt;
</pre>
                  </td>
                </tr>
              </table>
              <p>
                <code><code class="FUNCDEF">gdouble <tt class= 
                "FUNCTION">g_strtod</tt></code>(const gchar* <tt
                class="PARAMETER"><i>nptr</i></tt>, gchar** <tt
                class="PARAMETER"><i>endptr</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strerror</tt></code>(gint <tt class= 
                "PARAMETER"><i>errnum</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strsignal</tt></code>(gint <tt class= 
                "PARAMETER"><i>signum</i></tt>);</code>
              </p>
            </div>
            <p>
              <b>Figure 9. String Conversions</b>
            </p>
          </div>
          <p>
            <a href="cha-glib.html#FL-STRDUP">Figure 10</a> shows
            glib's rich array of functions for allocating strings.
            Unsurprisingly, <tt class="FUNCTION">g_strdup()</tt>
            and <tt class="FUNCTION">g_strndup()</tt> produce an
            allocated copy of <span class="STRUCTNAME">str</span>
            or the first <span class="STRUCTNAME">n</span>
            characters of <span class="STRUCTNAME">str</span>. For
            consistency with the glib memory allocation functions,
            they return <span class="STRUCTNAME">NULL</span> if
            passed a <span class="STRUCTNAME">NULL</span> pointer.
            The <tt class="FUNCTION">printf()</tt> variants return
            a formatted string. <tt class="FUNCTION">
            g_strescape</tt> escapes any <span class="STRUCTNAME">
            \</span> characters in its argument by inserting
            another <span class="STRUCTNAME">\</span> before them,
            returning the escaped string. <tt class="FUNCTION">
            g_strnfill()</tt>returns a string of size <span class= 
            "STRUCTNAME">length</span> filled with <span class= 
            "STRUCTNAME">fill_char</span>.
          </p>
          <p>
            <tt class="FUNCTION">g_strdup_printf()</tt> deserves a
            special mention; it is a simpler way to handle this
            common piece of code:
          </p>
          <table border="0" bgcolor="#E0E0E0" width="100%">
            <tr>
              <td>
<pre class="PROGRAMLISTING">
&#13;  gchar* str = g_malloc(256);
  g_snprintf(str, 256, "%d printf-style %s", 1, "format");&#13;
</pre>
              </td>
            </tr>
          </table>
          <p>
            Instead you could say this, and avoid having to figure
            out the proper length of the buffer to boot:
          </p>
          <table border="0" bgcolor="#E0E0E0" width="100%">
            <tr>
              <td>
<pre class="PROGRAMLISTING">
&#13;  gchar* str = g_strdup_printf("%d printf-style %s", 1, "format");&#13;
</pre>
              </td>
            </tr>
          </table>
          <div class="FIGURE">
            <a name="FL-STRDUP"></a>
            <div class="FUNCSYNOPSIS">
              <a name="FL-STRDUP.SYNOPSIS"></a>
              <table border="0" bgcolor="#E0E0E0" width="100%">
                <tr>
                  <td>
<pre class="FUNCSYNOPSISINFO">
#include &lt;glib.h&gt;
</pre>
                  </td>
                </tr>
              </table>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strdup</tt></code>(const gchar* <tt
                class="PARAMETER"><i>str</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strndup</tt></code>(const gchar* <tt
                class="PARAMETER"><i>format</i></tt>, guint <tt
                class="PARAMETER"><i>n</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strdup_printf</tt></code>(const gchar*
                <tt class="PARAMETER"><i>format</i></tt>, <tt
                class="PARAMETER"><i>...</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strdup_vprintf</tt></code>(const
                gchar* <tt class="PARAMETER"><i>format</i></tt>,
                va_list <tt class="PARAMETER"><i>
                args</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strescape</tt></code>(gchar* <tt
                class="PARAMETER"><i>string</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strnfill</tt></code>(guint <tt class= 
                "PARAMETER"><i>length</i></tt>, gchar <tt class= 
                "PARAMETER"><i>fill_char</i></tt>);</code>
              </p>
            </div>
            <p>
              <b>Figure 10. Allocating Strings</b>
            </p>
          </div>
          <p>
            glib provides some convenient functions for
            concatenating strings, shown in <a href= 
            "cha-glib.html#FL-STRCONCAT">Figure 11</a>. <tt class= 
            "FUNCTION">g_strconcat()</tt> returns a newly-allocated
            string created by concatenating each of the strings in
            the argument list. The last argument must be <span
            class="STRUCTNAME">NULL</span>, so <tt class=
            "FUNCTION">g_strconcat()</tt> knows when to stop. <tt
            class="FUNCTION">g_strjoin()</tt> is similar, but <span
            class="STRUCTNAME">separator</span> is inserted between
            each string. If <span class="STRUCTNAME">
            separator</span> is <span class="STRUCTNAME">
            NULL</span>, no separator is used.
          </p>
          <div class="FIGURE">
            <a name="FL-STRCONCAT"></a>
            <div class="FUNCSYNOPSIS">
              <a name="FL-STRCONCAT.SYNOPSIS"></a>
              <table border="0" bgcolor="#E0E0E0" width="100%">
                <tr>
                  <td>
<pre class="FUNCSYNOPSISINFO">
#include &lt;glib.h&gt;
</pre>
                  </td>
                </tr>
              </table>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strconcat</tt></code>(const gchar* <tt
                class="PARAMETER"><i>string1</i></tt>, <tt class= 
                "PARAMETER"><i>...</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strjoin</tt></code>(const gchar* <tt
                class="PARAMETER"><i>separator</i></tt>, <tt class= 
                "PARAMETER"><i>...</i></tt>);</code>
              </p>
            </div>
            <p>
              <b>Figure 11. Concatenating strings</b>
            </p>
          </div>
          <p>
            Finally, <a href="cha-glib.html#FL-STRVECTOR">Figure
            12</a> summarizes a few routines which manipulate <span
            class="STRUCTNAME">NULL</span>-terminated arrays of
            strings. <tt class="FUNCTION">g_strsplit()</tt> breaks
            <span class="STRUCTNAME">string</span> at each <span
            class="STRUCTNAME">delimiter</span>, returning a
            newly-allocated array. <tt class="FUNCTION">
            g_strjoinv()</tt> concatenates each string in the array
            with an optional <span class="STRUCTNAME">
            separator</span>, returning an allocated string. <tt
            class="FUNCTION">g_strfreev()</tt> frees each string in
            the array and then the array itself.
          </p>
          <div class="FIGURE">
            <a name="FL-STRVECTOR"></a>
            <div class="FUNCSYNOPSIS">
              <a name="FL-STRVECTOR.SYNOPSIS"></a>
              <table border="0" bgcolor="#E0E0E0" width="100%">
                <tr>
                  <td>
<pre class="FUNCSYNOPSISINFO">
#include &lt;glib.h&gt;
</pre>
                  </td>
                </tr>
              </table>
              <p>
                <code><code class="FUNCDEF">gchar** <tt class= 
                "FUNCTION">g_strsplit</tt></code>(const gchar* <tt
                class="PARAMETER"><i>string</i></tt>, const gchar*
                <tt class="PARAMETER"><i>delimiter</i></tt>, gint
                <tt class="PARAMETER"><i>
                max_tokens</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">gchar* <tt class= 
                "FUNCTION">g_strjoinv</tt></code>(const gchar* <tt
                class="PARAMETER"><i>separator</i></tt>, gchar**
                <tt class="PARAMETER"><i>
                str_array</i></tt>);</code>
              </p>
              <p>
                <code><code class="FUNCDEF">void <tt class=
                "FUNCTION">g_strfreev</tt></code>(gchar** <tt
                class="PARAMETER"><i>str_array</i></tt>);</code>
              </p>
            </div>
            <p>
              <b>Figure 12. Manipulating <span class="STRUCTNAME">
              NULL</span>-terminated string vectors</b>
            </p>
          </div>
        </div>
      </div>
    </div>
    <div class="NAVFOOTER">
      <br>
      <br>
      <table width="100%" border="0" bgcolor="#ffffff" cellpadding= 
      "1" cellspacing="0">
        <tr>
          <td width="25%" bgcolor="#ffffff" align="left">
            <a href="z22.html"><font color="#0000ff" size="2"><b>
            &lt;&lt;&lt; Previous</b></font></a>
          </td>
          <td width="25%" colspan="2" bgcolor="#ffffff" align= 
          "center">
            <font color="#0000ff" size="2"><b><a href="ggad.html">
            <font color="#0000ff" size="2"><b>
            Home</b></font></a></b></font>
          </td>
          <td width="25%" bgcolor="#ffffff" align="right">
            <a href="z29.html"><font color="#0000ff" size="2"><b>
            Next &gt;&gt;&gt;</b></font></a>
          </td>
        </tr>
        <tr>
          <td colspan="2" align="left">
            <font color="#000000" size="2"><b>Structure of the
            Book</b></font>
          </td>
          <td colspan="2" align="right">
            <font color="#000000" size="2"><b>Data
            Structures</b></font>
          </td>
        </tr>
      </table>
    </div>
  </body>
</html>