是否可以制作仅具有函数成员属性的回调接口？
Posted
技术标签:
【中文标题】是否可以制作仅具有函数成员属性的回调接口？【英文标题】：Is that possible to make a callback interface with only function-member attribute? 【发布时间】：2019-07-08 09:43:05 【问题描述】：上下文：
不使用堆的嵌入式 c++。
我想掌握我的代码（包括它的大小），所以我不想使用标准库，例如 std::function。
第一种方法：
让我们使用CRTP的修改版本来举这个例子（这是我的代码的简化版本）：
注意：我的回调方法可能有这两个签名：bool (ChildCrtp::*)(void); 和 void (ChildCrtp::*)(int)（一个用于操作，一个用于条件）。
#include <iostream>
#include <stdint.h>
using namespace std;
void* operator new(size_t size)
cout << "ERROR HEAP USED" << endl;
template <typename FunctionType = void, typename... ArgumentType>
class GenericCallback
public:
virtual ~GenericCallback()
virtual FunctionType Execute(ArgumentType... arg) = 0; //!< execute callback
virtual bool IsValid() const = 0; //!< check if callback is valid
;
template <typename ObjectType, typename FunctionType = void, typename... ArgumentType>
class Callback : public GenericCallback<FunctionType, ArgumentType...>
public:
Callback() ://!< Default constructor
pObject_m(0),
pFunction_m(0)
Callback(ObjectType* pObject_m, FunctionType(ObjectType::*pFunction_m)(ArgumentType...))//!< Constructor
this->pObject_m = pObject_m;
this->pFunction_m = pFunction_m;
virtual FunctionType Execute(ArgumentType... arg)//!< execute callback implementation
return (pObject_m->*pFunction_m)(arg...);
virtual bool IsValid(void) const//!< callback validity check implementation
return (pObject_m != 0) && (pFunction_m != 0);
private:
ObjectType* pObject_m; //!< pointer to object where the callback is defined
FunctionType(ObjectType::* pFunction_m)(ArgumentType...); //!< pointer to the callback (function-member) of the object
;
template<typename ChildCrtp>
class Interface
public:
using FooSpecificCallback = Callback<ChildCrtp, bool>;
virtual int getValue(void) = 0;
bool IsPositive() return (getValue() > 0); ;
bool IsNegative(void) return (getValue() < 0); ;
bool IsEven(void) return ((getValue() % 2) == 0); ;
bool IsOdd(void) return ((getValue() % 2) == 1); ;
FooSpecificCallback isPositive_ = FooSpecificCallback(static_cast<ChildCrtp*>(this), &Interface::IsPositive);//line to be removed
FooSpecificCallback isNegative_ = FooSpecificCallback(static_cast<ChildCrtp*>(this), &Interface::IsNegative);//line to be removed
FooSpecificCallback isEven_ = FooSpecificCallback(static_cast<ChildCrtp*>(this), &Interface::IsEven);//line to be removed
FooSpecificCallback isOdd_ = FooSpecificCallback(static_cast<ChildCrtp*>(this), &Interface::IsOdd);//line to be removed
;
class Mother
public:
using FooGenericCallback = GenericCallback<bool>* ;
int getValue()return x_;;
void storeCallback(FooGenericCallback pCallback)pCallback_ = pCallback;;
bool callCallback()return (pCallback_->IsValid() == false)?:pCallback_->Execute();;
private:
int x_ = 3;
FooGenericCallback pCallback_;
;
class Child : public Mother, public Interface<Child>
public:
int getValue()return Mother::getValue();
void setup(void)storeCallback(&isPositive_);
;
int main()
Child c;
c.setup();
cout << std::boolalpha << "Is " << c.getValue() << " positive? " << c.callCallback() << endl;
return 0;
这种设计有几个问题：
回调对象被存储两次 接口具有非函数成员属性：回调。 写一个lib很痛苦，因为你需要写方法和回调，而且你必须在所有使用你的回调的类中定义它！ 可能不适合使用 CRTP。为什么我使用 CRTP？见[这里]。(How to define a template specific type that can be inherited?)解决方案？
这可能吗？
我在正确的轨道上吗？如果不是，什么是正确的工具？
我在谷歌上搜索了几首曲目，但仍然不知道该怎么做：
1) 使用模板类型定义
不知道怎么做
2) 用作模板参数
我知道将函数作为模板参数传递是possible/valid
但是我的尝试没有成功：
#include <iostream>
#include <stdint.h>
using namespace std;
void* operator new(size_t size)
cout << "ERROR HEAP USED" << endl;
template <typename FunctionType = void, typename... ArgumentType>
class GenericCallback
public:
virtual ~GenericCallback()
virtual FunctionType Execute(ArgumentType... arg) = 0; //!< execute callback
virtual bool IsValid() const = 0; //!< check if callback is valid
;
template <typename ObjectType, typename FunctionType = void, typename... ArgumentType>
class Callback : public GenericCallback<FunctionType, ArgumentType...>
public:
Callback() ://!< Default constructor
pObject_m(0),
pFunction_m(0)
Callback(ObjectType* pObject_m, FunctionType(ObjectType::*pFunction_m)(ArgumentType...))//!< Constructor
this->pObject_m = pObject_m;
this->pFunction_m = pFunction_m;
virtual FunctionType Execute(ArgumentType... arg)//!< execute callback implementation
return (pObject_m->*pFunction_m)(arg...);
virtual bool IsValid(void) const//!< callback validity check implementation
return (pObject_m != 0) && (pFunction_m != 0);
private:
ObjectType* pObject_m; //!< pointer to object where the callback is defined
FunctionType(ObjectType::* pFunction_m)(ArgumentType...); //!< pointer to the callback (function-member) of the object
;
template<typename ChildCrtp>
class Interface
public:
using FooSpecificCallback = Callback<ChildCrtp, bool>;
using FooPrototype = bool(Interface::*)();
template<FooPrototype op>
FooSpecificCallback* checkIf(void)
//I'm trying to take the address of this temporary object, which is not legal in C++.
return &FooSpecificCallback(static_cast<ChildCrtp*>(this), op);
virtual int getValue(void) = 0;
bool IsNegative() return (getValue() < 0); ;
;
class Mother
public:
using FooGenericCallback = GenericCallback<bool>*;
int getValue()return x_;;
void storeCallback(FooGenericCallback pCallback)pCallback_ = pCallback;;
bool callCallback()return (pCallback_->IsValid() == false)?:pCallback_->Execute();;
private:
int x_ = 3;
FooGenericCallback pCallback_;
;
class Child : public Mother, public Interface<Child>
public:
int getValue()return Mother::getValue();
void setup(void)storeCallback(checkIf<&Child::IsNegative>());
;
int main()
Child c;
c.setup();
cout << std::boolalpha << "expectFalse: " << c.callCallback() << endl;
return 0;
我收到以下错误
error: taking address of temporary [-fpermissive]
由于不能获取临时对象的地址，这在 C++ 中是不合法的。
这个回调接口的问题是它需要一个指针来存储对象“FooGenericCallback”，它不能是“FooSpecificCallback”，因为对象类型在母类中是未知的。
3) 将回调实现为接口的其他方式
how to implement callback as an interface
但解决方案仍然使用对象将函数成员存储在接口（或接口的子接口）中。
4) Lambda...
我知道 lambdas 会简化我的生活，事实上我首先使用 lambdas 并且代码大小从 60kB 翻倍到 120kB（！），因为 lambdas 的存储方式：在 std::function 中。答案应该不是“lambda”:)
【问题讨论】：
PS 很好，PSS 可以接受，但是 PSSS 和 PSSSS 吓到我了。将附加信息合并到文本中而不是单独提供它们可能会更好。 同意，进行编辑。 哎呀，显然我不清楚，你把我的句子按字面意思理解了......我的意思是编辑不必在最后进行，而不是两个 PS 应该被保留......但无论如何它并不那么重要:) 我不明白你想达到什么目的。什么是Callback 模板，为什么不能使用std::mem_fn 之类的模板？
我不想使用std库有两个主要原因：1/我想掌握我正在编写的代码，所以制作我自己的lib，2/不想依赖std:function 因为那是我的代码在使用 lambdas 时加倍的原因。
【参考方案1】：
我可能过于简单化了您的需求，但有什么问题：
template<typename Base>
class Interface : public Base
public:
static bool IsNegative(Base* userData)
auto that = static_cast<Base*>(userData);
return that->getValue() < 0;
;
class Mother
public:
using Callback = bool (*) (Mother*);
int getValue() return x_;
void storeCallback(Callback pCallback) pCallback_ = pCallback;
bool callCallback() return pCallback_ ? (*pCallback_)(this) : throw 42;
private:
int x_ = 3;
Callback pCallback_;
;
class Child : public Interface<Mother>
public:
void setup() storeCallback(&Interface::IsNegative);
;
int main()
Child c;
c.setup();
std::cout << std::boolalpha << "expectFalse: " << c.callCallback() << std::endl;
Demo
【讨论】：
我喜欢另一种方法。我说我只有一种回调可能会误导你。实际上，我有两个不同的可能签名（一个用于条件，一个用于操作，因为我正在制作一组回调）。我编辑了我的帖子，所以它说我也需要第二个签名。无论如何，我将不得不调查你的提议！之后我给了一些反馈。 是来自设计模式还是什么？这种技术有名字吗？std::function之前可以处理“捕获”，C方式是用userData指针注册回调。在这里，我们似乎可以拥有更强大的类型。【参考方案2】：
我仍然不确定我是否正确理解了您的意图。但是下面的代码编译没有错误，虽然我没有进一步测试：
template<typename ChildCrtp>
class MotherInterface
protected:
//Callback types
using SomethingBooleanCallback = bool (ChildCrtp::*)();
protected:
//Helper methods
bool AlwaysTrue(void) return true; ;
SomethingBooleanCallback callback;
public:
void UseCallback(SomethingBooleanCallback a) callback = a;
bool CallCallback() return ((ChildCrtp *)this->*callback)();
;
template<typename ChildCrtp>
class SpecializedInterfaceA : public MotherInterface<ChildCrtp>
public:
/// methods to be overridden in child methods where the callbacks need to be bound
virtual int GetValue (void) const = 0;
protected:
///another helper methods
bool IsPositive(void) return (GetValue() > 0); ;
bool IsNegative(void) return (GetValue() < 0); ;
bool IsEven(void) return ((GetValue() % 2) == 0); ;
bool IsOdd(void) return ((GetValue() % 2) == 1); ;
;
template<typename ChildCrtp>
class ChildA1 : public SpecializedInterfaceA<ChildCrtp>
public:
//implements the interface
virtual int GetValue (void) const final override return value; ;
//bind the interfaces' callback by a reference to the object "isPositive", which contains a pointer to the desired method and a pointer to the object that owns the method)
void BindPositive(void) this->UseCallback(&ChildA1::IsPositive); ;
private:
//an attribute
int value;
;
【讨论】：
谢谢，但是：对于 CRTP，ChildA1 应使用模板class ChildA1 : public SpecializedInterfaceA<ChildA1> 。我将按原样使用它：int main() ChildA1 c; c.BindPositive(); c.CallCallback(); return 0;
此外，接口确实有一个属性“回调”，这是我想要避免的。但无论如何，你帮我澄清了我的问题。 :)
我的回调模板类完成了这项工作，但我不想把它放在这里以免问题过多。
如果要使用模板参数而不是属性，则需要将其添加到基类中！ PS： ChildA1 声明是从您的代码中复制的。
你几乎做到了。您几乎没有可修复的错误。设置应该看起来像：void setup(void)storeCallback(checkIf<&Child::IsNegative>());，checkIf 应该返回指向回调的指针，而不是 bool 等等......更重要的是 FooPrototype 应该是指向成员函数的指针，而不仅仅是任何函数 using FooPrototype = bool(Interface::*)();【参考方案3】：
这里是固定版本。
#include <iostream>
#include <stdint.h>
using namespace std;
template <typename FunctionType = void, typename... ArgumentType>
class GenericCallback
public:
virtual ~GenericCallback()
virtual FunctionType Execute(ArgumentType... arg) = 0; //!< execute callback
virtual bool IsValid() const = 0; //!< check if callback is valid
;
template <typename ObjectType, typename FunctionType = void, typename... ArgumentType>
class Callback : public GenericCallback<FunctionType, ArgumentType...>
public:
Callback() ://!< Default constructor
pObject_m(0),
pFunction_m(0)
Callback(ObjectType* pObject_m, FunctionType(ObjectType::*pFunction_m)(ArgumentType...))//!< Constructor
this->pObject_m = pObject_m;
this->pFunction_m = pFunction_m;
virtual FunctionType Execute(ArgumentType... arg)//!< execute callback implementation
return (pObject_m->*pFunction_m)(arg...);
virtual bool IsValid(void) const//!< callback validity check implementation
return (pObject_m != 0) && (pFunction_m != 0);
private:
ObjectType* pObject_m; //!< pointer to object where the callback is defined
FunctionType(ObjectType::* pFunction_m)(ArgumentType...); //!< pointer to the callback (function-member) of the object
;
template<typename ChildCrtp>
class Interface
public:
using FooSpecificCallback = Callback<ChildCrtp, bool>;
using FooPrototype = bool(Interface::*)();
template<FooPrototype op>
FooSpecificCallback* checkIf(void)
return new FooSpecificCallback(static_cast<ChildCrtp*>(this), op);
virtual int getValue(void) = 0;
bool IsNegative() return (getValue() < 0); ;
;
class Mother
public:
using FooGenericCallback = GenericCallback<bool>*;
int getValue()return x_;;
void storeCallback(FooGenericCallback pCallback)pCallback_ = pCallback;;
bool callCallback()return (pCallback_->IsValid() == false)?:pCallback_->Execute();;
private:
int x_ = 3;
FooGenericCallback pCallback_;
;
class Child : public Mother, public Interface<Child>
public:
int getValue()return Mother::getValue();
void setup(void)storeCallback(checkIf<&Child::IsNegative>());
;
int main()
Child c;
c.setup();
cout << std::boolalpha << "expectFalse: " << c.callCallback() << endl;
return 0;
PS：这段代码泄露了回调的指针，所以你需要添加代码来正确处理它。
【讨论】：
PSS: embedded C++ so only static allocation. = 无堆
哦。然后要么删除虚函数（你总是可以直接调用，因为它们无论如何都被实例化为相同的类型）并按值传递或以其他方式分配回调实例，例如从对象池......
哪个虚拟的？获取价值？我需要getValue虚函数，因为我需要我的接口提供一些基于子类中实现的getValue的方法
虚拟回调模板。基本上，您要么需要消除指向回调对象的指针，要么需要以某种方式分配回调对象。没有办法解决这个问题。作为一个最小的解决方案，您可以将FooSpecificCallback myCallback; 添加为Interface 的成员，并在每次调用checkIf 时重新初始化它。【参考方案4】：
这个解决方案的灵感来自 Jarod42 的回答，可以编译并运行。
将MotherA的属性x_更改为null、negative和positive并查看结果。
#include <iostream>
#include <stdint.h>
using namespace std;
static constexpr int STORE_SIZE = 4;
void* operator new(size_t size)
cout << "ERROR HEAP USED" << endl;
template<typename T, size_t storeSize>
class CallbackStore
public:
CallbackStore() : that_(nullptr) ;
CallbackStore(T* that) : that_(that) ;
using CallbackCondition = bool (*) (T*);
using CallbackAction = void (*) (T*,int);
struct Step
CallbackCondition pCallbackCondition;
CallbackAction pCallbackAction;
;
void setStep(int stepId,CallbackCondition pCallbackCondition, CallbackAction pCallbackAction)
if(stepId<storeSize)
store[stepId].pCallbackCondition = pCallbackCondition;
store[stepId].pCallbackAction = pCallbackAction;
else
cout << "pointer error" << endl;
void callStep(int stepId, int param)
if((stepId<storeSize) &&
(store[stepId].pCallbackCondition != nullptr) &&
(store[stepId].pCallbackAction != nullptr) &&
(that_ != nullptr))
bool isActive = (*(store[stepId].pCallbackCondition))(that_);
if(isActive) (*(store[stepId].pCallbackAction))(that_,param);
else
cout << "pointer error" << endl;
Step store[storeSize];
T* that_;
;
template<typename Base>
class Interface : public Base // interface
public:
static bool True(Base* baseInstance)
return true;
static bool IsNegative(Base* baseInstance)
return ((static_cast<Base*>(baseInstance))->getValue() < 0);
static bool IsNull(Base* baseInstance)
return ((static_cast<Base*>(baseInstance))->getValue() == 0);
static void PrintValue(Base* baseInstance, int value)
cout << "print this value : " << value << "." << endl;
;
class MotherA
public:
int getValue() return x_;
void setValue(int x) x_ = x;
private:
int x_ = -3;
;
class ChildA : public Interface<MotherA>, public CallbackStore<MotherA, STORE_SIZE>
public:
ChildA():Interface<MotherA>(), CallbackStore<MotherA, STORE_SIZE>(this);
void setup()
setStep(0, &Interface::IsNegative, &Interface::PrintValue );
setStep(1, &Interface::IsNull, &Interface::PrintValue );
setStep(2, &Interface::IsNull, &Interface::PrintValue );
setStep(3, &Interface::True, &Interface::PrintValue );
;
int main()
ChildA c;
c.setup();
for(int i = 0; i < STORE_SIZE; i++)
c.callStep(i,8);
// shall print "print this value : 8." 3 times if x_ is null, twice if x_ is negative.
【讨论】：
以上是关于是否可以制作仅具有函数成员属性的回调接口？的主要内容，如果未能解决你的问题，请参考以下文章