c++ - boost::program_options 和 ini 文件中的多个部分

Question

我正在尝试让 boost::program_options 读取具有多个部分的ini文件：

[slave]
address=localhost
port=1111

[slave]
address=192.168.0.1
port=2222

有什么解决办法吗？

提前致谢！

score 18 · Accepted Answer

这个问题有几个解决方案。虽然最初看起来这应该是一项容易的任务，但它通常相当复杂。这是因为节大致相当于命名空间；部分不等同于对象。

[奴隶]
地址=本地主机
端口=1111

[奴隶]
地址=192.168.0.1
端口=2222

上面的配置有一个slave命名空间，其中包含两个address值和两个port值。没有两个slave对象都有一个address和port。由于这种区别，关联值或配对必须在应用程序代码中完成。这提出了以下选项：

使用配置文件的布局来暗示配对。
通过将多个值合并为单个字段值来执行显式配对。

隐含配对

使用这种方法，配置文件可以保持原样。这种方法的简单性取决于：

一些 Boost.ProgramOption 组件的行为。
每个对象表示为一个没有可选字段和少量字段的部分。

[奴隶]
地址=本地主机#slave.address[0]
端口=1111 #slave.port[0]

[奴隶]
地址=192.168.0.1 #slave.address[1]
端口=2222 #slave.port[1]

不修改配置，代码如下：

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>

#include <boost/program_options.hpp>

/// @brief Convenience function for when a 'store_to' value is being provided
///        to typed_value.
///
/// @param store_to The variable that will hold the parsed value upon notify.
///
/// @return Pointer to a type_value.
template < typename T >
boost::program_options::typed_value< T >* make_value( T* store_to )
{
  return boost::program_options::value< T >( store_to );
}

/// @brief Slave type that contains an address and port.
struct slave
{
  std::string    address;
  unsigned short port;

  /// @brief Constructor.
  slave( std::string address, 
         unsigned short port )
    : address( address ),
      port( port )
  {}
};

/// @brief Stream insertion operator for slave.
///
/// @param stream The stream into which slave is being inserted.
/// @param s The slave object.
///
/// @return Reference to the ostream.
std::ostream& operator<<( std::ostream& stream, 
                          const slave& slave )
{
  return stream << "Slave address: " << slave.address 
                << ", port: "        << slave.port;
}

/// @brief Makes a slave given an address and port.
slave make_slave( const std::string& address,
                  unsigned short port )
{
  return slave( address, port );
}

int main()
{
  // Variables that will store parsed values.
  std::vector< std::string >    addresses;
  std::vector< unsigned short > ports;

  // Setup options.
  namespace po = boost::program_options;
  po::options_description desc( "Options" );
  desc.add_options()
    ( "slave.address", make_value( &addresses ),
                       "slave's hostname or ip address" )
    ( "slave.port"   , make_value( &ports ),
                       "plugin id" );

  // Load setting file.
  po::variables_map vm;
  std::ifstream settings_file( "config.ini", std::ifstream::in );
  po::store( po::parse_config_file( settings_file , desc ), vm );
  settings_file.close();
  po::notify( vm );

  // Transform each address and port pair into a slave via make_slave,
  // inserting each object into the slaves vector.
  std::vector< slave > slaves;
  std::transform( addresses.begin(), addresses.end(),
                  ports.begin(),
                  std::back_inserter( slaves ),
                  make_slave );

  // Print slaves.
  std::copy( slaves.begin(), slaves.end(), 
             std::ostream_iterator< slave >( std::cout, "\n" ) );
}

产生这个输出：

从机地址：localhost，端口：1111
从机地址：192.168.0.1，端口：2222

基本显式配对

多个值有时可以以有意义的方式在单个字段中表示。address和的一种常见表示形式port是address:port。通过这种配对，生成的配置文件将如下所示：

[奴隶]
从机=本地主机：1111
从机=192.168.0.1:2222

这种方法的简单性取决于：

能够在没有键说明符的情况下将多个值表示为单个有意义的值。
每个对象都没有可选值。

更新后的代码：

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>

#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/program_options.hpp>

/// @brief Convenience function for when a 'store_to' value is being provided
///        to typed_value.
///
/// @param store_to The variable that will hold the parsed value upon notify.
///
/// @return Pointer to a type_value.
template < typename T >
boost::program_options::typed_value< T >* make_value( T* store_to )
{
  return boost::program_options::value< T >( store_to );
}

/// @brief Slave type that contains an address and port.
struct slave
{
  std::string    address;
  unsigned short port;

  /// @brief Constructor.
  slave( std::string address, 
         unsigned short port )
    : address( address ),
      port( port )
  {}
};

/// @brief Stream insertion operator for slave.
///
/// @param stream The stream into which slave is being inserted.
/// @param s The slave object.
///
/// @return Reference to the ostream.
std::ostream& operator<<( std::ostream& stream, 
                          const slave& slave )
{
  return stream << "Slave address: " << slave.address 
                << ", port: "        << slave.port;
}

/// @brief Makes a slave given an address and port.
slave make_slave( const std::string& address_and_port )
{
  // Tokenize the string on the ":" delimiter. 
  std::vector< std::string > tokens;
  boost::split( tokens, address_and_port, boost::is_any_of( ":" ) );

  // If the split did not result in exactly 2 tokens, then the value
  // is formatted wrong.
  if ( 2 != tokens.size() )
  {
     using boost::program_options::validation_error;
     throw validation_error( validation_error::invalid_option_value,
                             "slaves.slave",
                             address_and_port );
  }

  // Create a slave from the token values.
  return slave( tokens[0],
                boost::lexical_cast< unsigned short >( tokens[1] ) );
}

int main()
{
  // Variables that will store parsed values.
  std::vector< std::string > slave_configs;

  // Setup options.
  namespace po = boost::program_options;
  po::options_description desc( "Options" );
  desc.add_options()
    ( "slaves.slave", make_value( &slave_configs ),
                      "slave's address@port" );

  // Load setting file.
  po::variables_map vm;
  std::ifstream settings_file( "config.ini", std::ifstream::in );
  po::store( po::parse_config_file( settings_file , desc ), vm );
  settings_file.close();
  po::notify( vm );

  // Transform each config into a slave via make_slave, inserting each 
  // object into the slaves vector.
  std::vector< slave > slaves;
  std::transform( slave_configs.begin(), slave_configs.end(),
                  std::back_inserter( slaves ),
                  make_slave );

  // Print slaves.
  std::copy( slaves.begin(), slaves.end(), 
             std::ostream_iterator< slave >( std::cout, "\n" ) );
}

产生相同的输出：

从机地址：localhost，端口：1111
从机地址：192.168.0.1，端口：2222

值得注意的代码修改如下：

的需要作为一个options_description阅读。optionsslaves.slavestd::vector< std::string >
make_slave将采用一个std::string参数，从中提取addressand port。
更新std::transform调用以仅迭代一个范围。

高级显式配对

通常，多个字段不能有意义地表示为单个无键值，或者一个对象具有可选字段。对于这些情况，需要进行额外级别的语法和解析。虽然应用程序可以引入自己的语法和解析器，但我建议利用 Boost.ProgramOption 的命令行语法（--key value和--key=value）和解析器。生成的配置文件可能如下所示：

[奴隶]
从机= --address localhost --port 1111
从机=--地址=192.168.0.1--端口=2222

更新后的代码：

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>

#include <boost/bind.hpp>
#include <boost/program_options.hpp>
#include <boost/tokenizer.hpp>

// copy_if was accidently left out of the C++03 standard, so mimic the
// C++11 behavior to support all predicate types.  The alternative is to
// use remove_copy_if, but it only works for adaptable functors.
template < typename InputIterator,
           typename OutputIterator, 
           typename Predicate >
OutputIterator 
copy_if( InputIterator first,
         InputIterator last,
         OutputIterator result,
         Predicate pred )
{
  while( first != last )
  {
    if( pred( *first ) )
      *result++ = *first;
    ++first;
  }
  return result;
}

/// @brief Tokenize a string.  The tokens will be separated by each non-quoted
///        character in @c separator_characters.  Empty tokens are removed.
///
/// @param input The string to tokenize.
/// @param separator_characters The characters on which to delimit.
///
/// @return Vector of tokens.
std::vector< std::string > tokenize( const std::string& input,
                                     const std::string& separator_characters )
{
   typedef boost::escaped_list_separator< char > separator_type;
   separator_type separator( "\\", // The escape characters.
                             separator_characters,
                             "\"\'" ); // The quote characters.

   // Tokenize the intput.
   boost::tokenizer< separator_type > tokens( input, separator );

   // Copy non-empty tokens from the tokenizer into the result.
   std::vector< std::string > result;
   copy_if( tokens.begin(), tokens.end(), std::back_inserter( result ), 
            !boost::bind( &std::string::empty, _1 ) );
   return result;
}

/// @brief option_builder provides a unary operator that can be used within
///        stl::algorithms.
template < typename ResultType,
           typename Builder >
class option_builder
{
public:

  typedef ResultType result_type;

public:

  /// @brief Constructor
  option_builder( const boost::program_options::options_description& options,
                  Builder builder )
    : options_( options ),
      builder_( builder )
  {}

  /// @brief Unary operator that will parse @c value, then delegate the
  ///        construction of @c result_type to the builder.
  template < typename T >
  result_type operator()( const T& value )
  {
    // Tokenize the value so that the command line parser can be used.
    std::vector< std::string > tokens = tokenize( value, "= " );

    // Parse the tokens.
    namespace po = boost::program_options;
    po::variables_map vm;
    po::store( po::command_line_parser( tokens ).options( options_ ).run(),
               vm );
    po::notify( vm );

    // Delegate object construction to the builder.
    return builder_( vm );
  }

private:

  const boost::program_options::options_description& options_;
  Builder builder_;

};

/// @brief  Convenience function used to create option_builder types.
template < typename T,
           typename Builder >
option_builder< T, Builder > make_option_builder(
  const boost::program_options::options_description& options,
  Builder builder )
{
  return option_builder< T, Builder >( options, builder );
}

/// @brief Convenience function for when a 'store_to' value is being provided
///        to typed_value.
///
/// @param store_to The variable that will hold the parsed value upon notify.
///
/// @return Pointer to a type_value.
template < typename T >
boost::program_options::typed_value< T >* make_value( T* store_to )
{
  return boost::program_options::value< T >( store_to );
}

/// @brief Slave type that contains an address and port.
struct slave
{
  std::string    address;
  unsigned short port;

  /// @brief Constructor.
  slave( std::string address, 
         unsigned short port )
    : address( address ),
      port( port )
  {}
};

/// @brief Stream insertion operator for slave.
///
/// @param stream The stream into which slave is being inserted.
/// @param s The slave object.
///
/// @return Reference to the ostream.
std::ostream& operator<<( std::ostream& stream, 
                          const slave& slave )
{
  return stream << "Slave address: " << slave.address 
                << ", port: "        << slave.port;
}

/// @brief Makes a slave given an address and port.
slave make_slave( const boost::program_options::variables_map& vm )
{
  // Create a slave from the variable map.
  return slave( vm["address"].as< std::string >(),
                vm["port"].as< unsigned short >() );
}

int main()
{
  // Variables that will store parsed values.
  std::vector< std::string > slave_configs;

  // Setup options.
  namespace po = boost::program_options;
  po::options_description desc( "Options" );
  desc.add_options()
    ( "slaves.slave", make_value( &slave_configs ),
                      "slave's --address ip/hostname --port num" );

  // Load setting file.
  po::variables_map vm;
  std::ifstream settings_file( "config.ini", std::ifstream::in );
  po::store( po::parse_config_file( settings_file , desc ), vm );
  settings_file.close();
  po::notify( vm );

  // Create options for slaves.slave.
  po::options_description slave_desc( "Slave Options" );
  slave_desc.add_options()
    ( "address", po::value< std::string >(),
                 "slave's hostname or ip address" )
    ( "port"   , po::value< unsigned short >(),
                 "slave's port" );

  // Transform each config into a slave via creating an option_builder that
  // will use the slave_desc and make_slave to create slave objects.  These
  // objects will be inserted into the slaves vector.
  std::vector< slave > slaves;
  std::transform( slave_configs.begin(), slave_configs.end(),
                  std::back_inserter( slaves ),
                  make_option_builder< slave >( slave_desc, make_slave ) );

  // Print slaves.
  std::copy( slaves.begin(), slaves.end(), 
             std::ostream_iterator< slave >( std::cout, "\n" ) ); 
}

产生与以前的方法相同的输出：

从机地址：localhost，端口：1111
从机地址：192.168.0.1，端口：2222

值得注意的代码修改如下：

copy_if因为它是 C++03 中被忽视的算法而创建的。
使用 Boost.Tokenizer 而不是 Boost.StringAlgo，因为 Boost.Tokenizer 更容易处理带引号的转义。
创建了一个option_builder一元仿函数，以帮助为应用转换提供惯用的重用。
make_slave现在需要 a boost::program_options::variables_map，它将从中构造一个slave对象。

这种方法也可以很容易地扩展以支持以下变体：

支持单个值的多个命令行。例如，一个配置可以支持两个从站，其中一个从站具有辅助配置，以防第一个配置失败。,这需要对分隔符执行初始标记化。
```
[奴隶]
从机 = --address localhost --port 1111, --address 127.0.0.1 --port 1112
从机 = --address 192.168.0.1 --port 2222
```
用提供给参数的变量slave_desc声明选项。然后可以将这些相同的变量绑定到工厂函数。虽然这与Boost.ProgramOptions 类型分离，但对于具有许多字段的类型可能会变得难以维护。typed_valuestore_toboost::refboost::bindmake_slavemake_slave

替代方法

替代方法仍然需要通过将多个值放入单个值来完成显式配对。但是，在解析阶段可以通过从boost::program_options::typed_value或继承来进行转换boost::program_options::untyped_value。

从继承时typed_value，覆盖该parse函数。使用的一个后果typed_value是模板参数必须满足typed_value. 例如，如果typed_value< slave >使用了，则需要将其设为默认可slave构造istream，>>并为.ostream<<slave
继承自时untyped_value，同时覆盖parse和notify函数。这种方法不会像那样强加类型要求typed_value，但它确实要求派生类维护自己的store_to变量。

建议

当绝对确定永远不会有可选字段并且字段数量最少（2~）时，请使用隐含配对方法。
如果有最少数量的字段 (2~) 并且可以在没有字段名称标识符的情况下以有意义的方式表示值，则使用基本的显式配对。可以支持可选字段，但它增加了语法和解析器的复杂性。
对于所有其他情况，或存在任何不确定性时，请使用高级显式配对。虽然它可能需要更多的工作，但它提供了更大的可重用性。例如，如果从属配置变得如此复杂以至于每个从属都有自己的配置文件，那么代码更改很少，因为只需要更改解析器类型和调用。

c++ - boost::program_options 和 ini 文件中的多个部分

1 回答 1

隐含配对

基本显式配对

高级显式配对

替代方法

建议

Related

Reference