从构造函数初始化列表中调用重载构造函数

Question

在下面的代码中，我的目的是根据传递给类 的对象的参数来调用 kap （类 opacity）的两个重载构造函数之一材料：

class opacity{
 private:
  int mode;
  double kap_const;
  double kappa_array[10][10];

 public:
  opacity(double constkap);  // picking the constructor sets the mode
  opacity(char* Datafile);
  double value(double T, double P); // will return a constant or interpolate
};

opacity::opacity(double constkap):mode(1){
  kap_const = constkap;
}

opacity::opacity(char* Datafile):mode(2){
  // read file into kappa_array...
}

class Matter {
 public:
  Matter(int i, double k, char* filename); // many more values are actually passed
  opacity kap;
  int x;  // dummy thing
  // more variables, call some functions
};

Matter::Matter(int i, double k, char * filename)
 :x(k>0? this->kap(x): this->kap(filename) ) {
  // ... rest of initialisation
 }

然而，这不起作用：

test.cpp: In constructor 'Matter::Matter(int, double, char*)':
test.cpp:32:21: error: no match for call to '(opacity) (void*&)'
test.cpp:32:42: error: no match for call to '(opacity) (char*&)'
test.cpp:32:44: error: no matching function for call to 'opacity::opacity()'
test.cpp:32:44: note: candidates are:
test.cpp:20:1: note: opacity::opacity(char*)
test.cpp:20:1: note:   candidate expects 1 argument, 0 provided
test.cpp:16:1: note: opacity::opacity(double)
test.cpp:16:1: note:   candidate expects 1 argument, 0 provided
test.cpp:4:7: note: opacity::opacity(const opacity&)
test.cpp:4:7: note:   candidate expects 1 argument, 0 provided

我尝试的第一件事

Matter::Matter(int i, double k, char * filename)
 :kap(k>0? k: filename) {   // use k<0 as a flag to read from filename
  // ... rest of initialisation
}

也失败了，因为出于编译时原因，“三元运算符的结果始终必须是相同的类型”，如 <一个href="https://stackoverflow.com/questions/4693629/ternary-operator?answertab=votes#tab-top">类似问题（尽管似乎没有在那里解释）。

现在，不优雅的解决方案是根据 kap 构造函数应接收的参数重载 Matter 构造函数，但这 (1) 非常不优雅，特别是因为Matter 构造函数接受许多变量并执行许多操作（因此会重复很多代码，只是为了改变构造函数初始化列表的 kap 部分），并且 (2)如果还有另一个可能会失控与 Matter 一起使用的类也具有不同的构造函数：对于具有 N 个 C'tors 的 M 个类，最终会得到 N em>^ M 组合...

有人有建议或解决方法吗？提前致谢！

Answer 1

您不能使用三元运算符来选择函数覆盖，因为该运算符的结果只有单一类型。在不同分支具有不同类型的情况下，它们将被强制为结果类型，否则将出现编译时错误。请参阅http://en.wikipedia.org/wiki/%3F:#Result_type

确实不可能有其他方式。编译器需要在编译时知道类型，但直到运行时才知道操作的结果。

Answer 2

如果 opacity 有复制构造函数，您可以在初始化列表中完成此操作，避免使用默认构造函数，但代价是复制：

  Matter::Matter(int i, double k, char * filename)
     :kap( ( 0 < k ) ? opacity(k) : opacity( filename ) ) { ... }

Answer 3

您将不得不忍受向 opacity 添加默认构造函数（这可能将模式设置为 0 以指示无效模式）并分配给 kap在构造函数主体中。

Matter::Matter(int i, double k, char * filename) {
  if(k > 0)
    kap = opacity(k);
  else
    kap = opacity(filename);
}

参数k是运行时值。不可能使类型和重载结果依赖于运行时值。

Answer 4

为了避免复制开销，并假设您有 C++0x 编译器，您可以为不透明度指定 移动构造函数并让静态函数根据您的逻辑提供opacity实例，并使用返回的临时opacity初始化您的kap成员>。

您可能希望将 kappa_array 设为一些指针，例如 auto_ptr。尽管如果在紧密循环中使用此数据，则与局部性和取消引用指针的成本相比，可移动性带来的节省可能是值得怀疑的。

opacity& get_opacity(double k, char * filename) {
    if(k > 0)
        return opacity(k);
    else
        return opacity(filename);
}

Matter::Mater(int i, double k, char * filename)
    : kap(get_opacity(k, filename) {
   //...
}

opacity::opacity(opacity&& other)
    : mode(other.mode),
      kap_const(other.kap_const),
      kappa_array(std::move(kappa_array)) { }

请不要在这方面测试我，我自己对移动语义和右值引用还很陌生......