C++ C++；继承和重载，重载后调用基方法

目前，我有一个类，它包含另一个类，并为其某些方法提供包装，并完整地提供其他方法：

class bar {
public:

    int calculate1(int a, int b) {
        return f.calculate1(a, b);
    }

    int calculate2(int a, int b) {
        a ++;
        b ++;
        return f.calculate2(a, b);
    }

private:
    foo f
}

其中

foo

是一个类，包含两个方法

calculate1

和

calculate2

，都取2

int

s并返回一个

int

有没有更好的方法通过继承来实现这一点？如果能够摆脱这个问题，那就太好了：

    int calculate1(int a, int b) {
        return f.calculate1(a, b);
    }

但这需要调用它正在重载的函数，我不知道如何做到这一点：

    int calculate2(int a, int b) {
        a ++;
        b ++;
        return f.calculate2(a, b);
    }

这是可能的还是可取的？在这种情况下，还有其他方法可以使用吗

---

抱歉，如果我的一些代码有点狡猾，你可以告诉我我有点新的C++，但是我希望我能得到这个消息。< /P> < P>调用基类方法，使用资格：

return foo::calculate1(a, b);

---

如果希望以多态方式调用基类方法，请记住确保基类方法是虚拟的。

要调用基类方法，请使用限定：

return foo::calculate1(a, b);

---

如果希望以多态方式调用基类方法，请记住确保基类方法是虚拟的。

可以通过以下方式：

class bar : public foo {
public:

    int calculate2(int a, int b) {        
        return foo::calculate2(a+1, b+1);
    }
};

---

可以通过以下方式：

class bar : public foo {
public:

    int calculate2(int a, int b) {        
        return foo::calculate2(a+1, b+1);
    }
};

---

1.

有没有更好的方法通过继承来实现这一点`

当然

//sg
#include<iostream>
class foo {
public:
    int calculate1(int a, int b) {
        return a * b;
    }

    int calculate2(int a, int b) {
        a ++;
        b ++;
        return a + b;
    }

};
class bar: public foo {
public:

    int calculate1(int a, int b) {
        return foo::calculate1(a, b);
    }

    int calculate2(int a, int b) {
        a++;
        b++;
        return foo::calculate2(a, b);
    }
};
using namespace std;
int main() {
    bar b;
    cout << b.calculate2(1,2) << endl;
    cout << b.calculate1(1,2) << endl;

    return 0;
}

//sg
#包括
福班{
公众：
整数计算1（整数a，整数b）{
返回a*b；
}
整数计算2（整数a，整数b）{
a++；
b++；
返回a+b；
}
};
分类栏：公共食品{
公众：
整数计算1（整数a，整数b）{
返回foo：：calculate1（a，b）；
}
整数计算2（整数a，整数b）{
a++；
b++；
返回foo：：calculate2（a，b）；
}
};
使用名称空间std；
int main（）{
b栏；
cout
1.
有没有更好的方法通过继承来实现这一点`

当然

//sg
#include<iostream>
class foo {
public:
    int calculate1(int a, int b) {
        return a * b;
    }

    int calculate2(int a, int b) {
        a ++;
        b ++;
        return a + b;
    }

};
class bar: public foo {
public:

    int calculate1(int a, int b) {
        return foo::calculate1(a, b);
    }

    int calculate2(int a, int b) {
        a++;
        b++;
        return foo::calculate2(a, b);
    }
};
using namespace std;
int main() {
    bar b;
    cout << b.calculate2(1,2) << endl;
    cout << b.calculate1(1,2) << endl;

    return 0;
}

//sg
#包括
福班{
公众：
整数计算1（整数a，整数b）{
返回a*b；
}
整数计算2（整数a，整数b）{
a++；
b++；
返回a+b；
}
};
分类栏：公共食品{
公众：
整数计算1（整数a，整数b）{
返回foo：：calculate1（a，b）；
}
整数计算2（整数a，整数b）{
a++；
b++；
返回foo：：calculate2（a，b）；
}
};
使用名称空间std；
int main（）{
b栏；
这里的继承在哪里？这是合成。我在问如何使用继承来实现类似的效果这里的继承在哪里？这是合成。我在问如何使用继承来实现类似的效果谢谢，你认为这比合成更好吗？@jayjay在这种情况下，可能是；如果你不确定决定，我建议阅读谢谢，你认为这比作文更可取吗？@jayjay在这种情况下，可能是这样；如果你对决定不确定，我建议阅读。你能解释一下为什么你认为继承看起来更好吗？我会说作文在这里看起来更好。而且，你的is-a has-a东西令人困惑，因为您正在使用继承来实现has-a关系。您将继承更改为
public
。这使得答案自洽，但OP的代码中没有任何东西表明继承比组合更好。您的判断是基于想象的类。@juanchopanza是的。这在第一个pl中是无意的王牌。那里没有词了。我确实提到了
foo
和
bar
的语义应该决定继承与组合。你能解释一下为什么你认为继承看起来更好吗？我认为组合在这里看起来更好。而且，你的is-a has-a东西很混乱，因为你用继承来实现has-一种关系。您将继承更改为
public
。这使答案自相矛盾，但OP的代码中没有任何东西表明继承比组合更好。您的判断是基于想象的类。@juanchopanza是的。一开始这是无意的。那里没有字眼了。我确实提到过
foo
和
bar
的语义应该决定继承与组合。