C++ 通过尽可能传递模板来简化模板函数？

我写了一个小例子来说明这个问题

solve_bs1_y

和

solve_bs2_y

的实现完全相似。唯一的区别是函数调用：

solve\u bs*\u z

。不幸的是，似乎无法将模板作为参数传递，以替换

solve\u bs*\u z

的函数调用。因此，我必须为每个

solve_bs*_z

实现另一个

solve_bs*_y

。有没有办法简化代码，使我只需要一个

solve\u bs\u y

的实现

// Example program
#include <iostream>
#include <string>

template <int x, int y, int offs, class T>
float solve_bs1_z(T mat, float fS, float fT, float fU) {
  return 1; // to keep it simple
}

template <int x, int y, int offs, class T>
float solve_bs2_z(T mat, float fS, float fT, float fU) {
  return 2; // to keep it simple
}

// essentially the same as solve_bs2_y
template <int x, int offs, class T>
float solve_bs1_y(T mat, float fS, float fT, float fU) {
  const float bs_s = 2;

  return    ( solve_bs1_z<x, 0, offs>(mat, fS, fT, fU)
      + solve_bs1_z<x, 1, offs>(mat, fS, fT, fU)
      + solve_bs1_z<x, 2, offs>(mat, fS, fT, fU))
      * bs_s;
}
// essentially the same as solve_bs1_y
template <int x, int offs, class T>
float solve_bs2_y(T mat, float fS, float fT, float fU) {
  const float bs_s = 2;

  return    ( solve_bs2_z<x, 0, offs>(mat, fS, fT, fU)
      + solve_bs2_z<x, 1, offs>(mat, fS, fT, fU)
      + solve_bs2_z<x, 2, offs>(mat, fS, fT, fU) )
      * bs_s;
}

// these are called in the program ..
template<int offs, class T>
float solve_ffd_bs1(T mat, float fS, float fT, float fU) {
  return    solve_bs1_y<0, offs>(mat, fS, fT, fU) +
      solve_bs1_y<1, offs>(mat, fS, fT, fU) +
      solve_bs1_y<2, offs>(mat, fS, fT, fU);
}

template<int offs, class T>
float solve_ffd_bs2(T mat, float fS, float fT, float fU) {
  return    solve_bs2_y<0, offs>(mat, fS, fT, fU) +
      solve_bs2_y<1, offs>(mat, fS, fT, fU) +
      solve_bs2_y<2, offs>(mat, fS, fT, fU);
}


int main()
{
    int mat[3][3][3] = {
        {{1,2,3}, {4,5,6}, {7,8,9}},
        {{11,2,3}, {14,5,6}, {17,8,9}},
        {{21,2,3}, {24,5,6}, {27,8,9}}
        };


  solve_ffd_bs2<0>(mat, 1,2,3);

  return 0;
}

//示例程序
#包括
#包括
模板
浮点解算_bs1_z（T-mat、浮点fS、浮点fT、浮点fU）{
返回1；//以保持简单
}
模板
浮点解算_bs2_z（T-mat、浮点fS、浮点fT、浮点fU）{
返回2；//保持简单
}
//本质上与solve_bs2_y相同
模板
浮点数解算（T矩阵、浮点数fS、浮点数fT、浮点数fU）{
常量浮点数bs_s=2；
返回（求解bs1_z（mat、fS、fT、fU）
+求解bs1_z（mat、fS、fT、fU）
+求解（mat，fS，fT，fU））
*学士学位；
}
//基本上与solve_bs1_y相同
模板
浮点数解算（T矩阵、浮点数fS、浮点数fT、浮点数fU）{
常量浮点数bs_s=2；
返回（求解bs2_z（mat、fS、fT、fU）
+求解bs2_z（mat、fS、fT、fU）
+求解（mat，fS，fT，fU））
*学士学位；
}
//这些在程序中被调用。。
模板
浮点解算\u ffd\u bs1（T垫、浮点fS、浮点fT、浮点fU）{
返回解算结果（mat、fS、fT、fU）+
解算bs1_y（垫、fS、fT、fU）+
解算（mat、fS、fT、fU）；
}
模板
浮点数解算\浮点数解算\浮点数bs2（T垫、浮点数fS、浮点数fT、浮点数fU）{
返回解算（mat、fS、fT、fU）+
解算bs2_y（垫、fS、fT、fU）+
解算（mat，fS，fT，fU）；
}
int main（）
{
国际材料[3][3][3]={
{{1,2,3}, {4,5,6}, {7,8,9}},
{{11,2,3}, {14,5,6}, {17,8,9}},
{{21,2,3}, {24,5,6}, {27,8,9}}
};
求解_ffd_bs2（mat，1,2,3）；
返回0；
}

不带结构模板的包装器版本：

struct s1 {
    template <int x, int y, int offs, class T>
    static float solve_bs_z(T mat, float fS, float fT, float fU) {
      return 1; // to keep it simple
    }
};

struct s2 {
    template <int x, int y, int offs, class T>
    static float solve_bs_z(T mat, float fS, float fT, float fU) {
      return 2; // to keep it simple
    }
};

template <class Wrapper, int x, int offs, class T>
float solve_bs_y(T mat, float fS, float fT, float fU) {
  const float bs_s = 2;

  return    ( Wrapper::template solve_bs_z<x, 0, offs>(mat, fS, fT, fU)
      + Wrapper::template solve_bs_z<x, 1, offs>(mat, fS, fT, fU)
      + Wrapper::template solve_bs_z<x, 2, offs>(mat, fS, fT, fU))
      * bs_s;
}

struct s1{
模板
静态浮点解算（T-mat、浮点fS、浮点fT、浮点fU）{
返回1；//以保持简单
}
};
结构s2{
模板
静态浮点解算（T-mat、浮点fS、浮点fT、浮点fU）{
返回2；//保持简单
}
};
模板
浮点解算（T矩阵、浮点fS、浮点fT、浮点fU）{
常量浮点数bs_s=2；
返回（包装器：：模板解算（mat、fS、fT、fU）
+包装器：：模板求解（mat、fS、fT、fU）
+包装器：：模板求解（mat，fS，fT，fU））
*学士学位；
}

然后打电话：

solve_bs_y<s1, 0, 1>(...);

solve_bs_y（…）；

不带结构模板的包装器版本：

struct s1 {
    template <int x, int y, int offs, class T>
    static float solve_bs_z(T mat, float fS, float fT, float fU) {
      return 1; // to keep it simple
    }
};

struct s2 {
    template <int x, int y, int offs, class T>
    static float solve_bs_z(T mat, float fS, float fT, float fU) {
      return 2; // to keep it simple
    }
};

template <class Wrapper, int x, int offs, class T>
float solve_bs_y(T mat, float fS, float fT, float fU) {
  const float bs_s = 2;

  return    ( Wrapper::template solve_bs_z<x, 0, offs>(mat, fS, fT, fU)
      + Wrapper::template solve_bs_z<x, 1, offs>(mat, fS, fT, fU)
      + Wrapper::template solve_bs_z<x, 2, offs>(mat, fS, fT, fU))
      * bs_s;
}

struct s1{
模板
静态浮点解算（T-mat、浮点fS、浮点fT、浮点fU）{
返回1；//以保持简单
}
};
结构s2{
模板
静态浮点解算（T-mat、浮点fS、浮点fT、浮点fU）{
返回2；//保持简单
}
};
模板
浮点解算（T矩阵、浮点fS、浮点fT、浮点fU）{
常量浮点数bs_s=2；
返回（包装器：：模板解算（mat、fS、fT、fU）
+包装器：：模板求解（mat、fS、fT、fU）
+包装器：：模板求解（mat，fS，fT，fU））
*学士学位；
}

然后打电话：

solve_bs_y<s1, 0, 1>(...);

solve_bs_y（…）；

是否正在寻找函数指针作为模板参数？参见此处示例：唯一的区别是函数调用。这意味着他们有相同的身体？这确实没有多大意义。我不能使用函数指针，因为我在想要简化的函数中使用了一个模板。模板在原地解析。@dgrat您能将独立函数包装成静态成员函数吗？仅供参考：OP中的代码并不是最简单的。我想它隐藏了你真正想做的事。我做了一个我认为更好的最简单的例子，你在寻找函数指针作为模板参数吗？参见此处示例：唯一的区别是函数调用。这意味着他们有相同的身体？这确实没有多大意义。我不能使用函数指针，因为我在想要简化的函数中使用了一个模板。模板在原地解析。@dgrat您能将独立函数包装成静态成员函数吗？仅供参考：OP中的代码并不是最简单的。我想它隐藏了你真正想做的事。我做了一个我认为更好的最小情况这个解决方案很好，我忘记了使用结构。。但奇怪的是，我们需要他们。为什么语言不直接支持无结构方法？@dgrat“为什么语言不直接支持无结构方法？”这可能与以下事实有关：结构不能重载，而函数（即使是模板化的函数）可以重载。现在，当您将重载模板函数的名称作为模板参数编译器之类的东西传递时，您可能不确定您想到的是哪个重载。@dgrat哦，我忘了补充一句，我觉得自己不是语言律师，所以我可能错了：）当适当地询问时，这可能是一个好问题！该语言无法直接支持无结构方法，因为该语言不支持函数的部分模板专门化。它之所以这样做是因为函数重载（和函数模板重载）Herb Sutter这个解决方案很好，我忘记了使用结构。。但奇怪的是，我们需要他们。为什么语言不直接支持无结构方法？@dgrat“为什么语言不直接支持无结构方法？”这可能与以下事实有关：结构不能重载，而函数（即使是模板化的函数）可以重载。现在，当您将重载模板函数的名称作为模板参数编译器传递时，可能无法确定您想到的是哪个重载。@dgrat噢，我忘了补充一句，我不觉得自己是语言律师，所以我可能错了：）当适当地询问时，这可能是一个好主意