3

我正在编写一个模板化的数学矩阵类来适应一些新的 c++11 特性，基本声明如下：

template <typename Type, int kNumRows, int kNumCols>
class Matrix { ... };

该类有一个成员函数来返回其次要之一（稍后用于计算 NxN 矩阵的行列式）。

Matrix<Type, kNumRows - 1, kNumCols - 1> minor(const int row, const int col) {
  static_assert(kNumRows > 2, "");
  static_assert(kNumCols > 2, "");

  ...
}

然后我创建了一个非成员函数来计算任何方阵的行列式：

template <typename Type, int kSize>
Type determinant(const Matrix<Type, kSize, kSize>& matrix) {
  switch (kSize) {
  case 2:
    return 0; // For now unimportant
  case 3:
    // Recursively call the determinant function on a minor matrix
    return determinant(matrix.minor(0, 0));
  }
  ...
}

在 main() 中，我创建了一个 3x3 矩阵并调用determinant它。这不会编译。编译器有效地移动到案例 3，创建一个次要矩阵并调用determinant它。然后它再次进入case 3，通过尝试创建一个 1x1 次要生成一个 static_assert。

问题很简单：我在这里遗漏了什么吗？是否不允许递归调用这样的模板化函数？这是编译器错误（我对此表示怀疑）？

为了完整起见：我正在使用 Clang++。

4

3 回答 3

3

编译器生成所有代码路径，即使这些路径在执行期间并未全部访问（并且实际上可能在优化步骤中被删除）。因此，determinant<Type, kSize - 1, kSize - 1>总是被实例化，即使对于kSize< 3。

您需要部分专门化您的功能以防止这种情况发生，您需要determinant适当地重载您的功能：

template <typename Type>
Type determinant(const Matrix<Type, 2, 2>& matrix) {
  ...
}

顺便说一句，这使得switch函数中的语句变得多余。

于 2012-12-11T12:56:09.547 回答
3

模板决定了在编译时做什么，而一个switch语句决定了在运行时做什么。编译器会为所有 switch 案例生成代码，或者至少验证其有效性，即使正确的案例在编译时是“显而易见的”。

而不是使用switch，尝试重载行列式：

template <typename Type>
Type determinant(const Matrix<Type, 1, 1>& matrix) {
    return matrix(0,0);
}

template <typename Type>
Type determinant(const Matrix<Type, 2, 2>& matrix) {
    return 0; // (incorrect math)
}

template <typename Type, int kSize>
Type determinant(const Matrix<Type, kSize, kSize>& matrix) {
    return determinant(matrix.minor(0,0)); // (incorrect math)
}
于 2012-12-11T13:00:09.423 回答
1

您需要在编译时使用模板专业化进行切换：

template <typename Type, int kSize>
struct Determinate {
    Type operator()(const Matrix<Type, kSize, kSize>& matrix) const {
        // Recursively call the determinant function on a minor matrix
        return Determinate<Type, kSize-1>{}(matrix.minor(0, 0));
    }
};
template <typename Type>
struct Determinate<Type, 2> {
    Type operator()(const Matrix<Type, kSize, kSize>& matrix) const {
        return 0; // For now unimportant
    }
};
template <typename Type, int kSize>
Type determinant(const Matrix<Type, kSize, kSize>& matrix) {
    return Determinate<Type, kSize>{}(matrix);
}
于 2012-12-11T12:56:17.230 回答