C++ 在添加_选项（）后更改boost:：program_options中的值语义。即默认值

我偶然发现了标题中定义的问题。我有一个应用程序，它创建了

options\u description

的实例，然后在其上使用

add\u options（）

。 与示例中的情况非常相似：

options_description desc;
desc.add_options()
("help", "produce help")
("optimization", value<int>()->default_value(10), "optimization level")
;

高度优化的版本，允许选择性地执行奇特的操作：

class HighlyOptimizedClass : public BaseClass {
public:
  HighlyOptimizedClass();
  virtual int parse(const int argc, char** argv);
private:
  bool fancy_optimizations;
};

HighlyOptimizedClass(): BaseClass() {
  m_desc.add_options()
   ("fancy,f", po::value<bool>()->zero_tokens(), "perform fancy optimizations")
  ;
}

HighlyOptimizedClass::parse(const int argc, char** argv)
{
  int ret = BaseClass::parse(argc, argv);      //execute base function
  if( ret ) return ret;                        //return if it didnt succed
  if ( vm.count("fancy") ) fancy_optimizations = 1;  // non-base stuff
  return 0;
}

class HighlyOptimizedClass:公共基类{
公众：
HighlyOptimizedClass（）；
虚拟整数解析（常量整数argc，字符**argv）；
私人：
布尔花式优化；
};
HighlyOptimizedClass（）：基类（）{
m_desc.添加_选项（）
（“fancy，f”，po:：value（）->zero_令牌（），“执行fancy优化”）
;
}
HighlyOptimizedClass:：parse（常量int argc，字符**argv）
{
int ret=BaseClass:：parse（argc，argv）；//执行基函数
if（ret）ret ret；//如果未成功返回
if（vm.count（“fancy”））fancy\u optimizations=1；//非基本内容
返回0；
}

允许启用详细调试的非优化版本：

class NonOptimizedClass : public BaseClass {
public:
  NonOptimizedClass();
  virtual int parse(const int argc, char** argv);
private:
  bool verbose_debug;
};

NonOptimizedClass(): BaseClass() {
  m_desc.add_options()
   ("verbose,v", po::value<bool>()->zero_tokens(), "genrates TONS of output")
  ;
}

NonOptimizedClass::parse(const int argc, char** argv)
{
  int ret = BaseClass::parse(argc, argv);       // execute base function
  if( ret ) return ret;                         // return if it didnt succed
  if ( vm.count("verbose") ) verbose_debug = 1; // non-base stuff
  return 0;
}

类非优化类：公共基类{
公众：
非优化类（）；
虚拟整数解析（常量整数argc，字符**argv）；
私人：
bool-verbose\u调试；
};
非优化类（）：基类（）{
m_desc.添加_选项（）
（“verbose，v”，po:：value（）->zero_tokens（），“生成大量输出”）
;
}
非优化类：：解析（常量int argc，字符**argv）
{
int ret=BaseClass:：parse（argc，argv）；//执行基函数
if（ret）ret ret；//如果未成功返回
if（vm.count（“verbose”））verbose_debug=1；//非基本内容
返回0；
}

我试着垂直压缩它，但它还是变长了。对不起，我太过火了。反过来，这些例子也很清楚，而且内容完整

BaseClass

设置了几乎所有的东西，并解析了常见的东西。派生类在构造函数和重载解析中添加自己的选项。它们执行基本解析器并检查错误。这也使得

--help

起作用

---

现在的问题是修改每个派生的优化的默认值。如果将

非优化类

设置得很低，将

优化类

设置得很高，那就太好了允许您对

选项的描述进行写访问

常数共享\u ptr

不是

共享\u ptr

但是，如果我遇到这种问题，我会使用

add\u output\u file（std:：string default）

，并让它调用

add\u option

。（很可能，尽管从界面上看上述内容似乎是合法的，但这样弄乱内部结构可能会混淆

boost

库。

您可以调用以获取对相关

选项的引用\u description

，其方法将为您提供一个指向最初提供的

值\u semantic

调用

add\u options

时，它会被禁用。但是，它是一个常量指针，因此您似乎不允许修改它所指向的内容

但是，

value\u semantic

在您创建它时不是常量，这意味着使用

const\u cast

删除

选项\u description

应用的常量限定应该是安全的。您还必须将

value\u semantic

对象类型转换回右侧

键入的\u value

类型当您最初调用

value

时，使用ot

---

好的，所以我发现在当前版本中，通过

const\u cast

修改

value\u语义

不违反

program\u选项

的现有设计是不可能的

在阅读了Rob Kennedy和Yakk的答案和建议后，我提出了一种将两者结合起来的方法。它应该按照描述的那样工作，不应该让任何不必要的事情变得杂乱无章

我们的想法是添加一个选项，该选项将在单独的调用中更改。将其设置为虚拟并在基类中定义默认的大小写

这种方法允许一次定制整个

程序\u选项

，而不仅仅是单个语义。为每个可能发生更改的情况添加参数或方法对我来说非常麻烦

修改后的代码如下所示：

基地

类基类{
公众：
基类：：基类（）；
虚拟整数解析（常量整数argc，字符**argv）；
私人：
虚拟无效添加_优化_选项（）；
采购订单：：选项描述m描述；
变量映射虚拟机；
int-u水平；
};
基类：：基类（）：m_desc（）{
m_desc.add_options（）（“帮助”、“生成帮助”）；
}
void基类：：添加优化选项（）{
m_desc.添加_选项（）
（“优化”，value（）->默认_值（10），“优化级别”）；
}

优化版本：

class HighlyOptimizedClass : public BaseClass {
public:
  HighlyOptimizedClass();
  virtual int parse(const int argc, char** argv);
private:
  virtual void add_optimization_option();
  bool fancy_optimizations;
};

void HighlyOptimizedClass::add_optimization_option(){
  m_desc.add_options()
   ("optimization", value<int>()->default_value(99), "optimization level");
}

class HighlyOptimizedClass:公共基类{
公众：
HighlyOptimizedClass（）；
虚拟整数解析（常量整数argc，字符**argv）；
私人：
虚拟无效添加_优化_选项（）；
布尔花式优化；
};
void HighlyOptimizedClass:：添加优化选项（）{
m_desc.添加_选项（）
（“优化”，value（）->默认_值（99），“优化级别”）；
}

非优化：

class NonOptimizedClass : public BaseClass {
public:
  NonOptimizedClass();
  virtual int parse(const int argc, char** argv);
private:
  virtual void add_optimization_option();
  bool verbose_debug;
};

void NonOptimizedClass::add_optimization_option(){
  m_desc.add_options()
   ("optimization", value<int>()->default_value(0), "optimization level");
}

类非优化类：公共基类{
公众：
非优化类（）；
虚拟整数解析（常量整数argc，字符**argv）；
私人：
虚拟无效添加_优化_选项（）；
bool-verbose\u调试；
};
作废非优化类：：添加优化选项（）{
m_desc.添加_选项（）
（“优化”，value（）->默认_值（0），“优化级别”）；
}

成本是为每个修改的选项添加一个私有方法，并为每个我们想要修改的情况重载一个私有方法。如果想要保留默认值，则不需要任何东西。 如果可以修改

值，则可以避免定义新方法。
BaseClass::BaseClass(int default_optimization):
  m_desc()
{
  m_desc.add_options()
    ("help",
      "produce help")
    ("optimization",
      value<int>()->default_value(default_optimization),
      "optimization level")
    ;
}

HighlyOptimizedClass::HighlyOptimizedClass():
  BaseClass(99)
{ }

NonOptimizedClass::NonOptimizedClass():
  BaseClass(0)
{ }

class BaseClass {
public:
  BaseClass::BaseClass();
  virtual int parse(const int argc, char** argv);
private:
  virtual void add_optimization_option();
  po::options_description m_desc;
  po::variables_map vm;
  int optimization_level;
};

BaseClass::BaseClass(): m_desc() {
  m_desc.add_options()("help", "produce help");
}

void BaseClass::add_optimization_option(){
 m_desc.add_options()
  ("optimization", value<int>()->default_value(10), "optimization level");
}

class HighlyOptimizedClass : public BaseClass {
public:
  HighlyOptimizedClass();
  virtual int parse(const int argc, char** argv);
private:
  virtual void add_optimization_option();
  bool fancy_optimizations;
};

void HighlyOptimizedClass::add_optimization_option(){
  m_desc.add_options()
   ("optimization", value<int>()->default_value(99), "optimization level");
}

class NonOptimizedClass : public BaseClass {
public:
  NonOptimizedClass();
  virtual int parse(const int argc, char** argv);
private:
  virtual void add_optimization_option();
  bool verbose_debug;
};

void NonOptimizedClass::add_optimization_option(){
  m_desc.add_options()
   ("optimization", value<int>()->default_value(0), "optimization level");
}