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

Question

在下面的代码中，我的意图是根据传递给material 类对象的参数来调用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
}

也失败了，因为“三元运算符的结果总是必须是相同的类型”出于编译时的原因，正如similar question 中所指出的那样（尽管似乎没有解释）。

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

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

Answer 1

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

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

Answer 2

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

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

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

Answer 3

为了避免复制开销，假设你有一个 C++0x 编译器，你可以给 opacity 一个 move constructor 并让一个静态函数根据你的逻辑提供一个 opacity 的实例并初始化你的 kap 成员使用返回的临时opacity。

您可能想要创建 kappa_array 一些指针，例如 auto_ptr<double>。尽管如果在紧密循环中使用此数据，与局部性和取消引用指针的成本相比，可移动性所节省的成本可能是值得怀疑的。

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)) { }

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

Answer 4

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

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