Question

假设我有一个函数f = sigma（phi（x）），我想为函数sigma和phi指定不同的形式。我们说我们有两个sigma函数和两个phi函数所以我们有4 = 2 * 2组合。我怎么能做到这一点？

如果仅用于f = sigma（x），我将sigma写为f中的虚函数，并将sigma的特定形式定义为子类。

class sigma1: public class f{sigma=sigma1}

class sigma2: public class f{sigma=sigma2}

但是当涉及到phi时，我真的很困惑。我想我还需要将phi定义为虚函数。但是对于特定的phi，它应该是

class phi1 : public sigma1, public sigma 2

class phi2 : public sigma1, public sigma 2

说我想创建一个对象sigma1 + phi1。我怎么能这样做？如果我只是写

phi1 object1

然后很明显它无法知道使用sigma1或sigma2。虚拟继承似乎也不起作用。我知道我可以创建四个类

class phi1 : public sigma1 {phi=phi1}

class phi2 : public sigma2 {phi=phi1}

class phi3 : public sigma1 {phi=phi2}

class phi4 : public sigma2 {phi=phi2}

但这似乎并不聪明......

Answer 1

不清楚，对我来说，你打算如何使用你的课程（或功能，或你想要什么），但我建议你提出以下基于你的phi假设的简单解决方案（）和sigma（）函数是接收类型为T的变量并返回相同类型T的值的函数。

所以我构建了一个模板化仿函数，它接收类型T，函数Sigma和Phi作为参数

template <typename T, T (*Sigma)(const T &), T (*Phi)(const T &)>
struct f
 {
   T operator() (const int & x) const
    { return Sigma(Phi(x)); }
 };

以下是sigma（）和phi（）函数接收int并返回int

的完整示例

#include <iostream>

int sigma1 (const int & x)
 { return x+1; }

int sigma2 (const int & x)
 { return x-1; }

int phi1 (const int & x)
 { return x+10; }

int phi2 (const int & x)
 { return x-10; }


template <typename T, T (*Sigma)(const T &), T (*Phi)(const T &)>
struct f
 {
   T operator() (const int &x) const
    { return Sigma(Phi(x)); }
 };


int main ()
 { 
   f<int, sigma1, phi1>  f11;
   f<int, sigma1, phi2>  f12;
   f<int, sigma2, phi1>  f21;
   f<int, sigma2, phi2>  f22;

   std::cout << "f11(100) = " << f11(100) << std::endl;
   std::cout << "f12(100) = " << f12(100) << std::endl;
   std::cout << "f21(100) = " << f21(100) << std::endl;
   std::cout << "f22(100) = " << f22(100) << std::endl;

   return 0;
 }

其他解决方案是可行的;例如，您可以编写模板化函数而不是模板化函数。

但是，我再说一遍：对我来说，不清楚你想要获得什么。

p.s：抱歉我的英语不好

C ++中的多重继承逻辑

1 个答案: