我正在尝试绑定一些ta-lib函数，然后回调。
这是简化的示例代码：
#include <functional>
#include <type_traits>
#include <cstdint>
struct DataChunk {
// ...
};
typedef uint64_t idx_t;
template <typename LookbackArgType> // int, double
struct talib_traits {
using talib_lookback_t = std::function<int(LookbackArgType)>;
using talib_function_t = std::function<void(DataChunk &, void *, idx_t, idx_t, LookbackArgType)>;
};
template <>
struct talib_traits<void> {
using talib_lookback_t = std::function<int()>;
using talib_function_t = std::function<void(DataChunk &, void *, idx_t, idx_t)>;
};
struct X {
talib_traits<int>::talib_lookback_t talib_lookback_int = nullptr;
talib_traits<int>::talib_function_t talib_function_int = nullptr;
talib_traits<double>::talib_lookback_t talib_lookback_double = nullptr;
talib_traits<double>::talib_function_t talib_function_double = …我想只允许在我的代码库中使用std :: function,如果它不进行任何分配.
为此我可以编写类似下面的函数的东西,只用它来创建我的函数实例:
template< typename Functor>
std::function<Functor> makeFunction( Functor f)
{
return std::function<Functor>(std::allocator_arg, DummyAllocator(), f);
}
如果DummyAllocator在运行时被使用,它将断言或抛出.
理想情况下,我想在编译时捕获分配用例.
即
template< typename Functor>
std::function<Functor> makeFunction( Functor f)
{
static_assert( size needed for function to wrap f < space available in function,
"error - function will need to allocate memory");
return std::function<Functor>(f);
}
这样的事情可能吗？
编辑:它不是重复的链接问题(也是我的).这里所有的返回类型都是
std::vector.我不想退货initializer-list.我想直接填写返回std::vector的initializer-list
让我们来看看这四个案例:
1)
//Acceptable
std::vector<int> foo(){
return std::vector<int>{1};
}
2)
//Acceptable
std::vector<int> foo(){
return {1};
}
3)
//Acceptable
std::function<std::vector<int>()> foo=[](){
return std::vector<int>{1};
};
4)
//NOT Acceptable
std::function<std::vector<int>()> foo=[](){
return {1};
};
为什么4不可接受,因为2是可以接受的？他们之间有什么不同？而且,这是可以接受的最奇怪的事情:
//Acceptable
auto bar=[]()->std::vector<int>{
return {1};
};
什么是错的std::function和initializer-list？
有没有办法防止std::functiongcc为更大的函数对象动态分配内存？
我希望以下代码在没有动态分配的情况下工作:
#include <functional>
#include <iostream>
// replace operator new and delete to log allocations
void* operator new (std::size_t n) {
std::cout << "Allocating " << n << " bytes" << std::endl;
return malloc(n);
}
void operator delete(void* p) throw() {
free(p);
}
class TestPlate
{
private:
int value;
public:
int getValue(){ return value; }
void setValue(int newValue) { value = newValue; }
int doStuff(const std::function<int()>& stuff) { return stuff(); }
};
int main()
{
TestPlate testor;
testor.setValue(15); …我正在尝试用 C++ 编写观察者模式，因此我有一个包含 eventname -> 回调函数向量的映射
回调函数存储在向量中，如下所示
std::function<void(void *)>
所以地图看起来像
std::unordered_map<std::string, std::vector<std::function<void(void *)>>>
我可以向向量添加侦听器并接收和响应事件通知。我的问题是实施分离。
所以 std::function 无法比较，因此擦除/删除已不再适用，所以我想搜索向量并手动比较。
我发现这个问题使用 std::function::target 成功地访问了底层指针，但我不能使用它，因为我使用 std::bind 来初始化回调：
std::function<void(void *)> fnCallback = std::bind(&wdog::onBark, this, std::placeholders::_1)
我只想比较底层成员函数 ptr，甚至与该成员函数关联的底层对象 ptr 进行比较。有什么办法吗？
我想避免将成员 fn ptr 包装在包含哈希的对象中，尽管看起来我可能必须这样做......
当泛型 lambda 被存储为 a 时std::function，我们需要提供一个具体的类型，比如，
std::function<double(double)>
因此绑定到特定类型，
以下声明：
std::function<auto(auto)>
引发编译器错误。
我知道，从 c++14 开始，auto可用于存储 lambda 的返回值，但是在将 lambda 存储在std::function.
考虑以下代码片段：
#include <functional>
namespace ns {
struct Arg{};
using Func = std::function<int(Arg)>;
Func operator+(Func lhs, Func rhs) {
return [lhs, rhs](Arg arg) {
return lhs(arg) + rhs(arg);
};
}
}
int main() {
ns::Func foo = [](ns::Arg i) {return 5;};
ns::Func bar = [](ns::Arg i) {return 2;};
auto foobar = foo + bar;
return foobar(ns::Arg());
}
上面的代码使用各种编译器进行编译。相反，以下代码段不会编译。唯一的区别是Func（Argvs int）内部使用的参数类型：
#include <functional>
namespace ns {
using Func = std::function<int(int)>;
Func operator+(Func lhs, Func rhs) {
return [lhs, …我遇到了一个问题。当我使用类似的东西时，std::function<A(Fs...)>它不起作用，但std::function<A(Fs..., B)>确实起作用。这是在 Clang 8.0 下；它在 GCC 下都不起作用。这是示例：
#include <functional>
template<typename A, typename B, typename ...Fs>
void func_tmpl1(std::function<A(Fs..., B)> callable)
{
}
template<typename A, typename ...Fs>
void func_tmpl2(std::function<A(Fs...)> callable)
{
}
class Cls1{};
void func0(std::function<void(float, Cls1)> callable)
{
}
int main()
{
std::function<void(float, Cls1)> f1 = [](float a, Cls1 b){};
func0(f1);
func0([](float a, Cls1 b){});
func_tmpl1<void, Cls1, float>(f1); // fails in GCC
func_tmpl2<void, float, Cls1>(f1);
func_tmpl1<void, Cls1, float>( // fails in GCC
[](float a, Cls1 b)
{ …我试图将一个指向谓词函数的指针传递给Foo和Bar函数。该Bar函数工作正常，但该Foo函数引发编译时错误：
错误：没有匹配的调用函数
Foo<int>(bool (&)(int))
为什么编译器会引发错误？' 解包后' Foos 和Bar's 模板参数类型之间有什么区别Args吗？
#include <functional>
bool predicate(int a) {
return (a > 5);
}
// sizeof...(Args) == 1 and I suppose it is int
template<typename... Args>
void Foo(std::function<bool(Args...)> predicate) {
// clang: note: candidate template ignored:
// could not match 'function<bool (int, type-parameter-0-0...)>'
// against 'bool (*)(int)'
}
template<typename Args>
void Bar(std::function<bool(Args)> predicate) {
}
int main(int argc, char const *argv[]) …c++ templates type-inference variadic-templates std-function
尝试std::bind()使用以下代码获取函数对象：
driver_manager driverManager();
std::function<void(mqtt::const_message_ptr,
mqtt::async_client*,callback*,sql::Driver*)> fn = std::bind(&driver_manager::test_callback, &driverManager, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
结果出错：
错误：从'std::_Bind_helper<false, void (driver_manager::*)(std::shared_ptr<const mqtt::message>, mqtt::async_client*, callback*, sql::Driver*), driver_manager ( *)()、const std::_Placeholder<1>&、const std::_Placeholder<2>&、const std::_Placeholder<3>&、const std::_Placeholder<4>&>::type'非标量类型 'std::function<void(std::shared_ptr<const mqtt::message>, mqtt::async_client*, callback*, sql::Driver*)>' 请求
几个小时以来，我一直试图找出问题所在，这段代码有什么问题？
编辑
driver_manager.hpp
class driver_manager{
public:
driver_manager();
void test_callback(mqtt::const_message_ptr, mqtt::async_client*,callback*,sql::Driver*);
};
driver_manager.cpp
driver_manager::driver_manager(){
}
void driver_manager::test_callback(mqtt::const_message_ptr msg, mqtt::async_client *client, callback *cb, sql::Driver *driver){
std::cout << "Callback triggered" << std::endl;
}