C++ 方法从C+中的另一个对象执行+；

首先，请允许我介绍一下我的班级结构。我正在为ARM设备（STM32）设计一个小库，我想实现两个对象，定义系统上可用的不同外设

class xGPIO : public Peripheral 
{
public:
    xGPIO();
    xGPIO(GPIO_TypeDef * GPIOx1, uint16_t Pinx1);
    virtual ~xGPIO();

    void on(void);
    void off(void);
private:
    void xInitGPIO(void);

};

我想到的想法是实现一个名为callback的内部公共函数，该函数设置下一个在计时器对象上调用的函数。不过，这个函数肯定是在另一个类中定义的方法，我希望它从xTimer执行。这里的行为应该是，每当计时器结束倒计时时，它都应该调用程序员在回调方法中存储的函数

class xTimer : public Peripheral 
{
public:
    xTimer(TIM_TypeDef * tim);
    virtual ~xTimer();
    /* void callBack(void (*f)()); */

private:
    void xInitTimer(void);
    TIM_HandleTypeDef htim;
};

void xTimer::callBack(void (*f)())
{
   f();
}

main.cpp下的代码如下：

int main(void)
{
    mySYS->initialize(false);

    xGPIO myGreenLed (GPIOB, GPIO_PIN_0);

    /* Declare Timers.  */
    xTimer myTimer(TIM2);    
    // myTimer.callBack(myGreenLed.on);
}

---

关于如何解决这个问题有什么线索吗？有没有一种简单的方法来满足C++程序的设计？p> 您正在使用C模式。C++有更强大的<代码> STD:：函数< /代码>。您的

xTimer:：callBack

应定义为

void xTimer::callBack(std::function<void(void)> f) { f(); }

或

---

您正在使用C模式。C++有更强大的<代码> STD:：函数< /代码>。您的

xTimer:：callBack

应定义为

void xTimer::callBack(std::function<void(void)> f) { f(); }

或

---

直接使用模板时，也可以不使用

std:：function

：

template<class T>
class xTimer : public Peripheral 
{
public:
    xTimer(TIM_TypeDef * tim);
    virtual ~xTimer();
    void callBack(T &obj, void (*T::f)())
    {
        (obj.*f)();
    }

private:
    void xInitTimer(void);
    TIM_HandleTypeDef htim;
};

模板
类xTimer：公共外设
{
公众：
xTimer（TIM_TypeDef*TIM）；
虚拟的~xTimer（）；
无效回调（T&obj，void（*T:：f）（）
{
（obj.*f）（）；
}
私人：
void xInitTimer（void）；
TIM_HandleTypeDef htim；
};

并且可以像这样使用：

xTimer<xGPIO> myTimer(TIM2);    
myTimer.callBack(myGreenLed, &xGPIO::on);

xTimer-myTimer（TIM2）；
回调（myGreenLed，&xGPIO:：on）；

然后，您将失去

std:：function

的灵活性，并且它不能与

std:：bind

和lambdas一起工作，但获得了不存在分配/解除分配的优势

模板也可以只是在

回调

级别，但是我假设您实际上希望存储该值并稍后调用它，那么您需要对存储进行模板化

如果您调用的方法仅是特定单一类型的成员（即始终

xGPIO

），那么您甚至不需要模板

---

还要注意的是，如果存储了要在以后调用的对象实例，则必须确保对象的生存期一直保持到需要调用它为止（或者需要制作副本，请使用

std:：shared_ptr

等）。这也适用于使用带有对象指针的

std:：function

或

std:：ref
直接使用模板时，也可以不使用
std:：function
：

template<class T>
class xTimer : public Peripheral 
{
public:
    xTimer(TIM_TypeDef * tim);
    virtual ~xTimer();
    void callBack(T &obj, void (*T::f)())
    {
        (obj.*f)();
    }

private:
    void xInitTimer(void);
    TIM_HandleTypeDef htim;
};

模板
类xTimer：公共外设
{
公众：
xTimer（TIM_TypeDef*TIM）；
虚拟的~xTimer（）；
无效回调（T&obj，void（*T:：f）（）
{
（obj.*f）（）；
}
私人：
void xInitTimer（void）；
TIM_HandleTypeDef htim；
};

并且可以像这样使用：

xTimer<xGPIO> myTimer(TIM2);    
myTimer.callBack(myGreenLed, &xGPIO::on);

xTimer-myTimer（TIM2）；
回调（myGreenLed，&xGPIO:：on）；

然后，您将失去
std:：function
的灵活性，并且它不能与
std:：bind
和lambdas一起工作，但获得了不存在分配/解除分配的优势

模板也可以只是在
回调
级别，但是我假设您实际上希望存储该值并稍后调用它，那么您需要对存储进行模板化

如果您调用的方法仅是特定单一类型的成员（即始终
xGPIO
），那么您甚至不需要模板

还要注意的是，如果存储了要在以后调用的对象实例，则必须确保对象的生存期一直保持到需要调用它为止（或者需要制作副本，请使用
std:：shared_ptr
等）。这同样适用于将
std:：function
与对象指针一起使用，或者
std:：ref
您想要做的几乎是，但不是100%清楚。如果计时器应该调用以前设置的回调，那么为什么
void xTimer:：callback（void（*f）（）
将函数作为参数？计时器不应该事先知道要调用什么函数吗？您需要一个计时器来处理所有回调，还是每个回调可以使用不同的计时器？这个标题很容易让人误解。你不想调用另一个类的方法，你想调用另一个对象的方法，在这里
myGreenLed
。这一点至关重要：如果
xGPIO:：on
是一个
静态
类方法（即不需要对象），您可以将
&xGPIO:：on
转换为
void（*）（
@MSalters），您是对的，更正了。@tobi303我可以有几个计时器。这是一个初步的设计，最终的设计应该将函数保存到一个本地指针（或类似的）中，并在事件发生时执行它。如果计时器应该调用以前设置的回调，那么为什么
void xTimer:：callback（void（*f）（）
将函数作为参数？计时器不应该事先知道要调用什么函数吗？您需要一个计时器来处理所有回调，还是每个回调可以使用不同的计时器？这个标题很容易让人误解。你不想调用另一个类的方法，你想调用另一个对象的方法，在这里
myGreenLed
。这一点至关重要：如果
xGPIO:：on
是一个
静态
类方法（即不需要对象），您可以将
&xGPIO:：on
转换为
void（*）（
@MSalters），您是对的，更正了。@tobi303我可以有几个计时器。这是一个初步的设计，最终的设计应该将函数保存到本地指针（或类似的）中，并在事件发生时执行。
std:：function
进行动态分配，因此在裸机系统上，如果该功能可以从中断中使用（这也包括