Boost 库中的实用工具类使用入门

约定不等于承诺〃 2022-08-11 16:35 199阅读 0赞

<table style="width: 100%;"> 
 <tbody> 
  <tr> 
   <td><img src="http://www.ibm.com/i/c.gif" alt="" width="10" height="1"></td> 
   <td> <p><a href="http://writeblog.csdn.net/#author" rel="nofollow"><span style="color: #5c81a7;">Arpan Sen</span></a>, 首席工程师, IBM</p> <p>2008 年 9 月 08 日</p> 
    <blockquote>
      实用工具类开发和维护会耗费程序员的时间。Boost 通过提供几个高质量的库，从而简化了此过程，您可以将这些库轻松集成到现有的代码库中。本文简单概述一些较流行的 Boost 实用工具类，并帮助您了解如何将它们投入使用。 
    </blockquote> <p>实用工具类（utility classes）在几乎任何适当规模的 C++ 项目中都是必需的，但是不存在满足此需求的标准方法。通常，团队根据他们的需求编写实用工具类代码，但是由于缺少重要的接口信息，使得相同组织中的其他项目团队无法重用那些类。建议的标准模板库（Standard Template Library，STL）只具有诸如 <code>hash</code>、<code>stack</code> 和 <code>vector</code> 等少数基本类，因此无法有效地用于取代遗留实用工具库。 </p> <p>本文将介绍几个 Boost 实用工具类，包括 <code>tuple</code>、<code>static_assert</code>、<code>pool</code>、<code>random</code> 和 <code>program_options</code>。您需要对标准 STL 具备一定的了解才能充分理解本文的内容。本文中的所有代码都已使用 Boost 1.35 来进行了测试并使用 gcc-3.4.4 来进行了编译。 </p> <p><a rel="nofollow"><span>boost::tuple 类</span></a></p> <p>有时，您希望 C++ 函数返回多个不相关的值。在推出 STL 之前，实现此目的的方法是创建所有不相关变量的结构，并以指针或引用的形式返回它们或作为参数传递给函数——但是任一种方法都不是表达程序员意图的方法。STL 引入了 <code>pair</code>，可将其用于聚合不相关的数据部分，但它一次只能处理两个数据对象。为了使用 <code>int</code>、<code>char</code> 和 <code>float</code> 的元组（tuple ），您可以按如下方式返回 <code>pair</code>： </p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>make_pair&lt;int, pair&lt;char, float&gt; &gt; (3, make_pair&lt;char, float&gt; ('a', 0.9));
			</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>随着您添加更多的元素，创建元组结构将变得越来越困难。Boost <code>tuple</code> 类型派上了用场。要使用 <code>boost::tuple</code>，您必须包括头文件 tuple.hpp。要执行元组比较和元组 I/O，您需要分别包括 tuple_comparison.hpp 和 tuple_io.hpp。</p> <p><a rel="nofollow"><span>第一个使用元组的程序</span></a></p> <p>清单 1 使用 <code>int</code>、<code>char</code> 和 <code>float</code> 的元组并打印内容。 </p> <br><a rel="nofollow"><strong>清单 1. 创建 Boost 元组并打印内容</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;iostream&gt;
#include &lt;tuple.hpp&gt;
#include &lt;tuple_comparison.hpp&gt;
#include &lt;tuple_io.hpp&gt;
using namespace boost;

int main ( )
  {
  tuple&lt;int, char, float&gt; t(2, 'a', 0.9);
  std::cout &lt;&lt; t &lt;&lt; std::endl;
  return 0;
  }
		  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>此代码的输出为 <code>(2 a 0.9)</code>。请注意，<code>&lt;&lt;</code> 运算符重载 <code>std::ostream</code>，以便通过转储每个单独的 <code>tuple</code> 元素来输出元组。 </p> <p><a rel="nofollow"><span>与元组相关的重要事实</span></a></p> <p>在使用元组时，务必牢记以下事实：</p> 
    <ul> 
     <li>能够形成元组的元素数量目前仅限于 10 个。 </li> 
     <li>元组可以包含用户定义的类类型，但是您必须负责确保那些类已经定义了正确的构造函数和拷贝构造函数 (copy constructor)。清单 2 显示了产生编译时错误的代码部分，因为该拷贝构造函数是私有的。 <br><br><a rel="nofollow"><strong>清单 2. 用于元组的类必须具有正确的拷贝构造函数</strong></a><br> 
      <table style="width: 100%;"> 
       <tbody> 
        <tr> 
         <td> <pre>                        
#include &lt;tuple.hpp&gt;
#include &lt;tuple_comparison.hpp&gt;
#include &lt;tuple_io.hpp&gt;
#include &lt;iostream&gt;
using namespace std;

class X
  {
  int x;
  X(const X&amp; u) { x = u.x; }
  public:
    X(int y=5) : x(y) { }
  };

int main ( )
  {
  boost::tuple&lt;int, X&gt; t(3, X(2));
  return 0;
  }
		  </pre> </td> 
        </tr> 
       </tbody> 
      </table> </li> 
     <li>与 STL 提供的 <code>make_pair</code> 函数非常类似，Boost 提供了 <code>make_tuple</code> 例程。要从函数返回元组，您必须调用 <code>make_tuple</code>。可以创建具有临时元素的元组；清单 3 的输出为 <code>(4 0)</code>。<br><br><a rel="nofollow"><strong>清单 3.使用 <code>make_tuple</code> 来从函数返回元组</strong></a><br> 
      <table style="width: 100%;"> 
       <tbody> 
        <tr> 
         <td> <pre>                        
#include &lt;tuple.hpp&gt;
#include &lt;tuple_comparison.hpp&gt;
#include &lt;tuple_io.hpp&gt;
#include &lt;iostream&gt;
using namespace std;

boost::tuple&lt;int, int&gt;
divide_and_modulo(int a, int b)
  {
  return boost::make_tuple&lt;int, int&gt; (a/b, a%b);
  }

int main ( )
  {
  boost::tuple&lt;int, int&gt; t = divide_and_modulo(8, 2);
  cout &lt;&lt; t &lt;&lt; endl;
  return 0;
  }
		  		  </pre> </td> 
        </tr> 
       </tbody> 
      </table> </li> 
     <li>要访问元组的各个元素，您可以使用 <code>get</code> 例程。此例程具有两种变体，如清单 4 所示。请注意，还可以使用 <code>get</code> 例程来设置元组的各个元素，虽然有些编译器可能不支持此功能。 <br><br><a rel="nofollow"><strong>清单 4. 使用 <code>boost::get</code> 例程</strong></a><br> 
      <table style="width: 100%;"> 
       <tbody> 
        <tr> 
         <td> <pre>                        
#include &lt;tuple.hpp&gt;
#include &lt;tuple_comparison.hpp&gt;
#include &lt;tuple_io.hpp&gt;
#include &lt;iostream&gt;
using namespace std;

boost::tuple&lt;int, int&gt;
divide_and_modulo(int a, int b)
  {
  return boost::make_tuple&lt;int, int&gt; (a/b, a%b);
  }

int main ( )
  {
  boost::tuple&lt;int, int&gt; t = divide_and_modulo(8, 2);
  cout &lt;&lt; t.get&lt;0&gt;() &lt;&lt; endl; // prints 4
  cout &lt;&lt; boost::get&lt;1&gt;(t) &lt;&lt; endl; // prints 0

boost::get&lt;0&gt;(t) = 9; // resets element 0 of t to 9
  ++boost::get&lt;0&gt;(t);   // increments element 0 of t
  cout &lt;&lt; t.get&lt;1&gt;() &lt;&lt; endl; // prints 10
  return 0;
  }</pre> </td> 
        </tr> 
       </tbody> 
      </table> </li> 
     <li>可以使用 <code>const</code> 限定符来声明元组，在这种情况下，用于访问特定元素的 <code>get</code> 调用将返回对 <code>const</code> 的引用。不能对以这种方式访问的元素进行赋值（请参见清单 5）。 <br><br><a rel="nofollow"><strong>清单 5. 使用 <code>const</code> 限定符来声明的元组不可修改</strong></a><br> 
      <table style="width: 100%;"> 
       <tbody> 
        <tr> 
         <td> <pre>                        
#include &lt;tuple.hpp&gt;
#include &lt;tuple_comparison.hpp&gt;
#include &lt;tuple_io.hpp&gt;
#include &lt;iostream&gt;
using namespace std;

int main ( )
  {
  const boost::tuple&lt;int, char*&gt; t(8, "Hello World!");
  t.get&lt;1&gt;()[0] = "Y"; // error!
  boost::get&lt;0&gt;(t) = 9; // error!
  return 0;
  }</pre> </td> 
        </tr> 
       </tbody> 
      </table> </li> 
     <li>可以使用关系运算符 <code>==</code>、<code>!=</code>、<code>&lt;</code>、<code>&gt;</code>、<code>&lt;=</code> 和 <code>&gt;=</code> 对相同长度的元组进行比较。比较不同长度的元组会产生编译时错误。这些运算符的工作原理是从左到右地比较两个参与元组的每个单独的元素（请参见清单 6）。 <br><br><a rel="nofollow"><strong>清单 6. 关系运算符与元组</strong></a><br> 
      <table style="width: 100%;"> 
       <tbody> 
        <tr> 
         <td> <pre>                        
#include &lt;tuple.hpp&gt;
#include &lt;tuple_comparison.hpp&gt;
#include &lt;tuple_io.hpp&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;
using namespace std;

int main ( )
  {
  boost::tuple&lt;int, string&gt; t(8, string("Hello World!"));
  boost::tuple&lt;int, string&gt; t2(8, string("Hello World!"));
  cout &lt;&lt; (t == t2) &lt;&lt; endl;

boost::tuple&lt;int, string&gt; r(9, string("Hello World!"));
  boost::tuple&lt;int, string&gt; r2(8, string("Hello World!"));
  cout &lt;&lt; (r &gt; r2) &lt;&lt; endl;

boost::tuple&lt;string, string&gt; q(string("AA"), string("BB"));
  boost::tuple&lt;string, string&gt; q2(string("AA"), string("CC"));
  cout &lt;&lt; (q &lt; q2) &lt;&lt; endl;

return 0;
  }</pre> </td> 
        </tr> 
       </tbody> 
      </table> <br>清单 6 的输出为 <code>1 1 1</code>。请注意，如果您不是使用 <code>string</code> 或 <code>int</code>，而是使用没有定义 <code>==</code>、<code>!=</code> 等运算符的用户定义的随机类，则会产生编译错误。 </li> 
    </ul> <br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br> 
        <table> 
         <tbody> 
          <tr> 
           <td><img src="http://www.ibm.com/i/v14/icons/u_bold.gif" alt="" width="16" height="16"><br></td> 
           <td align="right"><a href="http://writeblog.csdn.net/#main" rel="nofollow"><strong><span style="color: #5c81a7;">回页首</span></strong></a></td> 
          </tr> 
         </tbody> 
        </table> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><a rel="nofollow"><span>Boost 静态断言</span></a></p> <p>断言是 C/C++ 中的防错性程序设计的一部分。最常见的用法如下： </p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>assert(&lt;some expression you expect to be true at this point in code&gt;);
		    </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p><code>assert</code> 例程仅在调试模式下有效。在发布模式下，通常使用预处理器宏 <code>¨CDNDEBUG</code> 来编译代码，其效果相当于 assert 不存在。静态断言建立在这个基本概念之上，只不过静态断言仅在编译时有效。此外，静态断言不生成任何代码。 </p> <p>例如，假设您在一个整型变量中执行某个位操作，并预期其大小为 4：这并非在所有操作系统平台上都是如此（请参见清单 7）。 </p> <br><a rel="nofollow"><strong>清单 7. 使用 Boost 静态断言来验证变量的大小</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;boost/static_assert.hpp&gt;
int main ( )
  {
  BOOST_STATIC_ASSERT(sizeof(int) == 4);
   // … other code goes here
  return 0;
  }
		  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>要使用 <code>BOOST_STATIC_ASSERT</code> 宏，您必须包括 static_assert.hpp 头文件。不需要诸如 <code>DNDEBUG</code> 等特定于编译器的选项，并且您不需要向链接器提供库——单凭该头文件就足够了。 </p> <p>如果断言有效，则代码将顺利编译。但是如果该假设无效，在某些 64 位平台上就可能是如此，则编译器将生成错误消息并停止。使用 g++-3.4.4 进行编译时的典型消息如下：</p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>assert.cc: In function `int main()':
assert.cc:8: error: incomplete type `boost::STATIC_ASSERTION_FAILURE&lt; false&gt;' 
    used in nested name specifier
		  		  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>这肯定不是最详细的错误消息，但是它指出了具有错误假设的函数和确切行号。 </p> <p>下面是一些典型的现实情景，您应该在其中考虑使用静态断言：</p> 
    <ul> 
     <li>静态声明的数组的边界检查 </li> 
     <li>验证原始和用户定义的变量的大小 </li> 
     <li>允许模板类或函数仅使用某些数据类型来进行实例化 </li> 
    </ul> <p><a rel="nofollow"><span><strong><span style="font-size: small; font-family: Arial;">Boost 静态断言的行为</span></strong></span></a></p> <p>您可以在类、函数或命名空间范围中使用 Boost 静态断言；还可以与模板一起使用它们。清单 8 中的示例阐明了概念。 </p> <br><a rel="nofollow"><strong>清单 8. 使用 Boost 静态断言来限制类实例化</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;iostream&gt;
#include &lt;static_assert.hpp&gt;
using namespace std;
using namespace boost;

template&lt;class T&gt;
class A
  {
  private:
    T x, y;
    BOOST_STATIC_ASSERT(numeric_limits&lt;T&gt;::is_signed);
  public:
    A(T x1, T y1) : x(x1), y(y1) { }
  };

int main ( )
  {
  A&lt;unsigned long&gt; a(2, 1);
  return 0;
  }
		  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>在<a href="http://writeblog.csdn.net/#listing8" rel="nofollow"><span style="color: #5c81a7;">清单 8</span></a> 中，仅当 <code>T</code> 有符号时，模板类 <code>A</code> 才能进行实例化。类 <code>numeric_limits</code> 是标准命名空间的一部分；它检查基本类型在给定操作系统平台上的属性。在无符号（unsigned ）的 <code>long</code> 类型的情况下，专用变体 <code>numeric_limits&lt;unsigned int&gt;</code> 的 <code>is_signed</code> 标志为 false。当您在类范围中使用 <code>BOOST_STATIC_ASSERT</code> 时，它是私有的、受保护的还是公开的并不重要。 </p> <p>清单 9 将 <code>BOOST_STATIC_ASSERT</code> 与函数结合在一起使用。该代码确保在函数 <code>f1</code> 中处理的类型只能是 <code>A</code> 类型或其派生类型。通过使用 Boost 的静态断言宏和 <code>is_convertible</code> 例程（在 boost/type_traits/is_convertible.hpp 中定义），此代码确保不希望的类型不会最终调用此例程。 </p> <br><a rel="nofollow"><strong>清单 9. 将函数限制为仅处理特定的数据类型</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;iostream&gt;
#include &lt;static_assert.hpp&gt;
#include &lt;boost/type_traits/is_convertible.hpp&gt;
using namespace std;
using namespace boost;

struct A
  {
  int a;
  float b;
  };

struct B : public A
  {
  };

template &lt;typename T&gt;
int f1 (T y)
  {
  BOOST_STATIC_ASSERT((is_convertible&lt;T, A*&gt;::value));
  return 0;
  }

int main ( )
  {
  f1&lt;B*&gt; (new B);
  return 0;
  }
  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br> 
        <table> 
         <tbody> 
          <tr> 
           <td><img src="http://www.ibm.com/i/v14/icons/u_bold.gif" alt="" width="16" height="16"><br></td> 
           <td align="right"><a href="http://writeblog.csdn.net/#main" rel="nofollow"><strong><span style="color: #5c81a7;">回页首</span></strong></a></td> 
          </tr> 
         </tbody> 
        </table> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><a rel="nofollow"><span>使用 Boost 库生成随机数</span></a></p> <p>随机数生成用于各种各样的计算机应用，例如安全和游戏。UNIX 系统一般附带了随机数生成例程 <code>rand</code> 和 <code>srand</code>。通常，<code>srand</code> 使用新的种子值来初始化 <code>rand</code>（请参见清单 10）。 </p> <br><a rel="nofollow"><strong>清单 10. 用于在传统 UNIX 中生成随机数的代码</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

int main ( )
  {
  srand(time(NULL)); // this introduces randomness
  for (int i=0; i&lt;10; i++)
    printf("%d/n", rand());
  return 0;
  }
		  		  		  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p><code>rand</code> 例程返回一个介于 0 和 stdlib.h 中定义的 <code>RAND_MAX</code> 之间的数字。要了解 <code>srand</code> 所做的工作，可以在将 <code>srand</code> 例程注释掉的情况下编译<a href="http://writeblog.csdn.net/#listing11" rel="nofollow"><span style="color: #5c81a7;">清单 11</span></a>。当您这样做时，您将观察到 <code>rand</code> 并不真正是随机的——可执行代码每次打印同一组值。为了在代码中引入随机性，您可以使用 <code>srand</code>，此例程使用种子值来初始化 <code>rand</code>。由于每次调用程序时的时间值是不同的，因此对于不同的调用，代码打印的值不同。 </p> 
    <table style="width: 40%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="10" height="1"></td> 
       <td> 
        <table style="width: 100%;"> 
         <tbody> 
          <tr> 
           <td><a rel="nofollow"><strong>传统随机数生成器的问题</strong></a><br>传统随机数生成器具有几个问题。它们无法生成在用户指定范围内均匀分布的随机数，或者符合高斯或二项式分布的随机数。本文仅在可将随机数映射到某个范围内的上下文中讨论随机数。 </td> 
          </tr> 
         </tbody> 
        </table> </td> 
      </tr> 
     </tbody> 
    </table> <p><a rel="nofollow"><span><strong><span style="font-size: small; font-family: Arial;">使用 Boost 随机数生成器</span></strong></span></a></p> <p>Boost 随机数生成器位于 boost/random 文件夹中。此外，为方便起见，boost/ 目录中的 random.hpp 头文件包括了 boost/random 文件夹中的所有其他头文件。 </p> <p>Boost 随机接口划分为两个部分：随机数生成器和随机数必须位于其中的分布。本文讨论 <code>uniform_int</code> 和 <code>uniform_real random-number</code> 分布以及 <code>mt19937</code> 随机数生成器。清单 11 使用了 <code>uniform_int</code> 和 <code>uniform_real</code> 分布。 </p> <br><a rel="nofollow"><strong>清单 11. 将 <code>variate_generator</code> 与 <code>mt19937</code> 引擎和 <code>uniform_int</code> 分布一起使用</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;iostream&gt;
#include &lt;boost/random.hpp&gt;
using namespace std;
using namespace boost;

int main ( )
  {
  uniform_int&lt;&gt; distribution(1, 100) ;
  mt19937 engine ;
  variate_generator&lt;mt19937, uniform_int&lt;&gt; &gt; myrandom (engine, distribution);

for (int i=0; i&lt;100; ++i)
    cout &lt;&lt; myrandom() &lt;&lt; endl;

return 0;
  }
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>此代码生成介于 1 和 100 之间（包括 1 和 100）的随机数；用于实现随机化的基础引擎是 <code>mt19937</code>。<code>variate_generator</code> 为您组合了该引擎和分布。 </p> <p>清单 12 使用了另一个引擎： <code>kreutzer1986</code>. </p> <br><a rel="nofollow"><strong>清单 12：组合 <code>uniform_real</code> 分布和 <code>kreutzer1986</code> 引擎</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;iostream&gt;
#include &lt;boost/random.hpp&gt;
using namespace std;
using namespace boost;

int main ( )
  {
  uniform_real&lt;&gt; distribution(1, 2) ;
  kreutzer1986 engine ;
  variate_generator&lt;kreutzer1986, uniform_real&lt;&gt; &gt; myrandom (engine, distribution);

for (int i=0; i&lt;100; ++i)
    cout &lt;&lt; myrandom() &lt;&lt; endl;

return 0;
  }
		  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>除了 <code>uniform_int</code> 和 <code>uniform_real</code> 分布以外，Boost 还提供了几个其他分布，包括二项式、泊松和正态分布。 </p> <br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br> 
        <table> 
         <tbody> 
          <tr> 
           <td><img src="http://www.ibm.com/i/v14/icons/u_bold.gif" alt="" width="16" height="16"><br></td> 
           <td align="right"><a href="http://writeblog.csdn.net/#main" rel="nofollow"><strong><span style="color: #5c81a7;">回页首</span></strong></a></td> 
          </tr> 
         </tbody> 
        </table> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><a rel="nofollow"><span>boost::pool 库概述</span></a></p> <p>Boost <code>pool</code> 库引入了可用于实现快速内存分配的工具。正确的内存块对齐可以得到保证。 </p> <p>根据 Boost 文档所述，当您分配和释放许多小型对象时，建议使用池。使用池的另一个不太明显的优点在于，作为程序员，您不必担心内存泄露：内存由 Boost 库在内部自动进行管理。要使用 <code>pool</code> 库，您不必在链接时提供特定的库——单凭头文件就足以完成链接了。 </p> <p>有多个接口对 <code>pool</code> 库可用： </p> 
    <ul> 
     <li><strong>池接口</strong>——替代 <code>malloc</code> 进行工作的普通接口。要使用此接口，需要包括 boost/pool 文件夹中的 pool.hpp 头文件。 </li> 
     <li><strong>对象池接口</strong>——有对象意识的接口，在对象创建和删除过程中分别相应地调用构造函数和析构函数。还可以使用此接口创建普通对象，而不调用它们的构造函数。接口定义是在位于 boost/pool 目录中的 object_pool.hpp 头文件中提供的。<a href="http://writeblog.csdn.net/#listing13" rel="nofollow"><span style="color: #5c81a7;">清单 13</span></a> 引入了 <code>pool</code> 和 <code>object_pool</code> 接口。请注意以下几点： 
      <ul> 
       <li><code>pool</code> 接口需要知道每个单独的元素而不是类型的大小，因为它是一个 <code>malloc</code> 风格的分配程序，不会调用构造函数。 </li> 
       <li><code>pool</code> 接口中的 <code>malloc</code> 例程返回 <code>void*</code>。 </li> 
       <li><code>object-pool</code> 接口需要类型信息，因为要调用构造函数。 </li> 
       <li><code>object-pool</code> 接口中的 <code>malloc/construct</code> 例程返回指向类型的指针。<code>malloc</code> 例程不调用构造函数，但是 <code>construct</code> 要调用构造函数。 </li> 
       <li>使用 <code>pool</code> 接口或 <code>object-pool</code> 接口来创建的元素的范围与从中创建它们的池的范围相同。 </li> 
       <li>要从池接口中释放内存，可以调用 <code>purge_memory</code> 方法。该方法释放您先前创建的内存块，并使得从分配程序例程返回的所有指针失效。 </li> 
       <li>要释放各个元素，可以调用 <code>pool</code> 接口中的 <code>free</code> 例程。例如，如果 <code>t</code> 是使用 <code>pool</code> 接口来创建的池，并且 <code>m</code> 是从 <code>t</code> 分配的指针，则 <code>t.free(m)</code> 将把内存返回给 <code>t</code>（将其添加到 <code>t</code> 的空闲内存列表）。 <br><br><a rel="nofollow"><strong>清单 13. <code>pool</code> 和 <code>object_pool</code> 接口</strong></a><br> 
        <table style="width: 100%;"> 
         <tbody> 
          <tr> 
           <td> <pre>                            
#include &lt;iostream&gt;
#include &lt;boost/pool/pool.hpp&gt;
#include &lt;boost/pool/object_pool.hpp&gt;
using namespace std;
using namespace boost;

class A
  {
  public: A( ) { cout &lt;&lt; "Declaring A/n"; }
         ~A( ) { cout &lt;&lt; "Deleting A/n"; }
  };

int main ( )
  {
  cout &lt;&lt; "Init pool.../n";

pool&lt;&gt; p(10 * sizeof(A));
  for (int i=0; i&lt;10; ++i)
    A* a = (A*) p.malloc(); // Always returns sizeof(A)
  p.purge_memory();

cout &lt;&lt; "Init object pool.../n";

object_pool&lt;A&gt; q;
  for (int i=0; i&lt;10; ++i)
    A* a = q.construct(); // Calls A's constructor 10 times

return 0;
  }
  </pre> </td> 
          </tr> 
         </tbody> 
        </table> </li> 
      </ul> </li> 
     <li><strong><code>singleton_pool</code> 接口</strong>——与 <code>pool</code> 接口几乎相同，但是用作独立池。独立池的底层结构具有为 <code>malloc</code>、<code>free</code> 等声明的静态成员函数，并且构造函数是私有的。独立池声明中的第一个参数称为<em>标记</em>——它允许存在不同的独立池集（例如，用于 <code>int</code> 的多个池，其中每个池服务于不同的目的）。必须包括 singleton_pool.hpp 头文件才能使用此接口。请参见清单 14。 <br><br><a rel="nofollow"><strong>清单 14. <code>singleton_pool</code> 接口</strong></a><br> 
      <table style="width: 100%;"> 
       <tbody> 
        <tr> 
         <td> <pre>                        
#include &lt;iostream&gt;
#include &lt;boost/pool/singleton_pool.hpp&gt;
using namespace std;
using namespace boost;

struct intpool {  };
struct intpool2 {  };

typedef boost::singleton_pool&lt;intpool, sizeof(int)&gt; ipool1;
typedef boost::singleton_pool&lt;intpool2, sizeof(int)&gt; ipool2;

int main ( )
  {
  cout &lt;&lt; "Init singleton pool.../n";
  for (int i=0; i&lt;10; ++i) {
    int* q1 = (int*) ipool1::malloc();
    int* q2 = (int*) ipool2::malloc();
  }

ipool1::purge_memory();
  ipool2::purge_memory();
  return 0;
  }
		  </pre> </td> 
        </tr> 
       </tbody> 
      </table> </li> 
     <li><strong><code>pool_alloc</code> 接口</strong>——通常与 STL 容器结合在一起使用。请考虑以下代码片段： 
      <table style="width: 100%;"> 
       <tbody> 
        <tr> 
         <td> <pre>#include &lt;boost/pool/pool_alloc.hpp&gt;

std::vector&lt;int, boost::pool_allocator&lt;int&gt; &gt; v;
std::list&lt;double, boost::fast_pool_allocator&lt;double&gt; &gt; L;
</pre> </td> 
        </tr> 
       </tbody> 
      </table> <br>存在两个分配程序：<code>pool_allocator</code> 和 <code>fast_pool_allocator</code>。第一个分配程序是通用分配，可以满足针对任何数量的连续内存块的请求。<code>fast_pool_allocator</code> 最适合于一次请求单个（通常较大）块，但是也适用于通用分配，不过具有一些性能缺点。 </li> 
    </ul> <br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br> 
        <table> 
         <tbody> 
          <tr> 
           <td><img src="http://www.ibm.com/i/v14/icons/u_bold.gif" alt="" width="16" height="16"><br></td> 
           <td align="right"><a href="http://writeblog.csdn.net/#main" rel="nofollow"><strong><span style="color: #5c81a7;">回页首</span></strong></a></td> 
          </tr> 
         </tbody> 
        </table> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><a rel="nofollow"><span>boost::program_options 简介</span></a></p> <p>命令行处理是另一个难点，开发人员通常不会采用结构化的方式来解决。其结果是从头到尾维护开销。Boost <code>program_options</code> 库提供了简化命令行处理的例程和数据结构。 </p> <p>清单 15 详细描述了 <code>boost::program_options</code> 的使用。这是建议在您的代码中使用的标准模板。</p> <br><a rel="nofollow"><strong>清单 15. 使用 boost::program_options</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;boost/program_options.hpp&gt;
using namespace std;

int main (int ac, char* av[])
  {
  boost::program_options::options_description options("command line options");
  options.add_options() ("help", "Use -h or --help to list all arguments")
                                      ("file", boost::program_options::value&lt;string&gt;(),
                                       "Provide input file name");
  boost::program_options::variables_map vmap;
  boost::program_options::store(
      boost::program_options::parse_command_line(ac, av, options), vmap);
  boost::program_options::notify(vmap);

if (vmap.count("help")) {
      cout &lt;&lt; options &lt;&lt; endl;
  }

return 0;
  }
		  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>您必须包括 program_options.hpp 头文件。<a href="http://writeblog.csdn.net/#listing15" rel="nofollow"><span style="color: #5c81a7;">清单 15</span></a> 的工作方式如下： </p> 
    <ol> 
     <li><code>options_description</code> 类声明所有的有效命令行选项。 </li> 
     <li>使用方法 <code>add_options</code>，您可以注册命令和跟在命令后面的参数类型。在此例中，<code>help</code> 选项不需要任何参数，但是 <code>file</code> 选项需要一个字符串参数。 </li> 
     <li><code>variables_map</code> 类在运行时存储命令行选项及其参数。 </li> 
     <li>Boost 的 <code>parse_command_line</code> 例程解析 <code>argc</code> 和 <code>argv</code> 参数。<code>store</code> 和 <code>notify</code> 方法帮助存储 <code>vmap</code> 对象中的数据。 </li> 
     <li>当您检查 <code>help</code> 是否为程序的恰当命令行选项（这是 <code>vmap.count("help")</code> 所做的工作）时，<code>options</code> 对象将被转储到 <code>cout</code>。这意味着运算符 <code>&lt;&lt;</code> 是为 <code>options_description</code> 类定义的。 </li> 
    </ol> <p>下面是来自<a href="http://writeblog.csdn.net/#listing15" rel="nofollow"><span style="color: #5c81a7;">清单 15</span></a> 的输出： </p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>[user@/home/user1] ./a.out --help
command line options:
  --help                Use -h or --help to list all arguments
  --file arg            Provide input file name
  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>当您遇到其他选项时，可以采取进一步的操作。例如，下面的代码片段经过了修改，以打印您输入的文件名：</p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>…
if (vmap.count("file")) {
     cout &lt;&lt; "Setting input file to " &lt;&lt; vmap["file"].as&lt;string&gt;() &lt;&lt; "./n";
 } else {
     cout &lt;&lt; "No file specified/n";
 }
…
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>请注意，<code>variable_map</code> 类在许多方面与哈希表非常相似。例如，要检索 file 参数，您可以调用 <code>vmap["file"]</code>。</p> <br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br> 
        <table> 
         <tbody> 
          <tr> 
           <td><img src="http://www.ibm.com/i/v14/icons/u_bold.gif" alt="" width="16" height="16"><br></td> 
           <td align="right"><a href="http://writeblog.csdn.net/#main" rel="nofollow"><strong><span style="color: #5c81a7;">回页首</span></strong></a></td> 
          </tr> 
         </tbody> 
        </table> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><a rel="nofollow"><span>提供多个参数和缩写的命令选项</span></a></p> <p>命令行处理通常同时需要同一个命令选项的短名称和长名称。此外，您通常必须多次使用某个选项，以便收集该选项的所有参数。例如，您可能希望使用 <code>¨Ch</code> 和 <code>¨Chelp</code> 来打印可用的命令。清单 16 演示了这些功能。 </p> <br><a rel="nofollow"><strong>清单 16. 使用较短的选项变体并允许多次调用命令选项</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;boost/program_options.hpp&gt;
using namespace std;

int main (int ac, char* av[])
  {
  boost::program_options::options_description options("command line options");
  options.add_options() ("help,h", "Use -h or --help to list all arguments")
                    ("file", boost::program_options::value&lt;vector&lt;string&gt; &gt;( ),
                         "Provide input file name");
  boost::program_options::variables_map vmap;
  boost::program_options::store(
      boost::program_options::parse_command_line(ac, av, options), vmap);
  boost::program_options::notify(vmap);

if (vmap.count("help")) {
      cout &lt;&lt; options &lt;&lt; endl;
  }

if (vmap.count("file")) {
      vector&lt;string&gt; ifiles(vmap["file"].as&lt; vector&lt;string&gt; &gt; ());
      vector&lt;string&gt;::iterator vI;
      cout &lt;&lt; "Number of input files: " &lt;&lt; ifiles.size() &lt;&lt; endl;
      cout &lt;&lt; "Input file list: " &lt;&lt; endl;
      for(vI = ifiles.begin(); vI != ifiles.end(); ++vI)
          cout &lt;&lt; "/t" &lt;&lt; *vI &lt;&lt; endl;
  } else {
      cout &lt;&lt; "No file specified/n";
  }

return 0;
  }
		  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>在使用 <code>add_options</code> 来添加命令选项时，较长和较短的选项之间使用逗号进行分隔。请注意，较长的选项 (<code>help</code>) 必须在较短的选项 (<code>h</code>) 之前，代码才能正常工作。与使用单个字符串不同，<code>file</code> 选项现在是使用一个字符串向量来定义的。如果指定了 <code>¨Cfile</code> 选项多次，则会将在所有指定中收集到的命令选项参数存储在关联的 <code>vector&lt;string&gt;</code> 中。下面是使用不同的参数来多次指定 <code>¨Ch</code> 和 <code>¨Cfile</code> 所获得的输出： </p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>[user@/home/user1] ./a.out -h
command line options:
  -h [ --help ]         Use -h or --help to list all arguments
  --file arg            Provide input file name

No file specified
[user@/home/user1] ./a.out --file abc --file pqr
Number of input files: 2
Input file list:
        abc
        pqr
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br> 
        <table> 
         <tbody> 
          <tr> 
           <td><img src="http://www.ibm.com/i/v14/icons/u_bold.gif" alt="" width="16" height="16"><br></td> 
           <td align="right"><a href="http://writeblog.csdn.net/#main" rel="nofollow"><strong><span style="color: #5c81a7;">回页首</span></strong></a></td> 
          </tr> 
         </tbody> 
        </table> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><a rel="nofollow"><span>解析位置选项</span></a></p> <p>带输入参数但是不带命令行选项来调用某个程序是非常普遍的。您预期参数和命令行选项之间自动存在某种神奇关联。这种行为由 <code>boost::program_options</code> 提供支持。 </p> <p>请考虑清单 17。第一个参数转换为 <code>--file=&lt;first parameter&gt;</code>，第二个参数转换为 <code>--do-file=&lt;second parameter&gt;</code>。 </p> <br><a rel="nofollow"><strong>清单 17. 将位置参数与命令行选项相关联</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>                
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;boost/program_options.hpp&gt;
using namespace std;

int main (int ac, char* av[])
  {
  boost::program_options::options_description options("command line options");
  options.add_options() ("help,h", "Use -h or --help to list all arguments")
                        ("file", boost::program_options::value&lt;string&gt;(),
                         "Provide input file name")
                        ("do-file", boost::program_options::value&lt;string&gt;(),
                         "Specify commands file");

boost::program_options::variables_map vmap;
  boost::program_options::positional_options_description poptd;
  poptd.add("file", 1);
  poptd.add("do-file", 2);

boost::program_options::store(
      boost::program_options::command_line_parser(ac, av).
      options(options).positional(poptd).run(), vmap);
  boost::program_options::notify(vmap);

if (vmap.count("file")) {
     cout &lt;&lt; "file: " &lt;&lt; vmap["file"].as&lt;string&gt; ( ) &lt;&lt; endl;
  }

if (vmap.count("do-file")) {
     cout &lt;&lt; "do-file: " &lt;&lt; vmap["do-file"].as&lt;string&gt; ( ) &lt;&lt; endl;
  }

return 0;
  }
		  </pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>下面是输出内容： </p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>[user@/home/user1] ./a.out file1 dofile1
file: file1
do-file: dofile1
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p><a href="http://writeblog.csdn.net/#listing15" rel="nofollow"><span style="color: #5c81a7;">清单 15</span></a> 中使用的某些 API 在<a href="http://writeblog.csdn.net/#listing17" rel="nofollow"><span style="color: #5c81a7;">清单 17</span></a> 中已发生更改。清单 17 引入了新的类 <code>positional_options_description</code>。该类的 <code>add</code> 方法（<code>add("command option", N)</code>）将位置 <em>N</em> 处的输入参数与命令行选项 <code>"command option"</code> 相关联。因此，<code>./a.out file1</code> 在内部解析为 <code>./a.out ¨Cfile=file1</code>。另一个区别在于调用 <code>program_options::store</code> 方法的方式。与使用 <code>parse_command_line</code> 例程不同，Boost 库要求您将 <code>command_line_parser</code> 例程与 <code>store</code> 方法结合在一起使用。 </p> <p>请注意，仍然可以使用 <code>¨Cfile</code> 和 <code>¨Cdo-file</code> 选项来调用该程序。最后，若要将所有的输入参数与同一个命令行选项相关联，您需要使用值 -1 将该命令行选项添加到 <code>positional_options_description</code> 对象。下面是代码： </p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>…
boost::program_options::positional_options_description poptd;
poptd.add("file", -1);
...
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br> 
        <table> 
         <tbody> 
          <tr> 
           <td><img src="http://www.ibm.com/i/v14/icons/u_bold.gif" alt="" width="16" height="16"><br></td> 
           <td align="right"><a href="http://writeblog.csdn.net/#main" rel="nofollow"><strong><span style="color: #5c81a7;">回页首</span></strong></a></td> 
          </tr> 
         </tbody> 
        </table> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><a rel="nofollow"><span>结束语</span></a></p> <p>本文提供了 Boost 库中较为有用的一些实用工具类的概述。只要使用得当，它们可以为您省去大量的代码维护开销。鉴于所讨论的概念的范围和广度，论及每个实用工具类的每个功能是不切实际的。<a href="http://writeblog.csdn.net/#resources" rel="nofollow"><span style="color: #5c81a7;">参考资料</span></a>部分提供了进一步的阅读参考。 </p> <br><br> <p><a rel="nofollow"><span>参考资料 </span></a></p> <strong>学习</strong><br> 
    <ul> 
     <li>您可以参阅本文在 developerWorks 全球站点上的 <a href="http://www.ibm.com/developerworks/aix/library/au-util_boost_lib/?S_TACT=105AGX52&amp;S_CMP=content" rel="nofollow"><span style="color: #5c81a7;">英文原文</span></a> 。<br></li> 
     <li>阅读 <a href="http://www.boost.org/doc/libs/1_35_0/libs/tuple/doc/tuple_users_guide.html" rel="nofollow"><span style="color: #5c81a7;">tuple user guide</span></a>。<br></li> 
     <li>请参阅 <a href="http://www.boost.org/doc/libs/1_35_0/doc/html/boost_staticassert.html" rel="nofollow"><span style="color: #5c81a7;">Static Assertion Reference</span></a>。<br></li> 
     <li>获取有关<a href="http://www.boost.org/doc/libs/1_35_0/libs/random/index.html" rel="nofollow"><span style="color: #5c81a7;">随机数生成器</span></a>的更多信息。要了解随机数生成器的数学基础，请参阅图书 <em><a href="http://www.fizyka.umk.pl/nrbook/bookcpdf.html" rel="nofollow"><span style="color: #5c81a7;">Numerical Recipes in C</span></a></em>。<br></li> 
     <li>阅读 Boost <a href="http://www.boost.org/doc/libs/1_35_0/libs/pool/doc/index.html" rel="nofollow"><span style="color: #5c81a7;">pool library documentation</span></a>。<br></li> 
     <li>从 <a href="http://www.boost.org/doc/libs/1_35_0/doc/html/program_options.html" rel="nofollow"><span style="color: #5c81a7;">program-options user guide</span></a> 中获取更多信息。<br></li> 
     <li><a href="http://www.ibm.com/developerworks/cn/aix" rel="nofollow"><span style="color: #5c81a7;">AIX and UNIX 专区</span></a>：developerWorks 的“AIX and UNIX 专区”提供了大量与 AIX 系统管理的所有方面相关的信息，您可以利用它们来扩展自己的 UNIX 技能。<br></li> 
     <li><a href="http://www.ibm.com/developerworks/cn/aix/newto" rel="nofollow"><span style="color: #5c81a7;">AIX and UNIX 新手入门</span></a>：访问“AIX and UNIX 新手入门”页面可了解更多关于 AIX 和 UNIX 的内容。<br></li> 
     <li><a href="http://www.ibm.com/developerworks/cn/aix/lpsummary.html" rel="nofollow"><span style="color: #5c81a7;">AIX and UNIX 专题汇总</span></a>：AIX and UNIX 专区已经为您推出了很多的技术专题，为您总结了很多热门的知识点。我们在后面还会继续推出很多相关的热门专题给您，为了方便您的访问，我们在这里为您把本专区的所有专题进行汇总，让您更方便的找到您需要的内容。<br></li> 
     <li><a href="http://www.ibm.com/developerworks/cn/offers/techbriefings" rel="nofollow"><span style="color: #5c81a7;">developerWorks 技术事件和网络广播</span></a>：了解最新的 developerWorks 技术事件和网络广播。<br></li> 
     <li><a href="http://www-941.ibm.com/collaboration/wiki/display/WikiPtype/Home" rel="nofollow"><span style="color: #5c81a7;">AIX</span></a>：访问此 AIX 相关技术信息的协作环境。<br></li> 
     <li><a href="http://www-128.ibm.com/developerworks/podcast/" rel="nofollow"><span style="color: #5c81a7;">Podcast</span></a>：收听 Podcast 并与 IBM 技术专家保持同步。<br></li> 
    </ul> <br><strong>获得产品和技术</strong><br> 
    <ul> 
     <li>下载 <a href="http://www.boost.org/" rel="nofollow"><span style="color: #996699;">Boost 实用工具类</span></a>。<br></li> 
     <li><a href="http://www-128.ibm.com/developerworks/cn/downloads/" rel="nofollow"><span style="color: #5c81a7;">IBM 试用软件</span></a>：从 developerWorks 可直接下载这些试用软件，您可以利用它们开发您的下一个项目。<br></li> 
    </ul> <br><strong>讨论</strong><br> 
    <ul> 
     <li>参与“AIX and UNIX”论坛： 
      <ul> 
       <li><a href="http://www-128.ibm.com/developerworks/forums/dw_forum.jsp?forum=747&amp;amp;cat=72" rel="nofollow"><span style="color: #5c81a7;">AIX 论坛</span></a> </li> 
       <li><a href="http://www-128.ibm.com/developerworks/forums/dw_forum.jsp?forum=905&amp;amp;cat=72" rel="nofollow"><span style="color: #5c81a7;">AIX 开发者论坛</span></a> </li> 
       <li><a href="http://www-128.ibm.com/developerworks/forums/dw_forum.jsp?forum=907&amp;amp;cat=72" rel="nofollow"><span style="color: #5c81a7;">集群系统管理</span></a> </li> 
       <li><a href="http://www-128.ibm.com/developerworks/forums/dw_forum.jsp?forum=935&amp;amp;cat=72" rel="nofollow"><span style="color: #5c81a7;">IBM Support Assistant 论坛</span></a> </li> 
       <li><a href="http://www-128.ibm.com/developerworks/forums/dw_forum.jsp?forum=749&amp;amp;cat=72" rel="nofollow"><span style="color: #5c81a7;">性能工具论坛</span></a> </li> 
       <li><a href="http://www.ibm.com/developerworks/forums/forum.jspa?forumID=748" rel="nofollow"><span style="color: #5c81a7;">虚拟化论坛</span></a> </li> 
       <li><a href="http://www-128.ibm.com/developerworks/forums/dw_auforums.jsp" rel="nofollow"><span style="color: #5c81a7;">更多“AIX and UNIX”论坛</span></a> </li> 
      </ul> </li> 
    </ul> <br><br> <p><a rel="nofollow"><span>关于作者</span></a></p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td colspan="3"><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="5"></td> 
      </tr> 
      <tr> 
       <td> <p>&nbsp;</p> </td> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="4" height="5"></td> 
       <td> <p>Arpan Sen 是致力于电子设计自动化行业的软件开发首席工程师。他使用各种 UNIX 版本（包括 Solaris、SunOS、HP-UX、IRIX，以及 Linux 和 Microsoft Windows）已经多年。他热衷于各种软件性能优化技术、图形理论和并行计算。Arpan 获得了软件系统硕士学位。</p> </td> 
      </tr> 
     </tbody> 
    </table> </td> 
  </tr> 
 </tbody> 
</table>