如何使同一类的对象在同一函数中执行不同的操作？ 我正在C++中做游戏，我在想如何让一个类的2个对象在调用相同函数时做不同的事情。我的意思是，我有两个按钮，当我点击其中一个时，它应该开始游戏，当我点击另一个时，它应该结束游戏。这只是一个简单的示例，但基本上我只想调用函数click（），您单击的按钮将执行与其他按钮不同的代码。

在函数中添加一个条件，检查对象的某些属性，例如实例变量的值。

在函数中设置条件，检查对象的某些属性，例如实例变量的值。

您可以将函数对象（functor）或函数指针作为数据成员。
每个实例将为单击提供不同的函子。

您可以将函数对象（函子）或函数指针作为数据成员。

---

每个实例将提供一个不同的函数，用于单击。

一种方法是创建一个接口（C++是一个纯虚拟方法和虚拟析构函数的类）。让我们调用该类clickHandler来处理按钮示例。在clickHandler上调用的click函数

doclick

中，按钮已经给出。现在，当你创建你的按钮时，你给他们一个clickHandler的子类，它做正确的事情

---

其他选项包括使用C++新增的lambdas。

一种方法是创建一个接口（C++是一个纯虚拟方法和虚拟析构函数的类）。让我们调用该类clickHandler来处理按钮示例。在clickHandler上调用的click函数

doclick

中，按钮已经给出。现在，当你创建你的按钮时，你给他们一个clickHandler的子类，它做正确的事情

---

其他选项包括使用C++新添加的lambda。

坦白说，这听起来像是糟糕的设计。几乎唯一的方法就是以其他形式将标志或状态传递给方法。但是如果您正在这样做，那么按钮已经知道需要做什么，您也可以创建和调用单独的方法。或者，您可以放弃让对象属于同一个类的要求，将继承与虚拟方法结合使用。然而，如果不同的子类对于这些子类具有截然不同的语义，那么这也可能是糟糕设计的标志。所以我建议使用不同的方法并显式调用它们。

坦白说，这听起来像是糟糕的设计。几乎唯一的方法就是以其他形式将标志或状态传递给方法。但是如果您正在这样做，那么按钮已经知道需要做什么，您也可以创建和调用单独的方法。或者，您可以放弃让对象属于同一个类的要求，将继承与虚拟方法结合使用。然而，如果不同的子类对于这些子类具有截然不同的语义，那么这也可能是糟糕设计的标志。因此，我建议使用不同的方法并显式调用它们。

我假设您正在构建自己的游戏引擎，而不是使用实际处理这些事情的库

您要做的是为每个函数注册一个回调。这就是所有UI库/框架所做的。在一个简单的例子中：

class Button{
std::function<void()> callback;

public:

void connect(std::function<void()> func){
   callback=func
}
void click(){
  callback();
}
};

class按钮{
函数回调；
公众：
无效连接（标准：：函数func）{
callback=func
}
无效单击（）{
回调（）；
}
};

---

通过提供不同的回调来连接，您可以实现不同的功能。

我假设您正在构建自己的游戏引擎，而不是使用实际处理这些事情的库

您要做的是为每个函数注册一个回调。这就是所有UI库/框架所做的。在一个简单的例子中：

class Button{
std::function<void()> callback;

public:

void connect(std::function<void()> func){
   callback=func
}
void click(){
  callback();
}
};

class按钮{
函数回调；
公众：
无效连接（标准：：函数func）{
callback=func
}
无效单击（）{
回调（）；
}
};

---

通过提供不同的回调来连接，您可以实现不同的功能。

我认为您需要的是多态性。查看代码：

    #include <iostream>
    using namespace std;
    class Button
    {
    public:
            virtual void click()
            {
                    cout << "Button click\n";
            }
    };

    class StartButton : public Button
    {
    public:
            void click()
            {
                    cout << "Start click\n";
            }
    };

    class EndButton : public Button
    {
    public:
            void click()
            {
                    cout << "End click\n";
            }
    };

    void make_click (Button * button)
    {
            button -> click();
    }

    int main ()
    {
            StartButton * start = new StartButton();
            EndButton * end = new EndButton();
            make_click(start);
            make_click(end);
            return 0;
    }

---

你可以找到一本不错的教程。

我想你要找的是多态性。查看代码：

    #include <iostream>
    using namespace std;
    class Button
    {
    public:
            virtual void click()
            {
                    cout << "Button click\n";
            }
    };

    class StartButton : public Button
    {
    public:
            void click()
            {
                    cout << "Start click\n";
            }
    };

    class EndButton : public Button
    {
    public:
            void click()
            {
                    cout << "End click\n";
            }
    };

    void make_click (Button * button)
    {
            button -> click();
    }

    int main ()
    {
            StartButton * start = new StartButton();
            EndButton * end = new EndButton();
            make_click(start);
            make_click(end);
            return 0;
    }

---

你可以找到一个很好的教程。

将状态（按钮编号）放入类中，并让您的函数通过继承和虚拟函数或指向成员函数的指针或指定要执行的操作的标志来选择如何处理它。@CaptainObvlious我认为在这种情况下继承比需要的复杂一点。@La comadreja一个简单的按钮类，带有虚拟的

OnClick

成员函数一点也不复杂。将状态（按钮编号）放入类中，并让您的函数通过继承和虚拟函数或指向成员函数的指针或指定要执行的操作的标志来选择如何处理它。@CaptainObvlious我认为在这种情况下继承比需要的复杂一点。@La comadreja一个简单的按钮类，带有虚拟的

OnClick

成员功能一点也不复杂，设计也不错。使用回调定制行为是一种标准模式。请参阅例如回答如何做到这一点。它的设计一点也不差。使用回调定制行为是一种标准模式。参见例如回答如何执行此操作。+1。如果按钮具有相同的代码，

std:：function

成员可能是正确答案。+1。如果按钮具有相同的代码，则

std:：function

成员可能是正确答案。