相关疑难解决方法(0)

我一直在听C++中的仿函数.有人可以给我一个关于它们是什么的概述以及在什么情况下它们会有用吗？

The C++ Standard Library (Second Edition)Nicolai Josuttis 在其着作中指出,编译器可以比普通函数更好地优化lambdas.

此外,C++编译器比普通函数更好地优化lambdas.(第213页)

这是为什么？

我认为在内联时不应该有任何差别.我能想到的唯一原因是编译器可能有一个更好的本地上下文与lambdas,这样可以做出更多假设并执行更多优化.

我目前正在研究一些日志代码,它们应该 - 除其他外 - 打印有关调用函数的信息.这应该相对容易,标准C++有一个type_info类.它包含typeid'd类/函数/ etc的名称.但它被破坏了.它不是很有用.即typeid(std::vector<int>).name()回归St6vectorIiSaIiEE.

有没有办法从中产生有用的东西？就像std::vector<int>上面的例子一样.如果它只适用于非模板类,那也没关系.

该解决方案应该适用于gcc,但如果我可以移植它会更好.这是为了记录所以它不是那么重要,它不能被关闭,但它应该有助于调试.

我试图创建一个lambda矢量,但失败了:

auto ignore = [&]() { return 10; };  //1
std::vector<decltype(ignore)> v;     //2
v.push_back([&]() { return 100; });  //3

直到第2行,它编译得很好.但第3行给出了编译错误:

错误:没有匹配函数来调用'std :: vector <main():: <lambda()>> :: push_back(main():: <lambda()>)'

我不想要一个函数指针向量或函数对象向量.但是,封装真实 lambda表达式的函数对象向量对我有用.这可能吗？

我想做这样的事情:

int main()
{
    auto f = [/*some variables*/](/*take lambda function*/)
    {/*something with lambda function*/};

    f([/*other variables*/](/*variables to be decided by f()*/)
    {/*something with variables*/});
}

我知道可以将lambda传递给函数,也可以传递给lambda.以下作品:

int main()
{
    int x=0;
    int y=0;
    auto f = [x,y](double (func)(int)) -> double
    {func(0); return 0.0;};

    f([](int i) -> double
    {return 0.0;});
}

但以下不起作用(只要我将范围变量更改为添加[x])

int main()
{
    int x=0;
    int y=0;
    auto f = [x,y](double (func)(int)) -> double
    {func(0); return 0.0;}

    f([x](int i) -> double    //[x] does not work
    {return 0.0;});
} …

据我所知,所有数据类型必须在编译时知道,而lambda不是一个类型.lambda被翻译成anonymous struct with operator()或std::function包裹？

例如,

std::for_each(v.begin(), v.end(), [](int n&){n++;});

有这个代码:

auto fun = [](int x)->int {return x + 1; };
std::cout << typeid(fun).name() << std::endl;

结果是:Z4mainEUliE_但c ++ filt似乎没有解释它是什么.什么是lambda表达式？

我正在编写一个使用的应用程序boost::asio.Asio async_receive(或async_read)总是使用boost::bind给出的回调对象显示:

boost::asio::async_read(socket_,
                        boost::asio::buffer(read_msg_.data(),
                                            chat_message::header_length),
                        boost::bind(&chat_session::handle_read_header,
                                    shared_from_this(),
                                    boost::asio::placeholders::error));

这非常好,但我不想在每次调用回调后重新创建绑定对象.相反,我想在我的类的构造函数中创建对象,并将其赋予async_receive.

问题是,我不知道如何将该对象声明为类成员.我所知道的只是汽车,它显然不会作为班级成员.

class Whatever
{
public:
    Whatever()
    {
        functor = boost::bind(&Whatever::Callback);
    }
private:
    void Callback()
    {
        boost::asio::async_read(socket_,
                        boost::asio::buffer(read_msg_.data(),
                                            chat_message::header_length),
                        functor);
    }

    ?? functor; // How do I declare this?
    ...
};

注意:这可能是过早优化,但我仍然想知道如何在没有auto的情况下声明绑定对象.

你能解释一下L这种背景下的哪种类型.换句话说,我可以使用什么类型的auto关键字？

int main(){
 int x=0;
 auto L = [x] (int y)->bool{
   return x>y;
 };
  return 0; 
}

谁能解释 lambda 函数是如何在 std::function 中表示的？编译器和 std::function 是否有隐式转换用作容器？

我最近问了一个稍微不同的问题，它被标记为这个问题的重复。答案是未定义和未指定 lambda 函数的类型。我发现一些代码似乎为 lambda 函数提供了一个容器，如下所示。我还包含了 Stroustrup 引用，这似乎与 lambda 函数没有定义类型相矛盾，但说它是一个函数闭包类型。这只会进一步混淆问题。

更新：关于 function<> 实现的部分答案在这里。

感谢您的指导。

#include <iostream>
#include <vector>
#include <functional>
using namespace std;

static vector<function<void(int)>> cbl;
static vector<function<int(int)>> cblr;

class GT {
public:
    int operator()(int x) {return x;}
};

void f()
{
    auto op = [](int x) {cout << x << endl;}; 
    cbl.push_back(op);

    for (auto& p : cbl)
        p(1);

    auto op2 = [](int x) {return x;};
    cblr.push_back(op2);
    cblr.push_back(GT()); …