我不确定我是否定义了以下情况下的行为：
我的函数指针类型：
typedef void (*DoAfter_cb_type)(void);
应该分配回调的函数：
void DoSomething(DoAfter_cb_type & DoAfter_cb)
{
//...
DoAfter_cb = [](){
//...
};
}
呼叫者：
DoAfter_cb_type DoAfter_cb = nullptr;
DoSomething(DoAfter_cb);
// Here is something that has to be done after DoSomething but before DoAfter_cb.
if( DoAfter_cb != nullptr){
DoAfter_cb();
}
正如我在这里了解到的，lambda 可以隐式转换为函数指针。
然而 thoose 仍然是指针，我担心调用 lambda 的重要内容存储在堆栈中，如果我只返回函数指针，这些内容就会超出范围
我必须使用函数指针，因为我无法在我的环境中访问 std::function 。使用 std::function 我希望 lambda 对象存储在引用变量中，并且不会有任何问题。
行为是否与如果我只定义一个普通函数相同，或者我在这里有任何副作用吗？
......为前一个道歉
在C++中我们如何执行以下操作
// fundamental language construct
type name = value ;
// for example
int x = y;
用函数指针？
typedef (char)(*FP)(unsigned);
// AFAIK not possible in C++
FP x = y ;
我可以用lambdas:
FP x = []( unsigned k) -> char { return char(k); }
但我不知道如何在没有lambda的情况下做到这一点.有任何想法吗？
#include <functional>
void toggleOk(bool& b) { b = !b; }
void toggleBroken(bool b) { b = !b; }
void toggleInt(int i) { i = !i; }
void tooManyParams(bool b, int i) { i = !b; }
int main()
{
typedef std::function<void(bool&)> CallbackType;
typedef std::function<void(bool)> WrongCallbackType;
CallbackType cb1 = [](bool b) { b = !b; }; // Should throw error - missing reference
CallbackType cb2 = toggleOk; // Ok
CallbackType cb3 = toggleBroken; // Should throw error - missing reference
CallbackType …我正在尝试将 lambda 传递给CURLOPT_WRITEFUNCTION.
该函数需要一个静态函数，但是，我从这个问题中了解到lambda 将被隐式转换，并且我可以从 lambda 调用成员函数。
auto callback = [](char * ptr_data, size_t size, size_t nmemb, string * writerData)
->size_t
{
if(writerData == NULL)
return 0;
size_t data_size = size * nmemb;
writerData->append(ptr_data, data_size);
return (int)data_size;
};
CURLcode code = curl_easy_setopt(conn, CURLOPT_WRITEFUNCTION, callback);
这实际上编译，但卷曲段错误： Segmentation fault: 11
我在这里粘贴了完整的示例。
我试图将一个 lambda 作为参数传递给一个函数，但是一旦我尝试访问一个在 lambda 内部声明的变量，该变量在外部声明，构建就会失败： error: no matching function for call to 'AWS::subscribe(char [128], mainTask(void*)::<lambda(AWS_IoT_Client*, char*, uint16_t, IoT_Publish_Message_Params*, void*)>)'
我在想这[&]会处理捕获变量。我也试过[=]，以及[someVar]，[&someVar]。
我正在使用 C++11。
char someVar[128];
aws->subscribe(
topic,
[&] (AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen, IoT_Publish_Message_Params *params, void *pData) {
char *text = (char *)params->payload;
sprintf(someVar, "%s", text);
}
);
从 AWS 库：
void AWS::subscribe(const char *topic,
pApplicationHandler_t iot_subscribe_callback_handler) {
m_error =
::aws_iot_mqtt_subscribe(&m_client, topic, (uint16_t)std::strlen(topic),
QOS1, iot_subscribe_callback_handler, NULL);
}
据说，我有一个可变参数宏（例如，MY_MACRO(...)），我这样称呼它：
MY_MACRO(std::pair<int, int> const &p)
现在，__VA_ARGS__在我的宏的主体中将是std::pair<int, int> const &p.
有没有办法弄清楚的类型__VA_ARGS__？
据推测，如果像decltype(std::pair<int, int> const &p)work 和 yieldstd::pair<int, int> const&这样的东西，我会很感激，所以在我的可变参数宏的主体中decltype(__VA_ARGS__)也会 yield std::pair<int, int> const&。不幸的是，这不起作用。
看一下下面列出的代码示例，我使用编译器资源管理器（使用 gcc 和 clang）对其进行了测试，它可以工作并打印出 200 的（预期）输出。
我想弄清楚的是：为什么这个 C++ 是有效的。或者不是吗？
在这里，我使用关键字为 function typeusing定义别名（而不是 a ） ，它描述了采用 an作为参数并返回 an （是函数类型，而不是函数指针类型！）的函数。等效语法是. 由于 C++ 标准规定，每个函数都有一个使用该语法的等效形式，因此很明显，这是指定此函数类型的明确定义的方法。typedefftintintfttypedeftypedef int ft(int);typedefusingusing ft = int(int)
现在有趣的部分来了：我使用类型ft来指定另一个函数 () 的参数类型print_it，然后调用它，传递一个 lambda 函数。我的问题是：C++ 标准在哪里/如何说这实际上应该起作用？我认为这是传递 lambda 的一种非常简单的方法。我不清楚这是否有效，因为 lambda 实际上是一个函子，而不是严格意义上的函数。所以我认为尚不清楚这个 lambda 是否与类型匹配ft，因此可以传递给print_it（如果ft被定义为是的话std::function<int(int)>，那就很清楚了）。
代码示例：
#include <iostream>
using ft = int(int);
void print_it (ft f, int a)
{
std::cout << f(a) << …我想定义一个函数,它接受一个lambda函数(除了通常的输入参数).我想尽可能地限制该函数(它自己的输入和返回类型).
int myfunc( const int a, LAMBDA_TYPE (int, int) -> int mylamda )
{
return mylambda( a, a ) * 2;
}
这样我可以调用函数如下:
int input = 5;
myfunc( input, [](int a, int b) { return a*b; } );
定义的正确方法是myfunc什么？
有没有办法定义默认的lambda？像这样:
int myfunc( const int a, LAMBDA_TYPE = [](int a, int b) { return a*b; });
我有一个静态回调成员函数，它通过静态内联指针调用非静态窗口过程成员函数。问题是，它最终调用了最后一个实例。这是一个演示问题核心的例子：
#include <iostream>
struct A {
static inline A* pThis;
int i;
A(int i) : i(i) {
pThis = this;
}
static void foo() {
std::cout << pThis->i << std::endl;
}
};
int main() {
A a1(1);
A a2(2);
a1.foo(); // prints 2 instead of 1
a2.foo(); // prints 2 as expected
return 0;
}
请注意，我无法更改回调函数的签名，因此建议让 foo 接受参数是徒劳的。我该如何解决这个问题？
添加捕获元素时,为什么以下lambda不符合签名？
[&callback](unsigned handle, void* userData, void* data, unsigned size) -> void { ... }
但这会吗？
[](unsigned handle, void* userData, void* data, unsigned size) -> void { ... }
签名:
typedef void (*em_async_wget2_data_onload_func)(unsigned, void*, void*, unsigned);
首先，定义一个树节点，其中“ BFSTraversal呼吸优先”搜索ReconstructBFS是根据“宽度优先”搜索序列构造一棵树。
template<typename T>
struct TreeNode
{
T val;
TreeNode *left;
TreeNode *right;
explicit TreeNode(T x) : val(x), left(nullptr), right(nullptr)
{}
static void BFSTraversal(TreeNode *node, void visit(T));
static TreeNode<T> *ReconstructBFS(vector<T> &seq);
};
然后重载<<运算符，这将导致我不理解的编译器错误。我的lambda函数有问题吗？
template<typename T>
ostream &operator<<(ostream &os, TreeNode<T> *node)
{
void (*visit)(T) = [&os](T v) -> void
{ os << v << ','; };
// compiler error
// cannot convert 'operator<<(std::ostream&, TreeNode<T>*)
// [with T = int; std::ostream = std::basic_ostream<char>]::<lambda(int)>' …正如 @user17732522 指出的那样， 的删除器std::unique_ptr应该可以用一个指针作为参数来调用。
如何检索pcloseunique_ptr 被销毁时的返回值？
此代码片段无法编译，
#include<memory>
#include<iostream>
#include<string>
#include<cstdio>
int ExecCmd(const std::string& cmd, std::string& output)
{
int ret = 0;
{
std::unique_ptr<FILE, void(*)(FILE*, int*)> pipe(popen(cmd.c_str(), "r"), [](FILE* file, int* ret_ptr){
if(NULL==file)
{
*ret_ptr = -1;
}
else
{
*ret_ptr = pclose(file);
}
});
}
return ret;
}
int main()
{
}
而下面的代码片段可以编译。
#include<memory>
#include<iostream>
#include<string>
#include<cstdio>
int ExecCmd(const std::string& cmd, std::string& output)
{
int ret = 0;
{ …