我正在尝试创建一个类,它将使用可变数量的参数存储指向函数的指针,并在以后调用它.
我们的想法是为函数创建一个包装器,在对象析构时调用所述函数.这样我就可以确保在退出某些功能后进行一些清理.
我现在拥有的是由Faheem Mitha在here发布的一些修改后的代码.
这是带有示例的工作代码(我正在使用Visual Studio 2015编译它):
#include "stdafx.h"
#include <tuple>
#include <iostream>
using namespace std;
template<int...> struct seq {};
template<int N, int... S> struct gens : gens<N - 1, N - 1, S...> {};
template<int... S> struct gens<0, S...> { typedef seq<S...> type; };
template<typename Return, typename... Args> class CallOnExit
{
Return(*_func)(Args...);
std::tuple<Args...> _args;
template<int... S> Return call_func(seq<S...>)
{
return _func(std::get<S>(_args)...);
}
Return call()
{
return call_func(typename gens<sizeof...(Args)>::type());
}
public:
CallOnExit(Return(*func)(Args...), Args&&... args)
{
_func = func;
_args = std::forward_as_tuple(args...);
}
~CallOnExit()
{
if (_func != nullptr)
call();
}
};
void f(int i, double d)
{
cout << i << endl << d << endl;
}
int main()
{
{
CallOnExit<void, int, double> c(f, 1, 2);
}
cin.get();
return 0;
}
问题是我必须在Arduino平台上使用stl不可用(所以没有std :: tuple,没有std :: forward,没有std :: get). Arduino支持C 11.
没有stl使这个例子工作所需的最小工作量是多少?
最佳答案
The idea is to create a wrapper for function that will call said function when the object destructs. That way I can for example ensure some cleanup happens after exiting some function.
您尝试使用的代码似乎有点过于思考,或至少适合其他一些特定用途.对于上面的引用,这是我如何使用lambdas和简单函数完成任务.
现在调用可以按照您的喜好自定义,并且实现保持简单:
template< typename T > struct TRef{
TRef(T &in) : t(in) {}
~TRef(){ t(); }
T t;
};
template< typename T > TRef<T> RunOnExit(T t){
return TRef<T>( t );
}
void setup() {
Serial.begin(9600);
}
void loop() {
int a = 3, b = 4;
auto test = RunOnExit( [](){ func(1, 2); } );
{
auto test1 = RunOnExit( [&a, &b](){ func(a, b); } );
}
}
void func( int a, int b){
auto pause = RunOnExit( wait );
Serial.print( a, HEX );
Serial.print( ", " );
Serial.println( b, HEX );
}
void wait(){ delay(500); }