C++ 编译Boost程序

我在理解编译boost程序的基础知识方面遇到了困难。我正在使用Fedora15，boost是通过yum-in/usr/include/boost安装的。我也安装了boost build

我真的很想知道如何与boost库链接并在终端下编译以下示例，以及如何使用boost jam/build

//
// reference_counted.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <iostream>
#include <vector>

using boost::asio::ip::tcp;

// A reference-counted non-modifiable buffer class.
class shared_const_buffer
{
public:
  // Construct from a std::string.
  explicit shared_const_buffer(const std::string& data)
    : data_(new std::vector<char>(data.begin(), data.end())),
      buffer_(boost::asio::buffer(*data_))
  {
  }

  // Implement the ConstBufferSequence requirements.
  typedef boost::asio::const_buffer value_type;
  typedef const boost::asio::const_buffer* const_iterator;
  const boost::asio::const_buffer* begin() const { return &buffer_; }
  const boost::asio::const_buffer* end() const { return &buffer_ + 1; }

private:
  boost::shared_ptr<std::vector<char> > data_;
  boost::asio::const_buffer buffer_;
};

class session
  : public boost::enable_shared_from_this<session>
{
public:
  session(boost::asio::io_service& io_service)
    : socket_(io_service)
  {
  }

  tcp::socket& socket()
  {
    return socket_;
  }

  void start()
  {
    using namespace std; // For time_t, time and ctime.
    time_t now = time(0);
    shared_const_buffer buffer(ctime(&now));
    boost::asio::async_write(socket_, buffer,
        boost::bind(&session::handle_write, shared_from_this()));
  }

  void handle_write()
  {
  }

private:
  // The socket used to communicate with the client.
  tcp::socket socket_;
};

typedef boost::shared_ptr<session> session_ptr;

class server
{
public:
  server(boost::asio::io_service& io_service, short port)
    : io_service_(io_service),
      acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
  {
    session_ptr new_session(new session(io_service_));
    acceptor_.async_accept(new_session->socket(),
        boost::bind(&server::handle_accept, this, new_session,
          boost::asio::placeholders::error));
  }

  void handle_accept(session_ptr new_session,
      const boost::system::error_code& error)
  {
    if (!error)
    {
      new_session->start();
      new_session.reset(new session(io_service_));
      acceptor_.async_accept(new_session->socket(),
          boost::bind(&server::handle_accept, this, new_session,
            boost::asio::placeholders::error));
    }
  }

private:
  boost::asio::io_service& io_service_;
  tcp::acceptor acceptor_;
};

int main(int argc, char* argv[])
{
  try
  {
    if (argc != 2)
    {
      std::cerr << "Usage: reference_counted <port>\n";
      return 1;
    }

    boost::asio::io_service io_service;

    using namespace std; // For atoi.
    server s(io_service, atoi(argv[1]));

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

//
//参考_.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
//版权所有（c）2003-2011克里斯托弗·M·科尔霍夫（克里斯在科尔霍夫网站）
//
//根据Boost软件许可证1.0版发布。（见附页）
//文件LICENSE_1_0.txt或复制到http://www.boost.org/LICENSE_1_0.txt)
//
#包括
#包括
#包括
#包括
#包括
#包括
使用boost:：asio:：ip:：tcp；
//引用计数的不可修改缓冲区类。
类共享常量缓冲区
{
公众：
//从std：：字符串构造。
显式共享常量缓冲区（常量标准：：字符串和数据）
：data（新std:：vector（data.begin（），data.end（）），
缓冲区（boost:：asio:：buffer（*数据）
{
}
//执行顺序要求。
typedef boost:：asio:：const_buffer value_type；
typedef const boost:：asio:：const_buffer*const_迭代器；
const boost:：asio:：const_buffer*begin（）const{return&buffer}
const boost:：asio:：const_buffer*end（）const{return&buffer_u+1；}
私人：
boost：：共享的ptr数据；
boost：：asio：：const_buffer_；
};
课堂
：public boost：：从\u启用\u共享\u
{
公众：
会话（boost:：asio:：io_服务和io_服务）
：socket_（io_服务）
{
}
tcp:：套接字和套接字（）
{
返回插座；
}
void start（）
{
使用命名空间std；//表示时间、时间和ctime。
现在时间=时间（0）；
共享常量缓冲区（ctime（&now））；
boost:：asio:：异步写入（套接字、缓冲、，
boost:：bind（&session:：handle_write，shared_from_this（））；
}
无效句柄_write（）
{
}
私人：
//用于与客户端通信的套接字。
tcp：：socket-socket；
};
typedef boost：：共享会话\u ptr；
类服务器
{
公众：
服务器（boost:：asio:：io_服务和io_服务，短端口）
：io_服务（io_服务），
接受者（io_服务，tcp:：端点（tcp:：v4（），端口））
{
会话ptr新会话（新会话（io服务））；
acceptor\异步\u accept（新建会话->套接字（），
boost:：bind（&server:：handle\u accept，这个，新的\u会话，
boost：：asio：：占位符：：错误）；
}
无效句柄\u接受（会话\u ptr新会话，
常量boost:：系统：：错误（代码和错误）
{
如果（！错误）
{
新建会话->开始（）；
新会话。重置（新会话（io_服务）；
acceptor\异步\u accept（新建会话->套接字（），
boost:：bind（&server:：handle\u accept，这个，新的\u会话，
boost：：asio：：占位符：：错误）；
}
}
私人：
boost:：asio:：io_服务和io_服务；
tcp:：接受者接受者；
};
int main（int argc，char*argv[]）
{
尝试
{
如果（argc！=2）
{
std:：cerr它使用
g++-lboost_system-mt-pthread
编译时可能需要显式包含boost库路径。具体的编译命令是什么？命令中是否有类似于
-L/usr/lib/boost
的内容？
可链接boost库列表：

for f in $(ls -1 /usr/lib64/libboost_*.a); do basename $f .a | cut -c 4-99; done;

我知道我需要Boost，我知道我在编译多线程。Boost的文档说使用
-lboost\u system-mt
来实现多线程代码，我的发行版的文档说使用
-pthread
来实现POSIX pthread支持。但是如果你不知道，你可以使用
nm
或
字符串来实现找到包含所需符号的库。然后登录到您的计算机并键入
man nm
或
man strings
。哦，我知道了，它们是程序。谢谢。
for f in $(ls -1 /usr/lib64/libboost_*.a); do basename $f .a | cut -c 4-99; done;